[Function add]

1. Add leetcode solutions with tag amazon.

Author: Seanforfun

leetcode/101. Symmetric Tree.md

@@ -108,3 +108,31 @@ class Solution {
       }
   }
   ```
+
+### Fourth Time
+* Method 1: recursion
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		public boolean isSymmetric(TreeNode root) {
+			if(root == null) return true;
+			return check(root.left, root.right);
+		}
+		private boolean check(TreeNode n1, TreeNode n2){
+			if(n1 == null && n2 == null) return true;
+			else if(n1 == null || n2 == null) return false;
+			else{
+				if(n1.val != n2.val) return false;
+				return check(n1.left, n2.right) && check(n1.right, n2.left);
+			}
+		}
+	}
+	```

leetcode/102. Binary Tree Level Order Traversal.md

@@ -126,3 +126,37 @@ class Solution {
       }
   }
   ```
+
+### Fourth Time
+* Method 1: BFS
+	```Java
+	/**
+	 * 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>> levelOrder(TreeNode root) {
+			List<List<Integer>> result = new ArrayList<>();
+			if(root == null) return result;
+			Queue<TreeNode> q = new LinkedList<>();
+			q.offer(root);
+			while(!q.isEmpty()){
+				List<Integer> temp = new ArrayList<>();
+				int size = q.size();
+				for(int i = 0; i < size; i++){
+					TreeNode node = q.poll();
+					temp.add(node.val);
+					if(node.left != null) q.offer(node.left);
+					if(node.right != null) q.offer(node.right);
+				}
+				result.add(temp);
+			}
+			return result;
+		}
+	}
+	```

leetcode/129. Sum Root to Leaf Numbers.md

@@ -141,4 +141,35 @@ class Solution {
 			if(node.right != null) dfs(node.right, cur);
 		}
 	}
+	```
+
+### Fourth Time
+* Method 1: dfs
+	```Java
+	/**
+	 * Definition for a binary tree node.
+	 * public class TreeNode {
+	 *     int val;
+	 *     TreeNode left;
+	 *     TreeNode right;
+	 *     TreeNode(int x) { val = x; }
+	 * }
+	 */
+	class Solution {
+		private int sum = 0;
+		public int sumNumbers(TreeNode root) {
+			if(root == null) return 0;
+			getNumber(root, 0);
+			return this.sum;
+		}
+		private void getNumber(TreeNode node, int num){
+			int cur = num * 10 + node.val;
+			if(node.left == null && node.right == null){
+				sum += cur;
+				return;
+			}
+			if(node.left != null) getNumber(node.left, cur);
+			if(node.right != null) getNumber(node.right, cur);
+		}
+	}
 	```

leetcode/165. Compare Version Numbers.md

@@ -93,4 +93,31 @@ class Solution {
         return 0;
     }
 }
-```
+```
+
+### Third Time
+* Method 1: String
+	```Java
+	class Solution {
+		public int compareVersion(String version1, String version2) {
+			String[] v1 = version1.split("\\.");
+			String[] v2 = version2.split("\\.");
+			int count1 = 0, count2 = 0;
+			while(count1 < v1.length || count2 < v2.length){
+				if(count1 < v1.length && count2 < v2.length){
+					int v1Num = Integer.parseInt(v1[count1++]);
+					int v2Num = Integer.parseInt(v2[count2++]);
+					if(v1Num < v2Num) return -1;
+					else if(v1Num > v2Num) return 1;
+				}else if(count1 < v1.length){
+					int v1Num = Integer.parseInt(v1[count1++]);
+					if(v1Num > 0) return 1;
+				}else{
+					int v2Num = Integer.parseInt(v2[count2++]);
+					if(v2Num > 0) return -1;
+				}
+			}
+			return 0;
+		}
+	}
+	```

leetcode/186. Reverse Words in a String II.md

@@ -0,0 +1,38 @@
+## 186. Reverse Words in a String II
+
+### Question
+Given an input string , reverse the string word by word. 
+
+```
+Example:
+
+Input:  ["t","h","e"," ","s","k","y"," ","i","s"," ","b","l","u","e"]
+Output: ["b","l","u","e"," ","i","s"," ","s","k","y"," ","t","h","e"]
+```
+
+Note: 
+* A word is defined as a sequence of non-space characters.
+* The input string does not contain leading or trailing spaces.
+* The words are always separated by a single space.
+
+Follow up: Could you do it in-place without allocating extra space?
+
+
+### Solution
+* Method 1: String operation
+    ```Java
+    class Solution {
+        public void reverseWords(char[] str) {
+            String s = new String(str);
+            String[] tokens = s.split(" ");
+            int count = 0;
+            for(int i = tokens.length - 1; i >= 0; i--){
+                for(char c : tokens[i].toCharArray()){
+                    str[count++] = c;
+                }
+                if(count < str.length)
+                    str[count++] = ' ';
+            }
+        }
+    }
+    ```

leetcode/270. Closest Binary Search Tree Value.md

@@ -0,0 +1,79 @@
+## 270. Closest Binary Search Tree Value
+
+### Question
+Given a non-empty binary search tree and a target value, find the value in the BST that is closest to the target.
+
+Note:
+* Given target value is a floating point.
+* You are guaranteed to have only one unique value in the BST that is closest to the target.
+
+```
+Example:
+
+Input: root = [4,2,5,1,3], target = 3.714286
+
+    4
+   / \
+  2   5
+ / \
+1   3
+
+Output: 4
+```
+
+
+### Solution
+* Method 1: recursion O(nlogn)
+    ```Java
+   /**
+     * Definition for a binary tree node.
+     * public class TreeNode {
+     *     int val;
+     *     TreeNode left;
+     *     TreeNode right;
+     *     TreeNode(int x) { val = x; }
+     * }
+     */
+    class Solution {
+        private double diff = Double.MAX_VALUE;
+        private int res;
+        public int closestValue(TreeNode root, double target) {
+            dfs(root, target);
+            return this.res;
+        }
+        private void dfs(TreeNode node, double target){
+            if(node == null) return;
+            else{
+                double diff = Math.abs(node.val - target);
+                if(diff < this.diff){
+                    this.diff = diff;
+                    this.res = node.val;
+                }
+                dfs(target < node.val ? node.left: node.right, target);
+            }
+        }
+    }
+    ```
+
+* Method 2: Itegeration
+    ```Java
+    class Solution {
+        public int maxSubArrayLen(int[] nums, int k) {
+            Map<Integer, Integer> map = new HashMap<>();
+            for(int i = 1; i < nums.length; i++){
+                nums[i] += nums[i - 1];
+            }
+            int max = 0;
+            map.put(0, -1);
+            for(int i = 0; i < nums.length; i++){
+                if(map.containsKey(nums[i] - k)){
+                    max = Math.max(max, i - map.get(nums[i] - k));
+                }
+                if(!map.containsKey(nums[i])){
+                    map.put(nums[i], i);
+                }
+            }
+            return max;
+        }
+    }
+    ```