【算法总结】Binary Tree & Binary Search Tree 二叉树

1. 描述：
   • 树的问题主要集中在特定条件下遍历travelsal (pre-order 中->左->右 ； inorder 左->中->右;  post-order 左->右->中)， 二分查找树 binary search tree。Binary Search Tree: 为root左边为小于它的值，右边为大于它的node.
2. 例题：
   • 二叉树的查找及遍历:
     • Path Sum
       
     • Symmetric Tree
       
     • Binary Tree Inorder Traversal
       
     • Binary Tree Level Order Traversal
       
   • Binary Search Tree:
     • Validate Binary Search Tree
       
     • Convert Sorted List to Binary Search Tree
       
   • 找最小公共祖先:
     • Lowest Common Ancestor of a Binary Tree
       
3. 解决方法：
   1. 遍历：
      
      • DFS: 迭代的话用stack, 或者用递归来模仿stack。
      • BFS：层序遍历，往往用queue
   2. BST: 利用BST inorder遍历为增序序列。
4. 复杂度：
   • 遍历时间复杂度O（n）n为node的数量
   • 空间复杂度为stack的大小，树的高度O（logn）
5. 代码模板示例：
   • 迭代 stack
   • 
     

     • <pre name="code" class="java">public ArrayList<Integer> preorderTraversal(TreeNode root) {  
       	    ArrayList<Integer> res = new ArrayList<Integer>();  
       	    if(root == null)  
       	        return res;  
       	    LinkedList<TreeNode> stack = new LinkedList<TreeNode>();  
       	    while(root!=null || !stack.isEmpty())  
       	    {  
       	        if(root!=null)  
       	        {  
       	            stack.push(root);  
       	            res.add(root.val);  
       	            root = root.left;  
       	        }  
       	        else  
       	        {  
       	            root = stack.pop();  
       	            root = root.right;  
       	        }  
       	    }  
       	    return res;  
       	}

       
       
       
       
       
       
   • Divide & Conquer 递归

   • public ArrayList<Integer> preorderTraversal(TreeNode root) {
     	        ArrayList<Integer> result = new ArrayList<Integer>();
     	        // null or leaf
     	        if (root == null) {
     	            return result;
     	        }
     
     	        // Divide
     	        ArrayList<Integer> left = preorderTraversal(root.left);
     	        ArrayList<Integer> right = preorderTraversal(root.right);
     
     	        // Conquer
     	        result.add(root.val);
     	        result.addAll(left);
     	        result.addAll(right);
     	        return result;
     	    }

     
     
     
   • 层序遍历 BFS

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