二叉树

树 ：

• 子树是不相交的
• 除根结点外，每个结点有且仅有一个父结点
• 一棵 N 个结点的树有 N-1 条边

二叉树：

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

二叉树的特点：

• 1. 每个结点最多有两棵子树，即二叉树不存在度大于 2 的结点。
• 2. 二叉树的子树有左右之分，其子树的次序不能颠倒，因此二叉树是有序树

两种特殊二叉树：

• 1、满二叉树：每一个层的结点数都达到最大值
• 2、完全二叉树：对于深度为K的，有n个结点的二叉树，每一个结点都与
• 深度为K的满二叉树中编号从1至n的结点一一对应
  （应先放每个结点的左子树，再放这个结点的右子树，依次放入）
  （满二叉树是一种特殊的完全二叉树）

二叉树的性质：

• 1. 二叉树的 第 i 层 上最多有 2^(i-1) 个结点 (i>0)
• 2. 深度为 K 的二叉树的 最大结点数 是 2^k -1 其中(k>=0)
• 3. 一棵二叉树, 叶结点个数为 n1, 度为2的非叶结点个数为 n2,则 n1＝n2＋1
• 4. 具有 n个结点 的 完全二叉树 的 深度k 为 log2(n+1)向上取整
• 5. 具有n个结点 的 完全二叉树，如果按照 从上至下 从左至右 的顺序 对所有节点
• 从0开始编号，则对于序号为 i 的结点有：
  双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
  （已知 子结点序号，求 父结点序号 ： (i-1)/2 ）
  若2i+1<n，左孩子序号：2i+1，否则无左孩子
  （已知 父结点序号，求 左孩子结点序号 ：2i+1 ）
  若2i+2<n，右孩子序号：2i+2，否则无右孩子
  （已知 父结点序号，求 右孩子结点序号 ： 2i+2 ）

二叉树的遍历方式：

•  前序遍历 ： 根 -》 左 -》 右
  

•  中序遍历 ： 左 -》 根 -》 右
  

•  后序遍历 ： 左 -》 右 -》 根
  

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

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

public class BinaryTree {

前序遍历

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 + "");
    }

遍历思路-求结点个数

static int size = 0;
    public void getSize1(Node root){
        if (root == null) {
            return;
        }
        size++;
        getSize1(root.left);
        getSize1(root.right);
    }

子问题思路-求结点个数

public int getSize2(Node root){
        if (root == null) {
            return 0;
        }
        return  getSize2(root.left) + getSize2(root.right) + 1;
    }

遍历思路-求叶子结点个数

static int leafSize = 0;
    public void getLeafSize1(Node root){
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            leafSize++;
        }else {
            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);
    }

获取二叉树的高度

public int getHeight(Node root){
        if (root == null) {
            return 0;
        }
        int left = getHeight(root.left);
        int right = getHeight(root.right);
        return left > right ? left+1 : right+1;
    }

查找 val 所在结点，没有找到返回 null
按照 根 -> 左子树 -> 右子树的顺序进行查找
一旦找到，立即返回，不需要继续在其他位置查找

public Node find(Node root, char val){
        if (root == null) {
            return null;
        }
        if (val == root.val) {
            return root;
        }
        Node left = find(root.left,val);
        if (left != null) {
            return left;
        }
        Node right = find(root.right,val);
        if (right != null) {
            return right;
        }
        return null;
    }

两棵二叉树是否相同

public boolean isSameTree(Node p, Node q) {
        if ((p == null && q != null) || (p != null && q == null)) {
            return false;
        }
        if (p == null && q == null) {
            return true;
        }
        if (p.val != q.val) {
            return false;
        }
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

一颗二叉树是否包含另一颗二叉数的所有

public boolean isSubtree(Node s, Node t) {
        if (s == null || t == null) {
            return false;
        }
        if (isSameTree(s,t)) {
            return true;
        }
        if (isSubtree(s.left,t)) {
            return true;
        }
        if (isSubtree(s.right,t)) {
            return true;
        }
        return false;
    }

层序遍历

public void levelOrderTraversal(Node root) {
        if (root == null) {
            return;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Node cur = queue.poll();
            System.out.print(cur.val + " ");
            if (cur.left != null) {
                queue.offer(cur.left);
            }
            if (cur.right != null) {
                queue.offer(cur.right);
            }
        }
        System.out.println();
    }

}