二叉树链式结构操作的java实现（续）

1.根据字符串创建二叉树
步骤：
因为“#”代表没有，所以若对应字符不是#号，创建一个节点，然后使用递归。
若是#，则直接下标++。
代码实现：

 public Node createTestTree(String str) {  //创建一棵二叉树，递归，先序遍历的方式
            Node root = null;
            //1.若对应字符不是#号，创建一个节点

            if (str.charAt(i) != '#') {
                root = new Node(str.charAt(i));
                i++;
                root.left = createTestTree(str);
                root.right = createTestTree(str);
            } else {        //2.若是#，则直接下标++
                i++;
            }
            return root;
        }

2.计算节点个数
节点的个数就等于根节点的左子树节点的个数加上根节点右子树节点的个数再加上根节点自己。
若根节点为空，则表示没有节点‘
代码实现：

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

3.计算叶子节点个数
当根节点为空时，表示没有节点。当一个节点的左孩子和右孩子都为空时，它是叶子节点。总的叶子节点就等于左子树的叶子节点加右子树的叶子节点。采用递归的思想。
代码实现：

  public 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);
        }

4.得到第k层节点个数
第k层相对于自己本身是第一层。
所以递归的第二个参数为k-1.
代码实现：

 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);

        }

5.查找，依次在二叉树的 根、左子树、右子树 中查找 value，如果找到，返回结点，否则返回 null。
步骤：（1）先看根节点，若根节点不为空，且根节点的值若为我们要查找的value值，则返回根节点。
（2）在左子树中查找，若找到，则返回该值
（3）在右子树中查找
、
代码实现：

 public Node find(Node root, int value) {  //根据先序遍历找
            if (root == null) {
                return null;
            }
            if (root.value == value) {
                return root;
            }
            Node r = find(root.left, value);
            if (r != null) {
                return r;
            }
            r = find(root.right, value);
            if (r != null) {
                return r;
            }
            return null;
        }

6.二叉树的高度，此高度也为它的最大高度
左右子树中最高的那一个高度再加上和根节点的高度，即在加1.
代码实现：

   public int height(Node root) {
            if (root == null) {
                return 0;
            }
            int leftHeight = height(root.left);
            int RightHeight = height(root.right);
            return Math.max(leftHeight, RightHeight) + 1;
        }

7.判断一棵二叉树是否为完全二叉树
返回0代表是完全二叉树，返回-1代表不是完全二叉树
完全二叉树：若设二叉树的深度为h，除第h层外，其他各层（1~h-1）的节点数都达到最大个数，第h层所有的节点都连续集中在最左边。
在此，可引入对列来实现
具体步骤如下图：

代码实现：

   int binaryTreeComplete(TreeNode root) {
        Queue<TreeNode> queue = new LinkedList<>();
        if(root != null) {
            queue.offer(root);
        }

        while (!queue.isEmpty()) {
            TreeNode cur = queue.poll();
            if(cur != null) {
                queue.offer(cur.left);
                queue.offer(cur.right);
            }else {
                break;
            }
        }
        //出队  只要不是空  就说明不是完全二叉树
        while (!queue.isEmpty()) {
            TreeNode cur = queue.peek();
            if(cur != null) {
                return -1;//不是完全二叉树
            }else {
                queue.poll();
            }
        }
        return 0;
    }
}

8.二叉树的层次遍历：
用对列实现
步骤：
（1）对于不为空的节点，先把该节点加入到对列中
（2）从队中拿出节点并打印该节点，如果该节点的左右节点不为空，就分别把左右节点加入到对列中。
代码实现：

 public static void levelOrder(TreeNode root){
        if(root==null){
            return ;
        }
        Queue<TreeNode> queue=new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()){
            TreeNode cur=queue.peek();
            cur=queue.poll();
            System.out.print(cur.value+" ");
            if(cur.left!=null){
                queue.offer(cur.left);
            }
            if(cur.right!=null){
                queue.offer(cur.right);
            }
        }
    }

9.给定两个二叉树，编写一个函数来检验它们是否相同。
如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。
步骤：
（1）若两个二叉树都为空，则它们是相同的
（2）若其中一个二叉树为空，另一个不为空，则它们是不相同的
（3）若它们节点处的值不相同，则它们是不相同的。
（4）若根节点满足了，则使用递归，判断它们相对应的左节点的值和相对应的右节点的值是否相等，若左右节点处对应的值都相等，则说明这两棵二叉树是相同的。
代码实现：

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

10.给定一个二叉树，判断它是否是高度平衡的二叉树
平衡二叉树的性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
即：root.leftHeight-root.rightHeight<2
代码实现：

public boolean isBalanced(TreeNode root) {
        if(root==null){
            return true;
        }
        return Math.abs(maxDepth(root.left)-maxDepth(root.right))<2 &&isBalanced(root.left)&&isBalanced(root.right);
        
    }
    public int maxDepth(TreeNode root) {
       if(root == null) {
            return 0;
        }
        int leftHeight = maxDepth(root.left);
        int rightHeight = maxDepth(root.right);
        return leftHeight >  rightHeight ?
                leftHeight +1 :  rightHeight +1;
    }

11.给定两个非空二叉树 s 和 t，检验 s 中是否包含和 t 具有相同结构和节点值的子树。s 的一个子树包括 s 的一个节点和这个节点的所有子孙。s 也可以看做它自身的一棵子树。
示例 1:
给定的树 s:

 3
/ \

4 5
/
1 2

给定的树 t：

4
/
1 2

返回 true，因为 t 与 s 的一个子树拥有相同的结构和节点值。

示例 2:
给定的树 s：

 3
/ \

4 5
/
1 2
/
0

给定的树 t：

4
/
1 2

返回 false。
步骤：
（1）因为是两棵非空的二叉树，所以，若两棵树都为空，则返回false。
（2）在上面我们写过相同的二叉树，若两棵二叉树相同，则它们互为子树，返回true.
（3）递归s的左，右节点，看t 与 s 的一个子树拥有相同的结构和节点值
代码实现：

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