Merge pull request Hearen#99 from cxxly/chenxiaoxu

update

Author: Hearen

ChenXiaoxu/103. Binary Tree Zigzag Level Order Traversal.md

@@ -0,0 +1,55 @@
+# 103. Binary Tree Zigzag Level Order Traversal
+
+## Problem
+
+Given a binary tree, return the zigzag level order traversal of its nodes' values. (ie, from left to right, then right to left for the next level and alternate between).
+
+For example:
+Given binary tree {3,9,20,#,#,15,7},
+    3
+   / \
+  9  20
+    /  \
+   15   7
+return its zigzag level order traversal as:
+[
+  [3],
+  [20,9],
+  [15,7]
+]
+
+tag:
+- bfs  
+
+## Solution
+
+广度优先搜索，用一个变量纪录层数，奇数层，结果加入子链表尾部，偶数层加入子链表头部
+
+**java**
+```java
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> res = new LinkedList<List<Integer>>();
+        if(root==null) return res;
+        Queue<TreeNode> q = new LinkedList<TreeNode>();
+        q.offer(root);
+        boolean level = false;
+        while(!q.isEmpty()) {
+            int levelNum = q.size();
+            List<Integer> subList = new LinkedList<Integer>();
+            for(int i=0; i<levelNum; i++) {
+                if(q.peek().left!=null) q.offer(q.peek().left);
+                if(q.peek().right!=null) q.offer(q.peek().right);
+                if(level) subList.add(0, q.poll().val);
+                else subList.add(q.poll().val);
+            }
+            res.add(subList);
+            level = !level;
+        }
+        return res;
+    }
+```
+
+**go**
+```go
+
+```

ChenXiaoxu/104. Maximum Depth of Binary Tree.md

@@ -0,0 +1,25 @@
+# 104. Maximum Depth of Binary Tree
+
+## Problem
+Given a binary tree, find its maximum depth.
+
+The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.
+
+tag:
+
+## Solution
+
+最大树高=左右子树种较高的一个+1
+
+**java**
+```java
+    public int maxDepth(TreeNode root) {
+        if(root==null) return 0;
+        return Math.max(maxDepth(root.left), maxDepth(root.right))+1;
+    }
+```
+
+**go**
+```go
+
+```

ChenXiaoxu/111. Minimum Depth of Binary Tree.md

@@ -0,0 +1,29 @@
+# 111. Minimum Depth of Binary Tree
+
+## Problem
+
+Given a binary tree, find its minimum depth.
+
+tag:
+
+## Solution
+
+当前树最小高度等于：
+- 若左子树为空， 右子树高度+1
+- 若有子树为空， 左子树高度+1
+- 左右子树种最小高度+1
+
+**java**
+```java
+    public int minDepth(TreeNode root) {
+        if(root==null) return 0;
+        if(root.left==null) return minDepth(root.right)+1;
+        if(root.right==null) return minDepth(root.left)+1;
+        return Math.min(minDepth(root.left), minDepth(root.right))+1;
+    }
+```
+
+**go**
+```go
+
+```

ChenXiaoxu/94. Binary Tree Inorder Traversal.md

@@ -0,0 +1,63 @@
+# 94. Binary Tree Inorder Traversal
+
+## Problem
+
+Given a binary tree, return the inorder traversal of its nodes' values.
+
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+```
+
+tag:
+
+## Solution
+
+### 递归
+
+**java**
+```java
+    public List<Integer> inorderTraversal(TreeNode root, List<Integer> res) {
+        if(root!=null) {
+            inorderTraversal(root.left, res);
+            res.add(root.val);
+            inorderTraversal(root.right, res);
+        }
+        return res;
+    }	
+```
+
+**go**
+```go
+
+```
+
+### 迭代
+
+``` java
+    public List<Integer> inorderTraversal(TreeNode root) {
+        List<Integer> res = new LinkedList<Integer>();
+        Stack<TreeNode> s = new Stack<TreeNode>();
+        TreeNode p = root;
+        while(p!=null || !s.isEmpty()) {
+            //push root to stack, traverse left subtree
+           if(p!=null) {
+               s.push(p);
+               p=p.left;
+           } else {
+               //pop root, visit root node, and travese right subtree
+               p = s.pop();
+               res.add(p.val);
+               p = p.right;
+           }
+        }
+        return res;
+    }
+```