二叉树的基本操作

二叉树的基本操作

定义一个Node类，来表示二叉树中的一个节点

class Node{
    public char val;
    public Node left;
    public Node right;
    public Node(char val){
        this.val = val;
    }
}

定义一个BinaryTree类，在类中实现以下函数

public class BinaryTree {
    public Node root;//根节点
}

二叉树的遍历（递归）

前序遍历（先序遍历）

访问顺序：根–左子树–右子树

public void preOrderTraversal(Node root){
        if (root == null) return;
        System.out.print(root.val+" ");
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);
    }

中序遍历

访问顺序：左子树–根--右子树

    public void inOrderTraversal(Node root){
        if (root == null) return;
        inOrderTraversal(root.left);
        System.out.print(root.val+" ");
        inOrderTraversal(root.right);
    }

后序遍历

访问顺序：左子树–右子树–根

    public void postOrderTraversal(Node root){
        if (root == null) return;
        postOrderTraversal(root.left);
        postOrderTraversal(root.right);
        System.out.print(root.val+" ");
    }

求节点个数

//求节点个数-遍历思路
    int size = 0;
    public void getSize1(Node root){
        if (root == null) return;
        size++;//根
        getSize1(root.left);
        getSize1(root.right);
        //前序遍历，遍历一个节点size+1
    }
    //求节点个数-子问题思路
    public int getSize2(Node root){
        if (root == null) return 0;
        return getSize2(root.left) + getSize2(root.right) +1;
        //总节点个数=根的左子树的节点个数+根的右子树节点个数+根
    }

求叶子节点个数

    //求叶子节点个数-遍历
    int leafSize = 0;
    public void getLeafSize1(Node root){
        if (root == null) return;
        if (root.left == null && root.right == null) {
            leafSize++;//一个节点没有左子树没有右子树就是一个叶子结点
        }
        getLeafSize1(root.left);
        getLeafSize1(root.right);
    }
    //求叶子结点个数-子问题
    public int getLeafSize2(Node root){
        if (root == null) return 0;
        if (root.left == null && root.right == null)
            return 1;//一个节点没有左子树没有右子树就是一个叶子结点
        return getLeafSize2(root.left)+getLeafSize2(root.right);
        //叶子节点个数=根的左子树的叶子节点+根的右子树的叶子结点
    }

求第k层节点个数

      public int getKLevelSize(Node root,int k){
        if (root == null) return 0;
        if (k == 1) return 1;//只有一个节点就是根节点
        return getKLevelSize(root.left,k-1)+getKLevelSize(root.right,k-1);
        //第k层的节点个数=上一层节点的左子树节点个数+上一层节点的右子树节点个数
    }

求二叉树的高度

    public int getHigth(Node root){
        if (root == null) return 0;
        int leftSize = getHigth(root.left);//根的左子树高度
        int rightSize = getHigth(root.right);//根的右子树高度
        return leftSize > rightSize ? leftSize+1 : rightSize+1;
        //比较左子树和右子树高度，高的+根
    }

查找val所在的节点

查找val所在的节点个数，一旦找到立即返回，不需要继续在其他位置查找 先序遍历查找

    public Node find(Node root,int val){
        if (root == null) return null;
        if (root.val == val) return root;//判断根
        Node r = find(root.left,val);//判断左子树中有没有val所在节点
        if (r != null) return r;
        r = find(root.right, val);//判断右子树中有没有val所在节点
        if (r != null) return r;
        return null;
    }

实现

创建了一个二叉树（穷举法）

    public Node creatTree(Node root){
        Node A = new Node('A');
        Node B = new Node('B');
        Node C = new Node('C');
        Node D = new Node('D');
        Node E = new Node('E');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        return A;
    }

定义一个测试类，测试这些函数的输出

public class TestDemo {
    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        Node node = binaryTree.creatTree(binaryTree.root);
        binaryTree.preOrderTraversal(node);//前序遍历
        System.out.println();
        binaryTree.inOrderTraversal(node);//中序遍历
        System.out.println();
        binaryTree.postOrderTraversal(node);//后序遍历
        System.out.println();
        System.out.println(binaryTree.getSize2(node));//总节点个数
        System.out.println(binaryTree.getLeafSize2(node));//叶子节点个数
        System.out.println(binaryTree.getKLevelSize(node, 3));//第3层节点个数
        System.out.println(binaryTree.getHigth(node));//高度
        Node ret = binaryTree.find(node,'C');//查找C
        System.out.println(ret.val);
    }
}