Merge branch 'master' of github.com:V1ncentzzZ/leetcode

V1ncentzzZ · V1ncentzzZ · commit e21465e5c099 · 2018-12-08T09:47:21.000+08:00
diff --git a/2018.12.06-leetcode103/。V1ncentzzZ.md b/2018.12.06-leetcode103/。V1ncentzzZ.md
@@ -0,0 +1,51 @@
+[103. 二叉树的锯齿形层次遍历](https://leetcode-cn.com/problems/binary-tree-zigzag-level-order-traversal/)
+
+给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
+
+例如：
+给定二叉树 [3,9,20,null,null,15,7],
+
+    3
+   / \
+  9  20
+    /  \
+   15   7
+返回锯齿形层次遍历如下：
+
+[
+  [3],
+  [20,9],
+  [15,7]
+]
+
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
+        List<List<Integer>> result = new ArrayList<>();
+        if(root == null) return result;
+        executor(root, result, 0);
+        return result;
+    }
+    
+    public void executor(TreeNode node,List<List<Integer>> result,int high){
+        if(node == null) return;
+        if(result.size() <= high) result.add(new ArrayList<>());
+        if(high % 2 == 0){
+           result.get(high).add(node.val); 
+        }else {
+            result.get(high).add(0,node.val); 
+        }
+        executor(node.left, result, high+1); 
+        executor(node.right, result, high+1);
+    }
+}
+```
diff --git a/2018.12.07-leetcode104/。V1ncentzzZ.md b/2018.12.07-leetcode104/。V1ncentzzZ.md
@@ -0,0 +1,51 @@
+[104. 二叉树的最大深度][https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/]
+
+给定一个二叉树，找出其最大深度。
+
+二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例：
+给定二叉树 [3,9,20,null,null,15,7]，
+```
+   3
+   / \
+  9  20
+    /  \
+   15   7
+```
+返回它的最大深度 3 。
+
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+//     public int maxDepth(TreeNode root) {
+//         if(root == null) return 0;
+//         return getDepth(root.left,root.right,1);
+//     }
+    
+//     public int getDepth(TreeNode node1,TreeNode node2,int high){
+//         if(node1 == null && node2 == null) return high;
+//         high++;
+//         if(node1 == null) return getDepth(node2.left,node2.right,high);
+//         if(node2 == null) return getDepth(node1.left,node1.right,high);
+//         return Math.max(getDepth(node1.left,node1.right,high),getDepth(node2.left,node2.right,high));
+//     }
+    
+    public int maxDepth(TreeNode root) {
+        if(root == null) return 0;
+        int left = maxDepth(root.left);
+        int right = maxDepth(root.right);
+        return 1 + (left > right ? left : right);
+    }
+}
+```
