求二叉树的深度，判断该树是不是平衡二叉树

剑指offer两道编程题

二叉树深度

题目描述：
输入一棵二叉树，求该树的深度。从根结点到叶结点依次经过的结点（含根、叶结点）形成树的一条路径，最长路径的长度为树的深度。

求二叉树的深度，有三种方法：
1. 递归，这也是很多人非常容易想到的,递归实际也是深度优先的思想（DFS）,时间复杂度为O(lgN),但是空间复杂度最坏为O(N),当二叉树退化为链表的时候。
2. 循环，这种方法不会有递归方法容易出现的栈溢出风险。循环其实是广度优先的思想(BFS)。时间复杂度O(N)

---

递归

分析：如果该树只有一个结点，它的深度为1.如果根节点只有左子树没有右子树，那么树的深度为左子树的深度加1；同样，如果只有右子树没有左子树，那么树的深度为右子树的深度加1。如果既有左子树也有右子树，那该树的深度就是左子树和右子树的最大值加1.
这个思路用递归实现如下：

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

循环

上述递归也可以改为循环：

import java.util.LinkedList;
import java.util.Queue;
public class Solution {
    public int TreeDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
      // return Math.max(TreeDepth(root.left), TreeDepth(root.right)) + 1;
                Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int count = 0, depth = 0, nextCount = 1;
        while (!queue.isEmpty()) {
            TreeNode node = queue.poll();
            count ++;
            if (node.left != null) {
                queue.offer(node.left);
            }
            if (node.right != null) {
                queue.offer(node.right);
            }
            if (count == nextCount) {
                nextCount = queue.size();
                count = 0;
                depth++;
            }
        }
        return depth;

    }
}

上述方式是先知道下一层树的个数，然后count++，相等时候，结束一层的层序遍历。

也可以先知道该层的个数，然后–；

import java.util.LinkedList;
import java.util.Queue;

/**
 * Created by 10648 on 2017/4/13 0013.
 */
public class TreeDepth {

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

        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);
        int depth = 0;
        while (!q.isEmpty()) {
            int size = q.size();
            while (size-- > 0) {
                TreeNode node = q.poll();
                if (node.left != null) {
                    q.offer(node.left);
                }
                if (node.right != null) {
                    q.offer(node.right);
                }
            }
            depth ++;
        }
        return depth;
    }
}

判断该树是不是平衡二叉树

输入一棵二叉树，判断该二叉树是否是平衡二叉树。

首先，什么是平衡二叉树？如果二叉树中任意结点的左右子树深度相差不超过1，那么它就是平衡二叉树。

递归法

有了求二叉树的深度的经验之后，很容易想到一个思路：遍历每个结点的时候，得到它的左右结点的深度。如果每个结点的左右二叉树的深度相差都不超过1，就是平衡二叉树。

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

    public boolean isBalanced(TreeNode root) {
        if (root == null) {
            return true;
        }
        int left = getTreeDepth(root.left);
        int right = getTreeDepth(root.right);
        return Math.abs(left - right) <= 1 && isBalanced(root.left)
                && isBalanced(root.right);
    }

但是这个方法每个结点被重复遍历，效率不高。

自底向上

另一个思路：
如果我们用后序遍历的方式遍历二叉树的每一个结点，在遍历到一个结点之前我们就已经遍历了它的左右子树。只要在遍历每个结点的时候几下它的深度，就可以一次遍历判断每个结点是不是平衡二叉树。

解法一：

 public boolean IsBalanced_Solution2(TreeNode root) {
        int[] depth = new int[1];
        return isBalancedCore(root, depth);
    }
    public boolean isBalancedCore(TreeNode node, int[] length) {
        if (node == null) {
            length[0] = 0;
            return true;
        }
        int[] left = new int[1];
        int[] right = new int[1];
        if (isBalancedCore(node.left, left) && isBalancedCore(node.right, right)) {
            if (Math.abs(left[0] - right[0]) <= 1) {
                length[0] = Math.max(left[0], right[0]) + 1;
                return true;
            }
        }
        return false;
    }

解法二：

首先： 求

        // 求高度
    public int height(TreeNode node) {

    } 

  //第一步：判断node == null
        if (node == null) {
            return 0;
        }

         // 第二步：求左子树高度
        int lH = height(node.left);

         // 第三步：求右子树高度
        int rH = height(node.right);

        // 第四步： 判断node 左右子树高度相差，
        // 如果不是平衡的，返回高度 -1
        if (Math.abs(lH - rH) > 1) {
            return -1;
        }

        //第四步后续：如果是AVL，返回此node结点的高度
        return Math.max(lH, rH) + 1;

      //第五步:如果左子树不是平衡的，则子节点 也不是
        if (lH == -1) {
            return -1;
        }
         //第五步后；如果右子树不是平衡的，则子节点 也不是
        if (rH == -1) {
            return -1;
        }

 public boolean isBalanced(TreeNode root) {
        return height(root) != -1;
    }
 public int height(TreeNode node) {
        //第一步：判断node == null
        if (node == null) {
            return 0;
        }
        // 第二步：求左子树高度
        int lH = height(node.left);
        //第五步:如果左子树不是平衡的，则子节点 也不是
        if (lH == -1) {
            return -1;
        }
        // 第三步：求右子树高度
        int rH = height(node.right);
        //第五步后；如果右子树不是平衡的，则子节点 也不是
        if (rH == -1) {
            return -1;
        }
        // 第四步： 判断node 左右子树高度相差，
        // 如果不是AVL，返回高度 -1
        if (Math.abs(lH - rH) > 1) {
            return -1;
        }
        //第四步后续：如果是AVL，返回此node结点的高度
        return Math.max(lH, rH) + 1;
    }