algorithm004-01 · Leith14 · Dec 13, 2019 · Dec 13, 2019 · Dec 13, 2019 · Dec 13, 2019
diff --git a/Week 02/id_576/LeetCode_144_576.java b/Week 02/id_576/LeetCode_144_576.java
@@ -0,0 +1,40 @@
+package id_576;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class LeetCode_144_576 {
+
+    // Approach 1: recursion, O(n)
+    public List<Integer> preorderTraversal1(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        helper(root, res);
+        return res;
+    }
+
+    private void helper(TreeNode root, List<Integer> res) {
+        if (root == null) return;
+        res.add(root.val);
+        helper(root.left, res);
+        helper(root.right, res);
+    }
+
+    // Approach 2: stack with manual, O(n)
+    public List<Integer> preorderTraversal2(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        if (root == null) return res;
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode node = root;
+        while (node != null || !stack.isEmpty()) {
+            while (node != null) {
+                res.add(node.val);
+                stack.push(node);
+                node = node.left;
+            }
+            node = stack.pop().right;
+        }
+        return res;
+    }
+
+}
diff --git a/Week 02/id_576/LeetCode_145_576.java b/Week 02/id_576/LeetCode_145_576.java
@@ -0,0 +1,46 @@
+package id_576;
+
+import javax.naming.InsufficientResourcesException;
+import java.util.ArrayList;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Stack;
+
+public class LeetCode_145_576 {
+
+    // Approach 1: recursion, O(n)
+    public List<Integer> postorderTraversal1(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        helper(root, res);
+        return res;
+    }
+
+    private void helper(TreeNode root, List<Integer> res) {
+        if (root == null) return;
+        helper(root.left, res);
+        helper(root.right, res);
+        res.add(root.val);
+    }
+
+    // Approach 2: stack with manual, O(n)
+    /**
+     * 更为简洁的写法。这种解法的思想是先序遍历的变形，
+     * 先序遍历是“根->左->右”，后序遍历是“左->右->根”，
+     * 那么把先序遍历改成“根->右->左”，再逆序一下就是后序遍历。
+     * 没太明白意思？再多练习几遍
+     * 画一遍图有些理解了，等于是逆序，从后往前存值。
+     */
+    public List<Integer> postorderTraversal2(TreeNode root) {
+        List<Integer> res = new LinkedList<>();
+        if (root == null) return res;
+        Stack<TreeNode> stack = new Stack<>();
+        stack.push(root);
+        while (!stack.isEmpty()) {
+            TreeNode node = stack.pop();
+            res.add(0, node.val);
+            if (node.left != null) stack.push(node.left);
+            if (node.right != null) stack.push(node.right);
+        }
+        return res;
+    }
+}
diff --git a/Week 02/id_576/LeetCode_1_576.java b/Week 02/id_576/LeetCode_1_576.java
@@ -0,0 +1,37 @@
+package id_576;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LeetCode_1_576 {
+
+    // Approach 1: hash table
+    public int[] twoSum1(int[] nums, int target) {
+        int[] res = new int[2];
+        Map<Integer,Integer> map = new HashMap<>();
+        for (int i = 0; i < nums.length; ++i) {
+            if (map.containsKey(target - nums[i])) {
+                res[1] = i;
+                res[0] = map.get(target - nums[i]);
+                return res;
+            }
+            map.put(nums[i], i);
+        }
+        return res;
+    }
+
+    // Approach 2: brute force, O(n^2)
+    public int[] twoSum2(int[] nums, int target) {
+        int[] res = new int[2];
+        for (int i = 0; i < nums.length - 1; i++) {
+            for (int j = i + 1; j < nums.length; j++) {
+                if (nums[i] + nums[j] == target) {
+                    res[0] = i;
+                    res[1] = j;
+                    return res;
+                }
+            }
+        }
+        return new int[0];
+    }
+}
diff --git a/Week 02/id_576/LeetCode_242_576.java b/Week 02/id_576/LeetCode_242_576.java
@@ -0,0 +1,33 @@
+package id_576;
+
+import java.util.Arrays;
+
+public class LeetCode_242_576 {
+
+
+    public boolean isAnagram1(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        char[] str1 = s.toCharArray();
+        char[] str2 = t.toCharArray();
+        Arrays.sort(str1);
+        Arrays.sort(str2);
+        return Arrays.equals(str1, str2);
+    }
+
+    // Approach 2: hash、map，统计每个字符的频次
+    public boolean isAnagram2(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int[] counter = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            counter[s.charAt(i) - 'a']++;
+            counter[t.charAt(i) - 'a']--;
+        }
+        for (int count:counter) if (count != 0) return false;
+        return true;
+    }
+}
diff --git a/Week 02/id_576/LeetCode_49_576.java b/Week 02/id_576/LeetCode_49_576.java
@@ -0,0 +1,41 @@
+package id_576;
+
+import java.util.*;
+
+public class LeetCode_49_576 {
+
+    // Approach 1: sort, O(k * n * logN)
+    public List<List<String>> groupAnagrams1(String[] strs) {
+        if (strs.length == 0) return new ArrayList<>();
+        Map<String, List<String>> ans = new HashMap<>();
+        for (String s : strs) {
+            char[] ca = s.toCharArray();
+            Arrays.sort(ca);
+            String key = String.valueOf(ca);
+            if (!ans.containsKey(key)) ans.put(key, new ArrayList<>());
+            ans.get(key).add(s);
+        }
+        return new ArrayList<>(ans.values());
+    }
+
+    // Approach 2: counter, O(k * n * logN)
+    public List<List<String>> groupAnagrams2(String[] strs) {
+        if (strs.length == 0) return new ArrayList<>();
+        Map<String, List<String>> ans = new HashMap<>();
+        int[] count = new int[26];
+        for (String s: strs) {
+            Arrays.fill(count, 0);
+            for (char c : s.toCharArray()) count[c - 'a']++;
+
+            StringBuilder sb = new StringBuilder("");
+            for (int i = 0; i < 26; i++) {
+                sb.append('#');
+                sb.append(count[i]);
+            }
+            String key = sb.toString();
+            if (!ans.containsKey(key)) ans.put(key, new ArrayList<>());
+            ans.get(key).add(s);
+        }
+        return new ArrayList<>(ans.values());
+    }
+}
diff --git a/Week 02/id_576/LeetCode_590_576.java b/Week 02/id_576/LeetCode_590_576.java
@@ -0,0 +1,33 @@
+package id_576;
+
+import java.util.Arrays;
+
+public class LeetCode_242_576 {
+
+
+    public boolean isAnagram1(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+
+        char[] str1 = s.toCharArray();
+        char[] str2 = t.toCharArray();
+        Arrays.sort(str1);
+        Arrays.sort(str2);
+        return Arrays.equals(str1, str2);
+    }
+
+    // Approach 2: hash、map，统计每个字符的频次
+    public boolean isAnagram2(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        int[] counter = new int[26];
+        for (int i = 0; i < s.length(); i++) {
+            counter[s.charAt(i) - 'a']++;
+            counter[t.charAt(i) - 'a']--;
+        }
+        for (int count:counter) if (count != 0) return false;
+        return true;
+    }
+}
diff --git a/Week 02/id_576/LeetCode_94_576.java b/Week 02/id_576/LeetCode_94_576.java
@@ -0,0 +1,43 @@
+package id_576;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Stack;
+
+public class LeetCode_94_576 {
+
+
+    // Approach 1: recursion, O(n)
+    public List<Integer> inorderTraversal1(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        helper(root, res);
+        return res;
+    }
+
+    private void helper(TreeNode root, List<Integer> res) {
+        if (root != null) {
+            if (root.left != null) helper(root.left, res);
+            res.add(root.val);
+            if (root.right != null) helper(root.right, res);
+        }
+    }
+
+    // Approach 2: create a stack with manual, O(n)
+    public List<Integer> inorderTraversal2(TreeNode root) {
+        List<Integer> res = new ArrayList<>();
+        Stack<TreeNode> stack = new Stack<>();
+        TreeNode node = root;
+        while (node != null || !stack.isEmpty()) {
+            while (node != null) {
+                stack.push(node);
+                node = node.left;
+            }
+            node = stack.pop();
+            res.add(node.val);
+            node = node.right;
+        }
+        return res;
+    }
+
+
+}
diff --git a/Week 03/id_576/LeetCode_102_576.java b/Week 03/id_576/LeetCode_102_576.java
@@ -0,0 +1,48 @@
+package id_576;
+
+import jdk.nashorn.api.tree.Tree;
+
+import java.time.temporal.Temporal;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.LinkedList;
+import java.util.List;
+
+public class LeetCode_102_576 {
+
+    //Approach 1: BFS, O(n)
+    public List<List<Integer>> levelOrder1(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        if (root == null) return res;
+        Deque<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            List<Integer> tmp = new ArrayList<>();
+            int cnt = queue.size();
+            for (int i = 0; i < cnt; i++) {//为什么直接写queue.size()会报错？
+                // 因为queue.size()在循环体里值不会改变，需要借助变量cnt改变
+                TreeNode node = queue.poll();
+                tmp.add(node.val);
+                if (node.left != null) queue.add(node.left);
+                if (node.right != null) queue.add(node.right);
+            }
+            res.add(tmp);
+        }
+        return res;
+    }
+
+    //Approach 2: DFS, O(n)
+    public List<List<Integer>> levelOrder2(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        helper(res, root, 0);
+        return res;
+    }
+
+    private void helper(List<List<Integer>> res, TreeNode root, int level) {
+        if (root == null) return;
+        if (res.size() == level) res.add(new LinkedList<>());
+        res.get(level).add(root.val);
+        helper(res, root.left, level + 1);
+        helper(res, root.right, level + 1);
+    }
+}
diff --git a/Week 03/id_576/LeetCode_200_576.java b/Week 03/id_576/LeetCode_200_576.java
@@ -0,0 +1,24 @@
+package id_576;
+
+public class LeetCode_200_576 {
+
+    //Approach 1: floodfill, O(M * N)
+    char[][] g;
+    public int numIslands(char[][] grid) {
+        int islands = 0;
+        g = grid;
+        for (int i=0; i<g.length; i++)
+            for (int j=0; j<g[i].length; j++)
+                islands += sink(i, j);
+        return islands;
+    }
+    int sink(int i, int j) {
+        if (i < 0 || i == g.length || j < 0 || j == g[i].length || g[i][j] == '0')
+            return 0;
+        g[i][j] = '0';
+        sink(i+1, j); sink(i-1, j); sink(i, j+1); sink(i, j-1);
+        return 1;
+    }
+
+
+}