二叉树（Java实现）

一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根节点加上两棵别称为左子树和右子树的二叉树组成。
二叉树的特点：

• 二叉树不存在度大于2的结点。
• 二叉树的子树有左右之分，且不能颠倒次序。

两种特殊的二叉树：

• 完全二叉树：对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。
• 满二叉树：如果一个二叉树的层数为K，且结点总数是(2^k) -1 ，则它就是满二叉树。
  

二叉树的遍历

1. NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。（根左右）
2. LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。（左根右）
3. LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。（左右根）
4. 层序遍历：从上到下，从左至右。
   
   如图，改二叉树的各个遍历结果为
   前序：A B D E C F G
   中序：D B E A F C G
   后序：D E B F G C A
   层序：A B C D E F G

遍历及求结点代码：
重点在于递归

package packagetree;
class Node{
    Node left;
    Node right;
    char val;

    public Node(char val) {
        this.val = val;
    }
}
public class BinaryTree {
    //空树
    private static Node root = null;
    //构建一棵树
    public static Node 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.right = G;
        C.right = F;
        return A;
    }
    //先序遍历
    public static void preOrder(Node root){
        if(root == null){
            return;
        }
        //访问用打印表示
        System.out.print(root.val);
        preOrder(root.left);
        preOrder(root.right);
    }
    //中序遍历
    public static void inOrder(Node root){
        if(root == null){
            return;
        }
        inOrder(root.left);
        System.out.print(root.val);
        inOrder(root.right);
    }
    //后序遍历
    public static void postOrder(Node root){
        if(root == null){
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val);
    }
    //层序遍历
        public void levalOrder(Node root){
        if(root == null){
            return;
        }
        //创建一个队列辅助进行遍历
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            //循环取队首元素，并访问
            Node cur = queue.poll();
            System.out.println(cur.val + " ");
            //把当前这个队首元素左子树右子树都插入到队列中
            if(cur.left != null){
                queue.offer(cur.left);
            }
            if(cur.right != null){
                queue.offer(cur.right);
            }
        }
    }
    //求树的结点
    public static int size(Node root){
        if(root == null){
            return 0;
        }
        return 1 + size(root.left) + size(root.right);
    }
    //求树的叶子结点个数
    public static  int getLeafSize(Node root){
        if(root == null){
            return 0;
        }
        if(root.left == null && root.right == null) {
            return 1;
        }
        return getLeafSize(root.left) + getLeafSize(root.right);
    }
}