二叉树与分治

几种常见的二叉树：

满二叉树 ：除了叶子节点外，所有节点都有两个儿子，深度为 k 的满二叉树具有 2^k - 1 个节点。

完全二叉树 ：若设二叉树的高度为h，除第h层外，其他各层 (1 ~ h -1)层节点都达到最大个数，第h层的叶子节点从左到右依次排列。

平衡二叉树(AVL) ：是一棵平衡的二叉查找树。任何一个节点的左右两个儿子的高度差不超过1，并且其左右子树都是平衡二叉树。

二叉查找树(BST) ： 左 < 根 < 右。（BST不一定是平衡二叉树）

遇到二叉树问题，就想想整棵树在该问题上的结果和左右子树在该问题上的结果之间的联系。

二叉树问题常常伴随着遍历出现，基本的就有前序遍历，中序遍历，后续遍历。三种遍历的实现分为递归实现和非递归实现，而递归实现又可以分为遍历法和分治法。区分遍历法可以简单想为遍历就是都是自己去做，而分治是分给自己的小弟去做。

一般分子二叉树问题都可以使用分治，就是无脑的先丢给左子树，然后无脑的丢给右子树，得到左右子树的结果之后再考虑根节点。

这里就先给出三种遍历的三种实现方法。前序遍历：根左右    中序遍历：左根右     后续遍历：左右根

前序遍历遍历法：

 public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        preorderHelp(result,root);
        return result;
    }
    public void preorderHelp(ArrayList<Integer> result , TreeNode root) {
        if (root == null) {
            return;
        }
        result.add(root.val);
        preorderHelp(result, root.left);
        preorderHelp(result, root.right);
    }

前序遍历非递归：

 public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        if (root == null)
            return result;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while(!stack.isEmpty()) {
            TreeNode node = stack.pop();
            result.add(node.val);
            if(node.right != null){
                stack.push(node.right);
            }
            if(node.left != null){
                stack.push(node.left);
            }
        }
        return result;
    }

前序遍历分治算法：

 public ArrayList<Integer> preorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        if (root == null) {
            return result;
        }
        result.add(root.val);
        ArrayList<Integer> left = preorderTraversal(root.left);
        ArrayList<Integer> right = preorderTraversal(root.right);
        result.addAll(left);
        result.addAll(right);
        return result;
    }

中序遍历，后续遍历的分治算法和遍历算法与前序遍历的区别仅仅是添加的顺序不同。非递归算法有所区别。

中序遍历非递归：

 public ArrayList<Integer> inorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        TreeNode curNode = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        while (curNode != null || !stack.isEmpty()) {
            while (curNode != null){
                stack.push(curNode);
                curNode=curNode.left;
            }
            curNode = stack.peek();
            result.add(curNode.val);
            stack.pop();
            curNode = curNode.right;
        }
        return result;
    }

后续遍历非递归：

后续遍历的非递归算法还是有点难度的，主要是记录是从上往下遍历 还是从左往上遍历 还是从右往上遍历。使用两个Node prev和cur,使用这两个节点的关系来判断是上述三种情况的哪一种，只有在第三种情况下result中添加值。

public ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = root;
        TreeNode prev = null;
        if (root == null) {
            return result;
        }
        stack.push(root);
        while (!stack.isEmpty()) {
            cur = stack.peek();
            if (prev == null || prev.left == cur || prev.right == cur) { //traverse down the tree
                if (cur.left != null) {
                    stack.push(cur.left);
                }
                else if (cur.right != null) {
                    stack.push(cur.right);
                }
            }
            else if (cur.left == prev) {//traverse up the tree from the left
                if (cur.right != null) {
                    stack.push(cur.right);
                }
            }
            else {
                result.add(cur.val);
                stack.pop();
            }
            prev = cur;
        }
        return result;
    }

 后续遍历非递归算法二，类似于前序遍历，先得到根右左到栈中，然后弹出。

public ArrayList<Integer> postorderTraversal(TreeNode root) {
        // write your code here
        ArrayList<Integer> result = new ArrayList<Integer>();
        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode cur = root;
        TreeNode prev = null;
        if (root == null) {
            return result;
        }
        stack.push(root);
        while (!stack.isEmpty()) {
            cur = stack.peek();
            if (prev == null || prev.left == cur || prev.right == cur) { //traverse down the tree
                if (cur.left != null) {
                    stack.push(cur.left);
                }
                else if (cur.right != null) {
                    stack.push(cur.right);
                }
            }
            else if (cur.left == prev) {//traverse up the tree from the left
                if (cur.right != null) {
                    stack.push(cur.right);
                }
            }
            else {
                result.add(cur.val);
                stack.pop();
            }
            prev = cur;
        }
        return result;
    }

下面看看二叉树问题的无脑左右子树分治解决方案：

二叉树的最大深度

public int maxDepth(TreeNode root) {
        // write your code here
        if (root == null)
            return 0;
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        return Math.max(left, right) + 1;
    }

 

平衡二叉树

给定一个二叉树,确定它是高度平衡的。对于这个问题,一棵高度平衡的二叉树的定义是：一棵二叉树中每个节点的两个子树的深度相差不会超过1。

分治算法实现，这里需要注意的是分治的返回值有两个，以前遇到过用-1来代表子树不是平衡树的情况，觉得这种想法很好，其实不应该这样，这样带来了二义性的问题。代码还是要有利于阅读较好。

public boolean isBalanced(TreeNode root) {
        // write your code here
        return isBalancedHelp(root).isBalanced;
    }
    public ReturnType isBalancedHelp(TreeNode root) {
        if(root == null) {
            return new ReturnType(0 , true);
        }
        ReturnType left = isBalancedHelp(root.left);
        ReturnType right = isBalancedHelp(root.right);
        int leftDepth = left.depth;
        int rightDepth = right.depth;
        int curDepth = Math.max(left.depth, right.depth)+1;
        if (left.isBalanced && right.isBalanced) {
            if (Math.abs(leftDepth - rightDepth) <= 1)
                return new ReturnType(curDepth, true);
        }
        return new ReturnType(curDepth , false);
    }
class ReturnType {
     int depth;
     boolean isBalanced;
     public ReturnType(int depth, boolean isBalanced) {
         this.depth = depth;
         this.isBalanced =isBalanced;
     }
 }

最近公共祖先

给定一棵二叉树，找到两个节点的最近公共父节点(LCA)。

最近公共祖先是两个节点的公共的祖先节点且具有最大深度。

假设给出的两个节点都在树中存在。

遇到这类面试题，首先问有没有指向父亲的指针，有的话就简单了，直接往上遍历到根节点，得到两条路径，然后查找第一个不同的。注意这里假设的是一定有CA。

递归程序在包含AB时就返回LCA，只包含A就返回A，只包含B就返回B,否则返回null。

public TreeNode lowestCommonAncestor(TreeNode root, TreeNode A, TreeNode B) {
        // write your code here
        if (root == null || root == A || root == B) {
            return root;
        }
        TreeNode left = lowestCommonAncestor(root.left, A, B);
        TreeNode right = lowestCommonAncestor(root.right, A, B);
        if (left != null && right!=null) {
            return root;
        }
        if (left != null) {
            return left;
        }
        if (right != null) {
            return right;
        }
        return null;
    }

 

最近公共祖先 II

给一棵二叉树和二叉树中的两个节点，找到这两个节点的最近公共祖先LCA。

两个节点的最近公共祖先，是指两个节点的所有父亲节点中（包括这两个节点），离这两个节点最近的公共的节点。

每个节点除了左右儿子指针以外，还包含一个父亲指针parent，指向自己的父亲。

public ParentTreeNode lowestCommonAncestorII(ParentTreeNode root,
                                                 ParentTreeNode A,
                                                 ParentTreeNode B) {
        // Write your code here   
        if (root == null || root == A || root == B) {
            return root;
        }
        HashSet<ParentTreeNode> hashSet = new HashSet<ParentTreeNode>();

        while (A != null) {
            hashSet.add(A);
            A = A.parent;
        }
        while (B != null) {
            if (hashSet.contains(B)) {
                return B;
            }
            B = B.parent;
        }
        return null;
    }

最近公共祖先 III

给一棵二叉树和二叉树中的两个节点，找到这两个节点的最近公共祖先LCA。

两个节点的最近公共祖先，是指两个节点的所有父亲节点中（包括这两个节点），离这两个节点最近的公共的节点。

返回 null 如果两个节点在这棵树上不存在最近公共祖先的话。

 注意事项

这两个节点未必都在这棵树上出现。

public TreeNode lowestCommonAncestor3(TreeNode root, TreeNode A, TreeNode B) {
        // write your code here
        return help(root, A, B).root;
    }
    public ResultType help(TreeNode root, TreeNode A, TreeNode B) {
        if (root == null) {
            return new ResultType(null, false, false);
        }
        ResultType left = help(root.left, A, B);
        ResultType right = help(root.right, A, B);
        if (left.root != null) {
            return left; 
        }
        if (right.root != null) {
            return right;
        }
        if (root == A) {
            if (root == B) {
                return new ResultType(root, true, true);
            }
            if (left.containsB || right.containsB) {
                return new ResultType(root, true, true);
            }
            else {
                return new ResultType(null, true, false);
            }
        }
        else if (root == B) {
            if (left.containsA || right.containsA) {
                return new ResultType(root, true, true);
            }
            else {
                return new ResultType(null, false, true);
            }
        }
        else {
            if (left.containsA) {
                if (right.containsB) {
                    return new ResultType(root, true, true);
                }
                else {
                    return new ResultType(null, true, false);
                }
            }
            else if (left.containsB) {
                if (right.containsA) {
                    return new ResultType(root, true, true);
                }
                else {
                    return new ResultType(null, false, true);
                }
            }
            else {
                if (right.containsA) {
                    return new ResultType(null, true, false);
                }
                else if (right.containsB) {
                    return new ResultType(null, false, true);
                }
                else {
                    return new ResultType(null, false, false);
                }
        
            }
        }
    }
class ResultType {
    TreeNode root;
    boolean containsA;
    boolean containsB;
    public ResultType (TreeNode root, boolean containsA, boolean containsB) {
        this.root = root;
        this.containsA = containsA;
        this.containsB = containsB;
    }
}

二叉树的最大路径和 II

给一棵二叉树，找出从根节点出发的路径中，和最大的一条。

这条路径可以在任何二叉树中的节点结束，但是必须包含至少一个点（也就是根了）。

注意节点值可能为负数。无脑分给左右儿子就行。

public int maxPathSum2(TreeNode root) {
        // Write your code here
        if (root == null) {
            return Integer.MIN_VALUE;
        }
        int left = maxPathSum2(root.left);
        int right = maxPathSum2(root.right);
        return root.val+Math.max(0,Math.max(left, right));
    }

二叉树中的最大路径和

给出一棵二叉树，寻找一条路径使其路径和最大，路径可以在任一节点中开始和结束（路径和为两个节点之间所在路径上的节点权值之和）

public int maxPathSum(TreeNode root) {
        // write your code here
        return maxPathSumHelp(root).any2Any;
    }
    public ResultType maxPathSumHelp(TreeNode root) {
        if (root == null) {
            return new ResultType(
                    Integer.MIN_VALUE, Integer.MIN_VALUE
            );
        }
        ResultType leftRes = maxPathSumHelp(root.left);
        ResultType rightRes = maxPathSumHelp(root.right);
        int root2Any = root.val
                    + Math.max(0, Math.max(leftRes.root2Any,rightRes.root2Any));
        int any2Any = root.val + Math.max(0,leftRes.root2Any)
                               + Math.max(0,rightRes.root2Any);
                               
        any2Any = Math.max(any2Any,
                Math.max(leftRes.any2Any, rightRes.any2Any)
        );
        return new ResultType(root2Any, any2Any);
    }
class ResultType {
     int root2Any;
     int any2Any;
     public ResultType(int root2Any, int any2Any) {
         this.root2Any = root2Any;
         this.any2Any = any2Any;
     }
 }

二叉查找树BST

注意二叉查找树不一定是平衡的，所以其查找复杂度不一定就是O(logn)

TreeMap是BST+Balanced。其删除 插入 查找 min max ceil(x) floor(x)复杂度都是O(logn)

验证二叉查找树

注意必须是整个左子树都比我小，整个右子树都比我大。并不只是左右子节点满足条件就行

public boolean isValidBST(TreeNode root) {
        // write your code here
        if (root == null)
            return true;
        return isValidBSTHelp(root).isValid;
    }
    public ResultType isValidBSTHelp(TreeNode root) {
        ResultType right;
        ResultType left;
        if (root.left == null && root.right == null) {
            return new ResultType(true, root.val, root.val);
        }
        if (root.left == null) {
            right = isValidBSTHelp(root.right);
            if (right.isValid && root.val < right.min) {
                return new ResultType(true, root.val, right.max);
            }
            return new ResultType(false, 0, 0);
        }
        if (root.right == null) {
            left = isValidBSTHelp(root.left);
            if (left.isValid && root.val > left.max) {
                return new ResultType(true, left.min, root.val);
            }
            return new ResultType(false, 0, 0);
        }
        right = isValidBSTHelp(root.right);
        left = isValidBSTHelp(root.left);
        if (left.isValid && right.isValid) {
            if (left.max < root.val && right.min > root.val) {
                return new ResultType(true, left.min, right.max);
            }
        }
        return new ResultType(false, 0, 0);
    }
class ResultType {
     boolean isValid;
     int min;
     int max;
     public ResultType(boolean isValid, int min, int max) {
         this.isValid = isValid;
         this.min = min;
         this.max = max;
     }
 }

同样的思路换一个方向，写出来的代码就漂亮许多。

 public boolean isValidBST(TreeNode root) {
        // write your code here
        return isValidBSTHelp(root).isValid;
    }
    public ResultType isValidBSTHelp(TreeNode root) {
        if (root == null) {
            return new ResultType(true, Integer.MAX_VALUE,Integer.MIN_VALUE);
        }
        ResultType left = isValidBSTHelp(root.left);
        ResultType right = isValidBSTHelp(root.right);
        if (!left.isValid || !right.isValid) {
            return new ResultType(false, 0, 0);
        }
        if (root.left != null && root.val <= left.max 
            || root.right !=null && root.val >= right.min) {
            return new ResultType(false, 0, 0);
        }
        return new ResultType(true, 
                Math.min(root.val, left.min), 
                Math.max(root.val,right.max));
    }

二叉查找树迭代器

public class BSTIterator {
    TreeNode root;
    Stack<TreeNode> stack;
    //@param root: The root of binary tree.
    public BSTIterator(TreeNode root) {
        // write your code here
        this.root = root;
        stack = new Stack<TreeNode>();
        TreeNode cur = root;
        while(cur != null) {
            stack.push(cur);
            cur = cur.left;
        }
    }

    //@return: True if there has next node, or false
    public boolean hasNext() {
        // write your code here
        return !stack.isEmpty();
    }
    
    //@return: return next node
    public TreeNode next() {
        // write your code here
        TreeNode cur = stack.pop();
        TreeNode right = cur.right;
        while (right != null) {
            stack.push(right);
            right = right.left;
        }
        return cur;
    }
}

二叉树的层次遍历

public ArrayList<ArrayList<Integer>> levelOrder(TreeNode root) {
        // write your code here
        ArrayList<ArrayList<Integer>> results = new ArrayList<>();
        ArrayList<Integer> list;
        if (root == null)
            return results;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            list = new ArrayList<>();
            for (int i = 0; i< size; i++) {
                TreeNode cur = queue.peek();
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
                list.add(cur.val);
                queue.poll();
            }
            results.add(new ArrayList<>(list));
        }
        return results;
    }

二叉树查找树中序后继 ***

public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        // write your code here
        if (root == null || p == null) {
            return null;
        }
        if (root.val == p.val) {
            TreeNode right = root.right;
            while (right != null && right.left != null) {
                right = right.left;
            }
            return right;
        }
        if (root.val > p.val) {
            TreeNode left = inorderSuccessor(root.left, p);
            if (left == null) {
                return root;
            }
            return left;
        }
        return inorderSuccessor(root.right, p);
    }

二叉树的路径和

给定一个二叉树，找出所有路径中各节点相加总和等于给定 目标值 的路径。

一个有效的路径，指的是从根节点到叶节点的路径。

public List<List<Integer>> binaryTreePathSum(TreeNode root, int target) {
        // Write your code here
        List<List<Integer>> results = new ArrayList<List<Integer>>();
        if (root == null) {
            return results;
        }
        help(results, new ArrayList<Integer>(), root, target);
        return results;
    }
    public void help(List<List<Integer>> results, List<Integer> cur, 
                     TreeNode root, int target) {
        cur.add(root.val);
        if (target == root.val && root.left == null && root.right == null) {
            results.add(new ArrayList<Integer>(cur));
        }
        if (root.left != null) {
            help(results, cur, root.left, target - root.val);
        }
        if (root.right != null) {
            help(results, cur, root.right, target - root.val);
        }
        cur.remove(cur.size() - 1);
    }

扭转后等价的二叉树

检查两棵二叉树是否在经过若干次扭转后可以等价。扭转的定义是，交换任意节点的左右子树。等价的定义是，两棵二叉树必须为相同的结构，并且对应位置上的节点的值要相等。

 public boolean isTweakedIdentical(TreeNode a, TreeNode b) {
        // Write your code here
        if (a == null && b == null) {
            return true;
        }
        if (a == null || b == null || a.val != b.val) {
            return false;
        }
        return isTweakedIdentical(a.left, b.left) 
                && isTweakedIdentical(a.right, b.right)
                ||
                (  isTweakedIdentical(a.left, b.right) 
                && isTweakedIdentical(a.right, b.left));
    }

 对称二叉树

public boolean isSymmetric(TreeNode root) {
        // Write your code here
        if (root == null) {
            return true;
        }
        return help(root.left, root.right);
    }
    public boolean help(TreeNode left, TreeNode right) {
        if(left == null && right == null) {
            return true;
        }
        if (left == null || right == null || left.val != right.val) {
            return false;
        }
        return help(left.left, right.right) 
            && help(left.right, right.left);
    }

完全二叉树

只有最后一层可以不满，最后一层从左到右排列。所以可以使用层序遍历，遍历同层的时候看看是否有左边空了，右边不空的情况。遍历下一层的时候看看是否有上层不满的情况。

之前两种思路：第一种看是否所有节点的左子树节点数大于等于右子树节点数，这是不对的，例如：1 2 3 4 # 5 

　　　　　　　另外一种看叶子节点数目是不是所有节点数目的上限一半也是有问题的，例如: 1 2 3 #  # 4

public boolean isComplete(TreeNode root) {
        // Write your code here
        Queue<TreeNode> queue = new LinkedList<>();
        if (root == null) {
            return true;
        }
        queue.offer(root);
        int num = 1;
        while (!queue.isEmpty()) {
            int size = queue.size();
            if (num != size && queue.peek().left!=null) {
                return false;
            }
            num = num * 2;
            boolean flag = true;
            for (int i = 0; i < size; i++) {
                TreeNode cur = queue.poll();
                if (!flag && (cur.left != null || cur.right != null)) {
                    return false;
                }
                if (cur.left != null) {
                    queue.offer(cur.left);
                    if (cur.right != null) {
                        queue.offer(cur.right);
                    }
                    else {
                        flag = false;
                    }
                }
                else {
                    if (cur.right != null) {
                        return false;
                    }
                    flag = false;
                }
            }
        }
        return true;
    }

前序遍历和中序遍历树构造二叉树

public TreeNode buildTree(int[] preorder, int[] inorder) {
        // write your code here
        if (preorder == null || preorder.length == 0 
            || inorder == null || preorder.length != inorder.length) {
                return null;
        }
        Map<Integer,Integer> map = new HashMap<Integer, Integer>();
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i], i);
        }
        return buildHelp(preorder, 0, preorder.length - 1,
                         inorder, 0, inorder.length - 1, map);
    }
    public TreeNode buildHelp(int[] preorder, int pre_begin, int pre_end,
                              int[] inorder, int in_begin, int in_end, 
                              Map<Integer,Integer> map) {
        if (pre_begin > pre_end) {
            return null;
        }
        if (pre_begin == pre_end) {
            return new TreeNode(preorder[pre_begin]);
        }     
        TreeNode root = new TreeNode(preorder[pre_begin]);
        int index = map.get(preorder[pre_begin]);
        root.left = buildHelp(preorder, pre_begin + 1, pre_begin + index - in_begin,
                            inorder, in_begin, index - 1, map);
        root.right = buildHelp(preorder, pre_begin + index - in_begin + 1, pre_end,
                            inorder, index + 1, in_end, map);
        return root;
    }

中序遍历和后序遍历树构造二叉树

public TreeNode buildTree(int[] inorder, int[] postorder) {
        // write your code here
        if (inorder == null || inorder.length == 0 
        || postorder == null || postorder.length != inorder.length) {
            return null;
        }
        Map<Integer,Integer> map = new HashMap<Integer,Integer>();
        for (int i = 0; i < inorder.length; i++) {
            map.put(inorder[i],i);
        }
        return buildHelp(inorder, 0, inorder.length - 1,
                postorder, 0, postorder.length - 1, map);
    }
    public TreeNode buildHelp(int[] inorder, int in_start, int in_end,
                              int[] postorder, int post_start, int post_end,
                              Map<Integer,Integer> map) {
        if (in_start > in_end) {
            return null;
        }               
        if (in_start == in_end) {
            return new TreeNode(postorder[post_end]);
        }
        TreeNode root = new TreeNode(postorder[post_end]);
        int index = map.get(root.val);
        root.left = buildHelp(inorder, in_start, index - 1,
                    postorder, post_start, post_start + index - 1 - in_start,
                    map);
        root.right = buildHelp(inorder, index + 1, in_end,
                    postorder, post_start + index - in_start, post_end - 1,
                    map);
        return root;
    }

二叉查找树中搜索区间

给定两个值 k1 和 k2（k1 < k2）和一个二叉查找树的根节点。

找到树中所有值在 k1 到 k2 范围内的节点。

即打印所有x (k1 <= x <= k2) 其中 x 是二叉查找树的中的节点值。

返回所有升序的节点值。

public ArrayList<Integer> searchRange(TreeNode root, int k1, int k2) {
        // write your code here
        ArrayList<Integer> res = new ArrayList<Integer>();
        helper(root, k1, k2, res);
        return res;
    }
    public void helper(TreeNode root, int k1, int k2, ArrayList<Integer> res) {
        if (root == null) {
            return ;
        }
        if (root.val > k1) {
            helper(root.left, k1, k2, res);
        }
        if (root.val >= k1 && root.val <= k2) {
            res.add(root.val);
        }
        if (root.val < k2) {
            helper(root.right, k1, k2, res);
        }
    }

 二叉树的序列化和反序列化

 使用前序遍历比层序遍历来得简单直观的多。

 public String serialize(TreeNode root) {
        // write your code here
        StringBuilder sb = new StringBuilder();
        bulidString(root, sb);
        return sb.toString();
    }
    public void bulidString(TreeNode root, StringBuilder sb) {
        if (root == null) {
            sb.append("#,");
        }
        else {
            sb.append(root.val).append(",");
            bulidString(root.left, sb);
            bulidString(root.right, sb);
        }
    }
    public TreeNode deserialize(String data) {
        // write your code here
        Queue<String> queue = new LinkedList<String>();
        queue.addAll(Arrays.asList(data.split(",")));
        return buildTree(queue);
    }
    public TreeNode buildTree(Queue<String> queue) {
        String cur = queue.poll();
        if (cur.equals("#")) {
            return null;
        } 
        else {
            TreeNode root = new TreeNode(Integer.valueOf(cur));
            root.left = buildTree(queue);
            root.right = buildTree(queue);
            return root;
        }
    }

删除二叉查找树的节点***

给定一棵具有不同节点值的二叉查找树，删除树中与给定值相同的节点。如果树中没有相同值的节点，就不做任何处理。你应该保证处理之后的树仍是二叉查找树。

 eeNode parent = findNode(dummy, root, value);//值为value的节点的父节点

public TreeNode deleteNode(TreeNode root, int key) {
       TreeNode dummy = new TreeNode(0);
       dummy.left = root;
       TreeNode parent = findNode(dummy, root, key);
       TreeNode node = null;
       if (parent.left != null && parent.left.val == key) {
           node = parent.left;
       } else if (parent.right != null && parent.right.val == key) {
           node = parent.right;
       } else {
           return dummy.left;
       }
       deleteNode(parent, node);
       return dummy.left;
        
    }
    public void deleteNode(TreeNode parent, TreeNode node) {
        if (node.right == null) {
            if (parent.left == node) {
                parent.left = node.left;
                return;
            } else {
                parent.right = node.left;
                return;
            }
        }
        TreeNode father = node;
        TreeNode rightMin = node.right;
        while (rightMin.left != null) {
            father = rightMin;
            rightMin = rightMin.left;
        }
        if (father.left == rightMin) {
            father.left = rightMin.right;
        } else {
            father.right = rightMin.right;
        }
        if (parent.left == node) {
            parent.left = rightMin;    
        } else {
            parent.right = rightMin;
        }
        rightMin.left = node.left;
        rightMin.right = node.right;
    }
    public TreeNode findNode(TreeNode parent, TreeNode root, int key) {
        if (root == null) {
            return parent;
        }
        if (root.val == key) {
            return parent;
        }
        if (root.val < key) {
            return findNode(root, root.right, key);
        } else {
            return findNode(root, root.left, key);
        }
    }

Kth Smallest Element in a BST

Given a binary search tree, write a function kthSmallest to find the kth smallest element in it.

方法一：中序遍历之后直接取得

def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if not root:
            return -1
        res=[]
        self.inorderTranverse(root, res)
        return res[k - 1]
    def inorderTranverse(self, root, res):
        if root.left:
            self.inorderTranverse(root.left, res)
        res.append(root.val)
        if root.right:
            self.inorderTranverse(root.right, res)

方法二：中序遍历到第k个元素返回

 def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if not root:
            return -1
        num = 0
        stack = []
        while root or len(stack)!=0:
            while root:
                stack.append(root)
                root = root.left
            node = stack.pop()
            num += 1
            if num == k:
                return node.val
            if node.right:
                root = node.right
        return -1

方法三：二分查找

def kthSmallest(self, root, k):
        """
        :type root: TreeNode
        :type k: int
        :rtype: int
        """
        if not root:
            return -1
        leftNum = self.getNodeNum(root.left)
        if leftNum >= k:
            return self.kthSmallest(root.left,k)
        elif leftNum < k - 1:
            return self.kthSmallest(root.right, k - leftNum - 1)
        else:
            return root.val
    def getNodeNum(self, root):
        if not root:
            return 0
        else:
            return self.getNodeNum(root.left) + self.getNodeNum(root.right) + 1

Binary Tree Serialization

public String serialize(TreeNode root) {
        // write your code here
        StringBuilder sb = new StringBuilder();
        return buildString(root, sb);
    }
    
    private String buildString(TreeNode root, StringBuilder sb) {
        if (root == null) {
            sb.append("#,");
            return sb.toString();
        }
        sb.append(root.val + ",");
        buildString(root.left, sb);
        buildString(root.right, sb);
        return sb.toString();
    }
public TreeNode deserialize(String data) {
        // write your code here
        if (data == null || data.length() == 0) {
            return null;
        }
        String[] strs = data.split(",");
        Queue<String> queue = new LinkedList<String>();
        queue.addAll(Arrays.asList(strs));
        return buildNode(queue);
    }
    
    private TreeNode buildNode(Queue<String> queue) {
        String cur = queue.poll();
        if (cur.equals("#")) {
            return null;
        } else {
            TreeNode root = new TreeNode(Integer.valueOf(cur));
            root.left = buildNode(queue);
            root.right = buildNode(queue);
            return  root;
        }
    }