二叉树操作（Java语言）

基本概念

树

除了根节点之外，每个节点只要一个父节点，根节点没有父节点。除了叶节点之外，所有节点都有一个或者多个节点，叶节点没有子节点。父节点和子节点之间用指针相连。

二叉树

所谓二叉树是树的一种特殊结构，在二叉树中每个节点最多只能拥有两个子节点。



二叉树具有以下性质：

非空二叉树的第n层上至多有2^(n-1)个元素。

深度为h的二叉树至多有2^h-1个结点。

数据结构定义

public class BTNode {
int val; //值
BTNode left;    //左子树
BTNode right;   //右子树
public BTNode(){

}
public BTNode(int val){
this.val = val;
}
public BTNode(int val, BTNode left, BTNode right) {
this.val = val;
this.left = left;
this.right = right;
}

}

二叉树操作

遍历

遍历即将树的所有结点访问且仅访问一次。按照根节点位置的不同分为前序遍历，中序遍历，后序遍历。

前序遍历：先访问根结点，再访问左子结点，最后访问右子结点

中序遍历：先访问左子结点，再访问根结点，最后访问右子结点

后序遍历：先访问左子结点，再访问右子结点，最后访问根结点

如下图所示二叉树



前序遍历：10 6 4 2 8 14 12 16

中序遍历：2 4 6 8 10 12 14 16

后序遍历：2 4 8 6 12 16 14 10

代码实现

前序遍历

/**
* 前序遍历
* 先访问根结点，再访问左子结点，最后访问右子结点
* @param root
*/
public void preorder(BTNode root){
//先访问根结点
System.out.print(root.val+" ");
if(root.left!=null){
preorder(root.left);
}
if(root.right!=null){
preorder(root.right);
}
}

中序遍历

/**
* 中序遍历
* 先访问左子结点，再访问根结点，最后访问右子结点
* @param root
*/
public void middleorder(BTNode root){
//先访问左子结点
if(root.left!=null){
middleorder(root.left);
}
System.out.print(root.val+" ");
if(root.right!=null){
middleorder(root.right);
}
}

后序遍历

/**
* 后序遍历
* 先访问左子结点，再访问右子结点，最后访问根结点
* @param root
*/
public void lastorder(BTNode root){

if(root.left!=null){
lastorder(root.left);
}
if(root.right!=null){
lastorder(root.right);
}
System.out.print(root.val+" ");
}

层次遍历

/**
* 层次遍历
* @param root
*/
public void layerorder(BTNode root){
if(root==null){
return;
}
//队列,先进先出
Queue<BTNode> queue = new LinkedList<>();
queue.add(root);
while(!queue.isEmpty()){

BTNode node = queue.poll();

System.out.print(node.val+" ");

if(node.left!=null){
queue.add(node.left);
}
if(node.right!=null){
queue.add(node.right);
}
}
}

获取二叉树的高度

/**
* 获取二叉树的高度
* @param root
* @return
*/
public int getHeight(BTNode root){
if(root==null){
return 0;
}
int left = getHeight(root.left);
int right = getHeight(root.right);

int h = (left>right?left:right)+1;

return h;
}

获取二叉树结点的数量

/**
* 获取二叉树结点的数量
* @param root
* @return
*/
public int getCount(BTNode root){
if(root==null){
return 0;
}
return getCount(root.left)+getCount(root.right)+1;
}

判断两棵 二叉树 是否相等

/**
* 判断两棵 二叉树 是否相等
* @param root1
* @param root2
* @return
*/
public boolean equals(BTNode root1, BTNode root2){
if((root1==null && root2==null) ||root1.val == root2.val){
return true;
}

if(equals(root1.left, root2.left) && equals(root1.right, root2.right)){
return true;
}

return false;
}

测试代码

//构造上图中的二叉树
BTNode node8 = new BTNode(2);

BTNode node4 = new BTNode(4, node8, null);
BTNode node5 = new BTNode(8);

BTNode node2 = new BTNode(6, node4, node5);

BTNode node6 = new BTNode(12);
BTNode node7 = new BTNode(16);

BTNode node3 = new BTNode(14, node6, node7);

BTNode root = new BTNode(10, node2, node3);

System.out.println("前序遍历:");
preorder(root);

System.out.println("--------------");

System.out.println("中序遍历:");
middleorder(root);

System.out.println("--------------");

System.out.println("后序遍历:");
lastorder(root);

System.out.println("--------------");

System.out.println("层次遍历:");
layerorder(root);

System.out.println("--------------");
System.out.println("结点数量："+getCount(root));

System.out.println("--------------");
System.out.println("高度："+getHeight(root));