github · yuchaozh · Oct 29, 2018 · Oct 30, 2018 · Oct 30, 2018 · Nov 5, 2018
diff --git a/.gitignore b/.gitignore
@@ -0,0 +1,3 @@
+
+hs_err_pid11544.log
+*.log
diff --git a/.vscode/test.code-snippets b/.vscode/test.code-snippets
@@ -0,0 +1,18 @@
+{
+	// Place your global snippets here. Each snippet is defined under a snippet name and has a scope, prefix, body and 
+	// description. Add comma separated ids of the languages where the snippet is applicable in the scope field. If scope 
+	// is left empty or omitted, the snippet gets applied to all languages. The prefix is what is 
+	// used to trigger the snippet and the body will be expanded and inserted. Possible variables are: 
+	// $1, $2 for tab stops, $0 for the final cursor position, and ${1:label}, ${2:another} for placeholders. 
+	// Placeholders with the same ids are connected.
+	// Example:
+	// "Print to console": {
+	// 	"scope": "javascript,typescript",
+	// 	"prefix": "log",
+	// 	"body": [
+	// 		"console.log('$1');",
+	// 		"$2"
+	// 	],
+	// 	"description": "Log output to console"
+	// }
+}
diff --git a/1.two-sum.java b/1.two-sum.java
@@ -0,0 +1,107 @@
+import java.util.HashMap;
+import java.util.Map;
+
+/*
+ * @lc app=leetcode id=1 lang=java
+ *
+ * [1] Two Sum
+ *
+ * https://leetcode.com/problems/two-sum/description/
+ *
+ * algorithms
+ * Easy (41.89%)
+ * Total Accepted:    1.5M
+ * Total Submissions: 3.6M
+ * Testcase Example:  '[2,7,11,15]\n9'
+ *
+ * Given an array of integers, return indices of the two numbers such that they
+ * add up to a specific target.
+ * 
+ * You may assume that each input would have exactly one solution, and you may
+ * not use the same element twice.
+ * 
+ * Example:
+ * 
+ * 
+ * Given nums = [2, 7, 11, 15], target = 9,
+ * 
+ * Because nums[0] + nums[1] = 2 + 7 = 9,
+ * return [0, 1].
+ * 
+ * 
+ * 
+ * 
+ */
+
+
+// Solution 1
+// brute force with two loops
+// Time: O(n2)
+// Space: O(1)
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int[] results = new int[2];
+
+        for (int i = 0; i < nums.length; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (nums[i] + nums[j] == target) {
+                    results[0] = i;
+                    results[1] = j;
+                    return results;
+                }
+            }
+        }
+
+        return results;
+    }
+}
+
+// Solution 2
+// One pass with HashMap
+// Time: O(n)
+// Space: O(n)
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        int[] results = new int[2];
+        Map<Integer, Integer> map = new HashMap<>();
+
+        for (int i = 0; i < nums.length; i++) {
+            map.put(nums[i], i);
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            int sub = target - nums[i];
+            // 还需判断找到的元素不是当前元素
+            if (map.containsKey(sub) && map.get(sub) != i) {
+                results[0] = i;
+                results[1] = map.get(sub);
+                return results;
+            }
+        }
+
+        return results;
+    }
+}
+
+// Solution 3
+// one pass with HashMap
+// Time complexity: O(n)
+// Space complexity: O(n)
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        if (nums == null || nums.length < 2) {
+            return new int[]{};
+        }
+        Map<Integer, Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; i++) {
+            int complement = target - nums[i];
+            // 不需要判断是不是当前元素了，因为当前元素还没有添加进 map 里
+            if (map.containsKey(complement)) {
+                return new int[]{map.get(complement), i};
+            }
+            map.put(nums[i], i);
+        }
+        return new int[]{};
+    }
+}
+
diff --git a/100. Same Tree.md b/100. Same Tree.md
@@ -0,0 +1,122 @@
+### **Description** ###
+Given two binary trees, write a function to check if they are the same or not.
+
+Two binary trees are considered the same if they are structurally identical and the nodes have the same value.
+
+Example 1:
+```
+Input:     1         1
+          / \       / \
+         2   3     2   3
+
+        [1,2,3],   [1,2,3]
+
+Output: true
+```
+Example 2:
+```
+Input:     1         1
+          /           \
+         2             2
+
+        [1,2],     [1,null,2]
+
+Output: false
+```
+Example 3:
+```
+Input:     1         1
+          / \       / \
+         2   1     1   2
+
+        [1,2,1],   [1,1,2]
+
+Output: false
+```
+---
+### **Solution 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 isSameTree(TreeNode p, TreeNode q) {
+        if (p == null && q == null) {
+            return true;
+        }
+        if (p == null || q == null) {
+            return false;
+        }
+        if (p.val != q.val) {
+            return false;
+        }
+        return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+    }
+}
+```
+---
+### **Solution 2** ###
+Similar to the first one, need to make sure call recursion when `p.val == q.val`
+```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 isSameTree(TreeNode p, TreeNode q) {
+        if(p == null && q == null) return true;
+        if(p == null || q == null) return false;
+        if(p.val == q.val)
+            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
+        return false;
+    }
+}
+```
+---
+### **Solution 3** ###
+Iterative - BFS
+queue
+```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 isSameTree(TreeNode p, TreeNode q) {
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(p);
+        queue.add(q);
+        while (!queue.isEmpty()) {
+            TreeNode f = queue.poll();
+            TreeNode s = queue.poll();
+            if (f == null && s == null) {
+                continue;
+            } else if (f == null || s == null || f.val != s.val) {
+                return false;
+            }
+            queue.add(f.left);
+            queue.add(s.left);
+            queue.add(f.right);
+            queue.add(s.right);
+        }
+        return true;
+    }
+}
+```
diff --git a/1002.find-common-characters.java b/1002.find-common-characters.java
@@ -0,0 +1,86 @@
+/*
+ * @lc app=leetcode id=1002 lang=java
+ *
+ * [1002] Find Common Characters
+ *
+ * https://leetcode.com/problems/find-common-characters/description/
+ *
+ * algorithms
+ * Easy (65.76%)
+ * Likes:    306
+ * Dislikes: 44
+ * Total Accepted:    27.8K
+ * Total Submissions: 42.3K
+ * Testcase Example:  '["bella","label","roller"]'
+ *
+ * Given an array A of strings made only from lowercase letters, return a list
+ * of all characters that show up in all strings within the list (including
+ * duplicates).  For example, if a character occurs 3 times in all strings but
+ * not 4 times, you need to include that character three times in the final
+ * answer.
+ * 
+ * You may return the answer in any order.
+ * 
+ * 
+ * 
+ * 
+ * Example 1:
+ * 
+ * 
+ * Input: ["bella","label","roller"]
+ * Output: ["e","l","l"]
+ * 
+ * 
+ * 
+ * Example 2:
+ * 
+ * 
+ * Input: ["cool","lock","cook"]
+ * Output: ["c","o"]
+ * 
+ * 
+ * 
+ * 
+ * Note:
+ * 
+ * 
+ * 1 <= A.length <= 100
+ * 1 <= A[i].length <= 100
+ * A[i][j] is a lowercase letter
+ * 
+ * 
+ * 
+ */
+class Solution {
+    public List<String> commonChars(String[] A) {
+        if (A == null || A.length < 1) {
+            return new ArrayList<String>();
+        }
+
+        List<String> result = new ArrayList<>();
+        // a global array which stores the min frequent chars among all strings
+        int[] count = new int[26];
+        Arrays.fill(count, Integer.MAX_VALUE);
+
+        for (String str : A) {
+            // find out the frequent for all char from one string
+            int[] temp = new int[26];
+            for (int i = 0; i < str.length(); i++) {
+                temp[str.charAt(i) - 'a']++;
+            }
+            // update the global array, which determin the min frequent char among all strings
+            for (int i = 0; i < 26; i++) {
+                count[i] = Math.min(count[i], temp[i]);
+            }
+        }
+
+        for (int i = 0; i < count.length; i++) {
+            while (count[i]-- > 0) {
+                result.add(String.valueOf((char)(i + 'a')));
+            }
+        }
+
+        return result;
+    }
+}
+