二叉树的基本代码实现(关于节点) -- JAVA

1. 首先，构建一棵树。

	static class Node {
        public char val;
        public Node left;
        public Node right;

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

        @Override
        public String toString() {
            return "Node{" +
                    "val=" + val +
                    ", left=" + left +
                    ", right=" + right +
                    '}';
        }
    }

    static Node build() {
        // 通过 build 方法构建一棵树，返回树的根节点
        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');
        Node F = new Node('F');
        Node G = new Node('G');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        E.left = G;
        C.right = F;
        return A;
    }

2. 计算节点个数

	public static int size(Node root) {
        // 计算结点个数
        if (root == null) {
            // 空树里有 0 个结点
            return 0;
        }
        // 整个树的结点 = 根结点个数 + 左子树个数 + 右子树个数
        return 1 + size(root.left) + size(root.right);
    }

3. 计算叶子节点

	public static int leafSize(Node root) {
        if (root == null) {
            return 0;
        }
        if(root.left == null && root.right == null) {
            //满足条件即为叶子结点
            return 1;
        }
        //当前叶子结点个数 = 左子树叶子结点个数 + 右子树叶子结点个数
        return leafSize(root.left) + leafSize(root.right);
    }

4. 计算第 k 层节点个数

	public static int kLevelSize(Node root, int k) {
        //求第 k 层结点个数
        if (root == null || k < 1) {
            return 0;
        }
        if(k == 1) {
            return 1;
            //根节点一定为 1（空树除外）
        }
        //第k层结点个数 = 其左子树的 k-1 层结点个数 + 其右子树的 k-1 层结点个数
        return kLevelSize(root.left, k-1) + kLevelSize(root.right, k-1);
    }

5. 查找 val 所在节点

	public static Node find(Node root, char toFind) {
        // 查找 val 所在结点，没有找到返回 null
        if (root == null) {
            return null;
        }
        if(root.val == toFind) {
            // 判断根结点是否为 toFind
            return root;
        }
        Node result = find(root.left, toFind);
        if(result != null) {
            return result;
        }
        return find(root.right, toFind);
    }

6. 检验两个二叉树是否相同

	static Node p() {
		// 给定二叉树 p
        Node num1 = new Node(1);
        Node num2 = new Node(2);
        num1.left = num2;
        return num1;
    }
    static Node q() {
    	// 给定二叉树 q
        Node num1 = new Node(1);
        Node num2 = new Node(2);
        num1.right = num2;
        return num1;
    }
    public static boolean isSameTree(Node p, Node q) {
        //给定两个二叉树，编写一个函数来检验它们是否相同.
        //如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的.
        if(p == null && q == null) {
            return true;
        }
        if(p != null && q != null && p.val == q.val) {
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        }else {
            return false;
        }
    }

8. 主函数调用

	public static void main(String[] args) {
        Node root = build();
        System.out.println(size(root)); // 7
        System.out.println(leafSize(root)); // 3
        System.out.println(kLevelSize(root, 3)); // 3

        Node result = find(root, 'G');
        System.out.println(result);
        // Node{val = G, left = null, right = null}
        Node result1 = find(root, 'C');
        System.out.println(result1);
        // Node{val = C, left = null, right = Node{val = F,  left = null, right = null}}

		boolean ret = isSameTree(p(), q());
        System.out.println(ret);

    }