二叉树

树 

N个结点的树有N-1个边

c狐狸根节点外，每个结点有且只有一个父节点

子树是不相交的

结点的度:指含有子树的个数

树的度:所有结点度中最大值称为树的度。

叶子结点:度为0的结点

双亲结点:上层与此结点相连的结点

孩子结点:下层与此结点相连的结点

根结点:没有双亲结点的结点。

层数：根为1层，随后逐层+1

树的深度:最大层

祖先：双亲结点以上的结点

子孙：孩子结点以下的结点

森林:由m个互不相交的树组成的集合

一般用孩子兄弟表示法

二叉树定义

结点的有限集合

集合为空

由一个根节加上两棵左子树或者右子树二叉树组成

  二叉树的两个结点的度<=2

是一个有序树 

性质

1.根节点的层数为1，非空二叉树的第i层2^k-1个结点

2.根节点的层数为1，，（2^k）-1是总共的个数 

3.对任何一棵二叉树,如果其叶结点个数为 n0,度为2的非叶结点个数为 n2,则有n0=n2+1

4.具有n个结点的完全二叉树的深度k为Log2(+1)向上取整。

5.对于具有n个结点的完全二叉树，如果按照从上至下从左至右的顺序对所有节点从0开始编号，则对于序号为i的结点有:

若i>0，双亲序号:(i-1)/2;i=0，i为根结点编号，无双亲结点
若2i+1<n，左孩子序号:2i+1，否则无左孩子
若2i+2<n，右孩子序号:2i+2，否则无右孩子

满二叉树

特殊的完全二叉树  

2^k-1每一层的节点个数

（2^k）-1是总共的个数 

完全二叉树

从上到下，从左到右依次排列

  二叉树的存储

分为顺序存储和链式存储

顺序存储 

遍历

通过前序遍历(后序遍历 )和中序遍历来画出二叉树

不能通过前序遍历和后序遍历穿凿一棵树

遍历前序遍历 遇到的是根在中序遍历当中 找到根的位置 根的左边 是左子树 右边右子树

                  A

       B                    C

D        E             F       G 

              H

前序遍历        根 左 右 A B D E H C F G

  public void preOrder(TreeNode root) {
        if(root == null) {
            return;//空树是不需要遍历的
        }
        System.out.print(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }

中序遍历        左 根 右 D B E H A F C G

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

后序遍历        左 右 根 D H E B F G C A

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

层序遍历       从上到下，从左到右 A  B C D E  F G H 

获取子叶结点个数

    public int leafSize;

 public void getLeafNodeCount(TreeNode root) {
        if(root == null) {
            return ;
        }
        if(root.left==null&&root.right==null){
            leafSize++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);

    }

    public int getLeafNodeCount2(TreeNode root) {
        if(root == null) {
            return 0;
        }

        if(root.left==null&&root.right==null){
            return  1;
        }

求树的k有多少个结点

  //root的第k层有多少个节点
    public int getKLevelNodeCount(TreeNode root,int k) {
        if(root == null) {
            return 0;
        }
        if(k==1)
            return 1;
        return getKLevelNodeCount(root.left,k-1)+getKLevelNodeCount(root.right,k-1);
    }

树的深度

    public int getHeight(TreeNode root) {
        if(root == null) {
            return 0;
        }
      
        return Math.max(getHeight(root.left),getHeight(root.right))+1;
    }


    public int getHeight2(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftHeight = getHeight2(root.left);
        int rightHeight = getHeight2(root.right);

        return (leftHeight > rightHeight ? leftHeight : rightHeight) + 1;
    }

    public int getHeight3(TreeNode root) {
        if(root == null) {
            return 0;
        }

        return (getHeight3(root.left) >  getHeight3(root.right)
                ? getHeight3(root.left) :  getHeight3(root.right)) + 1;//时间过长
    }

判断一个树是否是另一个树的子树

  //判断两个树是否相同
 public boolean isSameTree(TreeNode p, TreeNode q) {
        if(p != null && q == null  || p == null && q != null) {
            //结构不一样
            return false;
        }
        //上述If语句没有进来 那么说明  要么两个都是空 要么两个都不是空
        if(p == null && q == null) {
            return true;
        }
        //两个都不为空
        if(p.val != q.val ) {
            return false;
        }
        //上述代码完成 走到这里 说明p != null && q != null && 根节点值一样
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }

    //m  n  -> O(m*n) ->
    // root这棵树的每个节点 都要和subRoot判断是否相同
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root == null) return false;
        if(isSameTree(root,subRoot)) {
            return true;
        }
        if(isSubtree(root.left,subRoot)) {
            return true;
        }
        if(isSubtree(root.right,subRoot)) {
            return true;
        }
        return false;
    }

 巧计

 public boolean isBalanced(TreeNode root) {
        if(root == null) {
            return true;
        }
        int leftH = getHeight(root.left);
        int rightH = getHeight(root.right);
        if(Math.abs(leftH-rightH) < 2 && isBalanced(root.left)
                && isBalanced(root.right)) {
            return true;
        }
        return false;
    }

    public boolean isBalanced2(TreeNode root) {
        if(root == null) {
            return true;
        }
        return getHeight22(root) >= 0;
    }

    public int getHeight22(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftHeight = getHeight22(root.left);
        if(leftHeight < 0) {
            return -1;
        }
        int rightHeight = getHeight22(root.right);
        //刚刚已经约定 不平衡会返回负数
        if(leftHeight >= 0 && rightHeight >= 0
                && Math.abs(leftHeight-rightHeight) <= 1) {
            return Math.max(leftHeight,rightHeight) + 1;
        }else {
            //不平衡
            return -1;
        }
    }