二叉树的基本知识

树结构

1.定义树结构：
a.子树是不相交的
b.除了根节点外，每个节点有且仅有一个父节点
c.一棵N个结点的树有N-1条边
2.概念
a.节点的度：一个节点含有的子树的个数
b.叶子节点或终端节点：度为0的节点成为叶节点
双节点或父节点：若一个节点含有子节点，则这个节点成为其子节点的父节点
孩子节点或子节点：一个节点含有的子树的根节点成为该节点的子节点
根节点：一棵树中，没有双亲结点的结点
节点的层次：从根开始定义起，根为第一层，根的子节点为第二层，以此类推
树的深度与高度：树的每一层都是一个深度，深度最大的为高度

二叉树

1.二叉树的特点：
a. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
b. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树。
2.两种特殊的二叉树
a.完全二叉树：若一个节点有右树，则必然存在左树

b.满二叉树：特殊的完全二叉树

3.二叉树的性质：
a. 若规定根节点的层数为1，则一棵非空二叉树的第i层上
最多有2^(i-1) (i>0)个结点
b.若规定只有根节点的二叉树的深度为1，则深度为K的二叉树的
最大结点数是2^k -1 (k>=0)
c. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,
则有n0＝n2＋1
d. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i
的结点有：
若i>0，双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
若2i+1<n，左孩子序号：2i+1，否则无左孩子
若2i+2<n，右孩子序号：2i+2，否则无右孩子

二叉树的链式存储(递归孩子表示法)

// 孩子表示法
class Node {
 int val; // 数据域
 Node left; // 左孩子的引用，常常代表左孩子为根的整棵左子树
 Node right; // 右孩子的引用，常常代表右孩子为根的整棵右子树
}

具体实现如下：

public class MyBinaryTree {
    // 孩子兄弟表示法
    private static class Node {
        private char val;
        private Node left;
        private Node right;
        public Node(char val) {
            this.val = val;
        }
    }

    // 生成一个测试二叉树
    public Node buildATree() {
        Node nodeA = new Node('A');
        Node nodeB = new Node('B');
        Node nodeC = new Node('C');
        Node nodeD = new Node('D');
        Node nodeE = new Node('E');
        Node nodeF = new Node('F');
        Node nodeG = new Node('G');
        Node nodeH = new Node('H');
        nodeA.left = nodeB;
        nodeA.right = nodeC;
        nodeB.left = nodeD;
        nodeB.right = nodeE;
        nodeE.left = nodeG;
        nodeG.right = nodeH;
        nodeC.right = nodeF;
        return nodeA;
    }
    // 先序遍历(输出内容)
    // 根左右
    // 传入一个二叉树的根节点，根据先序遍历访问该树
    public void preOrder(Node root) {
        if (root == null) {
            return;
        }
        // 根
        System.out.print(root.val +" ");
        // 左树
        preOrder(root.left);
        // 右树
        preOrder(root.right);
    }

    /**
     * 传入一个二叉树的根节点root，根据中序遍历访问该树
     * 左根右
     * @param root 传入的根节点
     */
    public void inOrder(Node root) {
        if (root == null) {
            return;
        }
        // 先按照中序遍历访问左子树
        inOrder(root.left);
        System.out.print(root.val + " ");
        // 按照中序再访问右子树
        inOrder(root.right);
    }

    /**
     * 按照后序遍历访问二叉树
     * @param root
     */
    public void postOrder(Node root) {
        if (root == null) {
            return;
        }
        // 先左
        postOrder(root.left);
        // 再右
        postOrder(root.right);
        System.out.print(root.val +" ");
    }

    /**
     * 传入一个二叉树的根节点，求出该二叉树的节点个数
     * @param root 二叉树的根节点
     * @return
     */
    public int getNodeCount(Node root) {
        if (root == null) {
            return 0;
        }
        return 1 + getNodeCount(root.left) + getNodeCount(root.right);
    }

    /**
     * 传入一个二叉树根节点root，就能求得该二叉树的叶子节点个数
     * @param root 传入根节点
     * @return
     */
    public int getLeafNodeCount(Node root) {
        // 空树
        if (root == null) {
            return 0;
        }
        // 只有根节点
        if (root.left == null && root.right == null) {
            return 1;
        }
        // 此时二叉树不为空且有子树
        // 此时二叉树叶子节点个数 = 左树叶子节点个数 + 右树的叶子节点个数
        return getLeafNodeCount(root.left)
                + getLeafNodeCount(root.right);
    }

    /**
     * 传入一个根节点root，就能求得该树高度
     * @param root 传入二叉树根节点
     * @return
     */
    public int height(Node root) {
        if (root == null) {
            return 0;
        }
        // 左树高度 height(root.left) -> 以root.left为根节点的高度
        // 二叉树不为空 1 + Math.max(左树高度，右树高度);
        return 1 + Math.max(height(root.left),height(root.right));
    }

    /**
     * 判断一颗以root为根节点的二叉树中是否包含值为val的节点
     * @param root
     * @param val
     * @return
     */
    public boolean contains(Node root,char val) {
        if (root == null) {
            return false;
        }
        if (root.val == val) {
            return true;
        }
        // 在左树或右树中寻找val
        return contains(root.left,val) || contains(root.right,val);
    }

    /**
     * 传入一个二叉树的根节点root，求出第k层节点个数
     * @param root
     * @param k
     * @return
     */
    public int getKLevelNodes(Node root,int k) {
        if (k <= 0 || root == null) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        return getKLevelNodes(root.left,k - 1) +
                getKLevelNodes(root.right,k - 1);
    }



    public static void main(String[] args) {
        MyBinaryTree myBinaryTree = new MyBinaryTree();
        Node root = myBinaryTree.buildATree();
        System.out.println("先序遍历结果:");
        myBinaryTree.preOrder(root);
        System.out.println();
        System.out.println("-----------------");
        System.out.println("中序遍历结果:");
        myBinaryTree.inOrder(root);
        System.out.println();
        System.out.println("------------------");
        System.out.println("后序遍历结果:");
        myBinaryTree.postOrder(root);
        System.out.println("二叉树节点个数为:");
        System.out.println(myBinaryTree.getNodeCount(root));
        System.out.println("二叉树的叶子节点个数为:");
        System.out.println(myBinaryTree.getLeafNodeCount(root));
        System.out.println("二叉树的高度为:");
        System.out.println(myBinaryTree.height(root));
        System.out.println(myBinaryTree.contains(root,'H'));
        System.out.println(myBinaryTree.contains(root,'X'));
        System.out.println("二叉树第4层节点个数:");
        System.out.println(myBinaryTree.getKLevelNodes(root,4));
    }