二叉树操作（Java语言）

基本概念

树

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

二叉树

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



二叉树具有以下性质：

1. 非空二叉树的第n层上至多有2^(n-1)个元素。
2. 深度为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));