Data Structure and Algorithm

Array & ArrayList

1.   Move Zeros

双指针

class Solution {
    public void moveZeroes(int[] nums) {
        if (nums.length == 0) {
            return;
        }
        int i = 0;
        int j = 0;
        int len = nums.length;
        while (j < len) {
            while (i < len && nums[i] != 0) {
                i++;
            }
            while (j < len && (j < i || nums[j] == 0)) {
                j++;
            }
            if (i < len && j < len) {
                swap(nums, i, j);
            }
        }
    }
    
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

2.   Missing Number - Not Bug Free

思路一： HashSet

class Solution {
    public int missingNumber(int[] nums) {
        HashSet set = new HashSet();
        for (int i : nums) {
            set.add(i);
        }
        for (int i = 0; i < nums.length + 1; i++) {
            if (!set.contains(i)) {
                return i;
            }
        }
        return nums.length;
    }
}

思路二： Swap. - Not Bug Free - Bug Free

class Solution {
    public int missingNumber(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            while (nums[i] != i && nums[i] <= nums.length - 1) {
                swap(nums, i, nums[i]);
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (i != nums[i]) {
                return i;
            }
        }
        return nums.length;
    }
    
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

 3.   3Sum Closest - Not Bug Free - Bug Free

坑：将sum写在判断语句之后会引起漏掉。

class Solution {
    public int threeSumClosest(int[] nums, int target) {
        Arrays.sort(nums);
        int sum = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length; i++) {
            int j = i + 1;
            int k = nums.length - 1;
            while (j < k) {
                int tmp = nums[i] + nums[j] + nums[k];
                sum = Math.abs(sum - target) > Math.abs(tmp - target) ? tmp : sum; 
                if (tmp == target) {
                    return tmp;
                } else if (tmp > target) {
                    k--;
                } else {
                    j++;
                }
            }
        }
        return sum;
    }
}

 4.    Max Consecutive Ones - Not Bug Free  - Not Bug Free

坑：注意好循环之后i, j的所在位置. 注意max的计算之后 i 的值要变化. 

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        int max = 0;
        int i = 0;
        int j = 0;
        while (j < nums.length) {
            while (i < nums.length && (i < j || nums[i] != 1)) {
                i++;
            }
            while (j < nums.length && (j < i || nums[j] == 1)) {
                j++;
            }
            max = max > (j - i) ? max : (j - i);
        }
        return max;
    }
}

 5.   Rotate Array - Not Bug Free - Bug Free

坑： index从0开始，第一个reverse是(0, K-1). 

class Solution {
    public void rotate(int[] nums, int k) {
        if (nums.length == 0) {
            return;
        }
        k = k%nums.length;
        reverse(nums, 0, nums.length - 1);
        reverse(nums, 0, k - 1);
        reverse(nums, k, nums.length - 1);
    }
    
    public void reverse(int[] nums, int i, int j) {
        while (i < j) {
            int tmp = nums[i];
            nums[i] = nums[j];
            nums[j] = tmp;
            i++;
            j--;
        }
    }
}

 6.   First Missing Positive - Not Bug Free - Very Important - Not Bug Free

坑： 注意index可能 < 0.

class Solution {

    public int firstMissingPositive(int[] nums) {
        for (int i = 0; i < nums.length; i++) {
            while (nums[i] != i + 1 && nums[i] > 0 && nums[i] <= nums.length && nums[i] != nums[nums[i] - 1]) {
                swap(nums, i, nums[i] - 1);
            }
        }
        
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i + 1) {
                return i + 1;
            }
        }
        return nums.length + 1;
    }
    
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

 7.   Majority Element

class Solution {
    public int majorityElement(int[] nums) {
        Arrays.sort(nums);
        return nums[nums.length/2];
    }
}

 8.   Merge Sorted Array

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        int[] tmp = new int[m+n];
        int i = 0;
        int j = 0;
        int k = 0;
        while (j < m && k < n) {
            tmp[i++] = nums1[j] < nums2[k] ? nums1[j++] : nums2[k++];
        }
        while (j < m) {
            tmp[i++] = nums1[j++];
        }
        while (k < n) {
            tmp[i++] = nums2[k++];
        }
        System.out.println(Arrays.toString(tmp));
    }
}

9.   Largest Number At Least Twice of Others  - Not Bug Free - Not Bug Free 

心得1：比较元素时将[0]作为基准，从[1]开始比较. 认真分析判断条件.

心得2：比较元素时将[0]作为基准，从[1]开始比较. 认真分析判断条件.

class Solution {
    public int dominantIndex(int[] nums) {
        if (nums.length == 0) {
            return -1;
        }
        int max = nums[0];
        int index = 0;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] >= 2 * max) {
                max = nums[i];
                index = i;
            } else if (max < 2 * nums[i]){
                index = -1;
                if (max < nums[i]) {
                    max = nums[i];
                }
            }
        }
        return index;
    }
}

 10.   Max Chunks To Make Sorted ( I & II) - Not Bug Free - Not Bug Free

思路：if max(arr[ : A-1]) <= min(arr[A-1 : ]), then we can split it into two chunks.

class Solution {
    public int maxChunksToSorted(int[] arr) {
        int[] max = new int[arr.length];
        int[] min = new int[arr.length];
        max[0] = arr[0];
        min[arr.length - 1] = arr[arr.length - 1];
        for (int i = 1; i < arr.length; i++) {
            max[i] = Math.max(arr[i], max[i-1]);
        }
        for (int i = arr.length - 2; i >= 0; i--) {
            min[i] = Math.min(arr[i], min[i+1]);
        }
        int ans = 0;
        for (int i = 0; i < arr.length - 1; i++) {
            if (max[i] <= min[i+1]) {
                ans++;
            }
        }
        return ans + 1;
    }
}

 11.   remove Element - Not Bug Free - Not Bug Free

Pitfall: Template for two-pointer; Be careful when calculating length.

Pitfall: There are two ways of calculating length. One is by using "i" and the other is to use (nums.length - (j - i)).

class Solution {
    public int removeElement(int[] nums, int elem) {
        int i = 0;
        int j = 0;
        while (j < nums.length) {
            while (i < nums.length && nums[i] != elem) {
                i++;
            }
            while (j < nums.length && (j < i || nums[j] == elem)) {
                j++;
            }
            if (i < nums.length && j < nums.length) {
                swap(nums, i, j);
            }
        }
        // OR return nums.length - (j - i);
        return i;
    }
    
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

 12.   Subarray Sum - Not Bug Free - Not Bug Free

坑：edge cases，想清楚逻辑.

坑：subarray的两个Index 可以相同. 当 nums[i] == 0 时直接返回.

public class Solution {
    public List<Integer> subarraySum(int[] nums) {
        // write your code here
        List<Integer> ans = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            int sum = nums[i];
            if (sum == 0) {
                ans.add(i);
                ans.add(i);
                return ans;
            }
            for (int j = i + 1; j < nums.length; j++) {
                sum += nums[j];
                if (sum == 0) {
                    ans.add(i);
                    ans.add(j);
                    return ans;
                }
            }
        }
        return ans;
    }
}

13.   Remove Duplicates from Sorted Array - Not Bug Free  - Not Bug Free

思路：当不在乎后面数的时候可以不用swap，而是直接后面的值赋给前面。本质是双指针，先找到一个值，然后再找下一个与其值不等的值，再赋值。

坑：双指针；在纸上画出逻辑；加上comment.

public class Solution {
    public int removeDuplicates(int[] nums) {
        //  TODO: len == 0
                if (nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return 1;
        }
        int i = 1;
        int j = 1;
        int cnt = 1;
        while (j < nums.length) {
            if (nums[j] == nums[j-1]) {
                j++;
            } else {
                cnt = 1;
                nums[i++] = nums[j++];
            }
        }
        return i;
    }
}

 14.   Product of Array Except Self  - Not Bug Free - Bug Free

思路：分左右两端乘积. 先计算左边乘积，再计算右边乘积

class Solution {
    public int[] productExceptSelf(int[] nums) {
        int[] ans = new int[nums.length];
        int tmp = 1;
        for (int i = 0; i < nums.length; i++) {
            ans[i] = tmp;
            tmp *= nums[i];
        }
        tmp = 1;
        for (int i = nums.length - 1; i >= 0; i--) {
            ans[i] *= tmp;
            tmp *= nums[i];
        }
        return ans;
    }
}

 15.    3Sum  - Not Bug Free - Bug Free

思路：2 sum的思路，很多细节要注意。尝试想几个test case，分析他们，然后再代码。

class Solution {
    public List<List<Integer>> threeSum(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        if (nums.length < 3) {
            return results;
        }
        Arrays.sort(nums);
        int sum = nums[0] + nums[1] + nums[2];
        for (int i = 0; i < nums.length - 2; i++) {
            // skip duplicates 
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            int j = i + 1;
            int k = nums.length - 1;
            while (j < k) {
                sum = nums[i] + nums[j] + nums[k];
                if (sum == 0) {
                    // j++ and k-- is to prevent infinite loop
                    results.add(Arrays.asList(nums[i], nums[j++], nums[k--]));
                    // skip duplicates [j] == [j-1] because of [j++] in the above step
                    while (j < k && nums[j] == nums[j-1]) {
                        j++;
                    }
                    // skip duplicates [k] == [k+1] because of [k--] in the above step
                    while (j < k && nums[k] == nums[k+1]) {
                        k--;
                    }
                } else if (sum > 0) {
                    k--;
                } else {
                    j++;
                } 
            }
        }
        return results;
    }
}

16.   4Sum - Not Bug Free - Bug Free

思路：如何跳过重复值，sum在何处计算。

public class Solution {
    public List<List<Integer>> fourSum(int[] nums, int target) {
        Arrays.sort(nums);
        List<List<Integer>> ans = new ArrayList<>();
        for (int i = 0; i < nums.length - 3; i++) {
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            for (int j = i+1; j < nums.length -2; j++) {
                if (j > i+1 && nums[j] == nums[j-1]) {
                    continue;
                }
                int m = j + 1;
                int k = nums.length - 1;
                while (m < k) {
                   int sum = nums[i] + nums[j] + nums[m] + nums[k];
                   if (sum == target) {
                        ans.add(Arrays.asList(nums[i], nums[j], nums[m++], nums[k--]));
                        while (m < k && nums[m] == nums[m-1]) {
                            m++;
                        }
                        while (m < k && nums[k] == nums[k+1]) {
                            k--;
                        }
                    } else if (sum < target) {
                        m++;
                    } else {
                        k--;
                    } 
                }
            }
        }
        return ans;
    }
}

17.   Remove Duplicates from Sorted Array II  - Not Bug Free - Not Bug Free

思路：初始化count = 1, 一旦后一个和前一个不相等，count 又变为 = 1.

判断nums[i] == nums[i+1] 没有 nums[i] == nums[i-1] 好，前者容易漏掉元素。

坑：第一个循环里一点你给要写成nums[i++] = nums[j++]. 因为当cnt再次等于1时，单纯的i++, j++不会将后面的值重新付给前面了

class Solution {
    public int removeDuplicates(int[] nums) {
        // TODO len = 0
        if (nums.length == 0) {
            return 0;
        }
        int cnt = 1;
        int i = 1;
        int j = 1;
        while (j < nums.length) {
            if (nums[j] == nums[j-1]) {
                if (cnt < 2) {
                    cnt++;
                    nums[i++] = nums[j++];
                } else {
                    j++;
                }
            } else {
                cnt = 1;
                nums[i++] = nums[j++];
            }
        }
        return i;
    }
}

18.   Minimum Size Subarray Sum - Not Bug Free - Not Bug Free

思路：双指针。

坑：计算长度时，j会等于len，然后循环就终止了，所以这个不行！！！

public class Solution {
    public int minimumSize(int[] nums, int s) {
        // write your code here
        int i = 0;
        int j = 0;
        int sum = 0;
        int min = Integer.MAX_VALUE;
        while (j < nums.length) {
        /*    计算长度时，j会等于len，然后循环就终止了，所以这个不行！！！
            if (sum < s) {
                sum += nums[j++];
            } else {
                if (j >= i) {
                    min = Math.min(min, j-i);
                    sum -= nums[i++]; 
                }
            }
        */    
            sum += nums[j++];
            while (sum >= s && i <= j) {
                min = Math.min(min, j-i);
                sum -= nums[i++]; 
            }
        }
        return min == Integer.MAX_VALUE ? -1 : min;
    }
}

 19.   Subarray Sum Closest - Not Bug Free - New

思路：本质是prefixSum(m) - prefixSum(n)的最小值. prefixSum排序，计算哪组prefixSum(i+1) - prefixSum(i)最小. 返回 (lower+1, upper).

 20. Fruit Into Baskets - 1st Not Bug Free

思路：双指针

坑：注意while loop后面的index要适当变化。firstIdx, firstValue, lastIdx, lastValue.

class Solution {
    public int totalFruit(int[] tree) {
        if (tree == null) {
            return 0;
        }
        if (tree.length <= 2) {
            return tree.length;
        }
        int i = 0; 
        int j = 0;
        int max = 0;
        while (i < tree.length && j < tree.length) {
            while (j < tree.length && (j < i || tree[i] == tree[j])) {
                j++;
            }
            int first = tree[i];
            int firstIdx = i;
            int second = 0;
            if (j < tree.length) {
                second = tree[j];
                while (j < tree.length && j >= 0 && (tree[j] == second || tree[j] == first)) {
                    j++;
                }
            }
            int lastIdx = j - 1;
            int lastValue = tree[lastIdx];
            max = Math.max(j - firstIdx, max);
            if (tree[lastIdx] == lastValue) {
                while (lastIdx < tree.length && lastIdx >= 0 && tree[lastIdx] == lastValue) {
                    lastIdx--;
                }
                lastIdx++;
            }
            i = lastIdx;
        }
        return max;
    }
}

 

 

String

1.    Repeated string match - Not Bug Free - Bug Free

坑：Substring长度最多为bLength/aLength + 1; indexOf的应用.

class Solution {
    public int repeatedStringMatch(String A, String B) {
        int aLength = A.length();
        int bLength = B.length();
        if (aLength == 0 && bLength == 0) {
            return 1;
        }
        if (aLength == 0 || bLength == 0) {
            return -1;
        }
        int times = 1;
        if (aLength > bLength) {
            while (times <= 2) {
                String str = makeString(A, times);
                if (isSubstring(str, B)) {
                    return times;
                }
                times++;
            }
            return -1;
        }
        times = bLength/aLength;
        while (times <= bLength/aLength + 1) {
            String str = makeString(A, times);
            if (isSubstring(str, B)) {
                return times;
            }
            times++;
        }
        return -1;
    }
    
    public boolean isSubstring(String A, String B) {
        for (int i = 0; i <= A.length() - B.length(); i++) {
                if (A.substring(i, i + B.length()).equals(B)) {
                    return true;
                }
            }
        return false;
    }
    
    public String makeString(String A, int times) {
        String str = "";
        while (times-- != 0) {
            str += A;
        }
        return str;
    }
}

class Solution {
    public int repeatedStringMatch(String A, String B) {
        int aLength = A.length();
        int bLength = B.length();
        StringBuilder str = new StringBuilder();
        int nums = 0;
        while (str.indexOf(B) < 0) {
            if (str.length() > aLength + bLength) {
                return -1;
            }
            str.append(A);
            nums++;
        }
        return nums;
    }
}

 2.   Repeated Substring Pattern - Not Bug Free  - Not Bug Free

坑：Substring的长度最多为原String的1/2; 长度取余必须为0; 一部分一部分比较.

坑：关于str.length() 的loop最大值可以到str.length(); while loop有continue语句很危险，要记得用for loop.

class Solution {
    public boolean repeatedSubstringPattern(String s) {
        if (s == "") {
            return true;
        }
        for (int i = 1; i <= s.length()/2; i++) {
            String subStr = s.substring(0, i);
            if (s.length()%subStr.length() != 0) {
                continue;
            }
            for (int j = i; j <= s.length() - subStr.length(); j += subStr.length()) {
                if (!subStr.equals(s.substring(j, j+subStr.length()))) {
                    break;
                }
                if (j == s.length() - subStr.length()) {
                    return true;
                }
            }
        }
        return false;
    }
}

public boolean repeatedSubstringPattern(String str) {
    int l = str.length();
    for(int i=l/2;i>=1;i--) {
        if(l%i==0) {
            int m = l/i;
            String subS = str.substring(0,i);
            StringBuilder sb = new StringBuilder();
            for(int j=0;j<m;j++) {
                sb.append(subS);
            }
            if(sb.toString().equals(str)) return true;
        }
    }
    return false;
}

public boolean repeatedSubstringPattern(String str) {
    String s = str + str;
    return s.substring(1, s.length() - 1).contains(str);
}

 3.   Valid Parentheses - Bug Free

class Solution {
    public boolean isValid(String str) {
        Stack<Character> s = new Stack<>();
        int i = 0;
        while (i < str.length()) {
            switch (str.charAt(i++)) {
                    case '(': 
                        s.push('(');
                        break;
                    case '{':
                        s.push('{');
                        break;
                    case '[':
                        s.push('[');
                        break;
                    case ')':
                        if (s.empty() || !s.pop().equals('(')) {
                            return false;
                        } 
                        break;
                    case '}':
                        if (s.empty() || !s.pop().equals('{')) {
                            return false;
                        }
                        break;
                    case ']':
                        if (s.empty() || !s.pop().equals('[')) {
                            return false;
                        }
                        break;
                    default:
                        break;
            }
        }
        return s.empty();
    }
}

 4.   Reverse String - Not Bug Free

坑: 注意while的i--.

class Solution {
    public String reverseString(String s) {
        int len = s.length();
        char[] arr = new char[len];
        int i = len - 1;
        while (i >= 0) {
            arr[len - 1 - i] = s.charAt(i);
            i--;
        }
        return new String(arr);
    }
}

还可以利用string里的char交换.

public class Solution {
    public String reverseString(String s) {
        char[] arr = s.toCharArray();
        int len = arr.length;
        for (int i = 0; i < len/2; i++) {
            char tmp = arr[i];
            arr[i] = arr[len - 1 - i];
            arr[len - 1 - i] = tmp;
        }
        return new String(arr);
    }
}

 5.   Implement strStr()

class Solution {
    public int strStr(String haystack, String needle) {
        if (needle.length() == 0) {
            return 0;
        }
        for (int i = 0; i < haystack.length(); i++) {
            if (haystack.charAt(i) == needle.charAt(0)) {
                for (int j = 0; j < needle.length(); j++) {
                    if (i + j >= haystack.length()) {
                        return -1;
                    }
                    if (haystack.charAt(i + j) != needle.charAt(j)) {
                        break;
                    }
                    if (j == needle.length() - 1) {
                        return i;
                    }
                }
            }
        }
        return -1;
    }
}

 6.   Longest Common Prefix

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }
        int max = 0;
        for (int i = 0; i <= strs[0].length(); i++) {
            String s = strs[0].substring(0, i);
            for (int j = 1; j < strs.length; j++) {
                if (i > strs[j].length() || !s.equals(strs[j].substring(0, i))) {
                    return strs[0].substring(0, max);
                }
            }
            max = i;
        }
        return strs[0].substring(0, max);
    }
}

思路二：从最长的开始判断，如果不行，长度减一，再进行判断.

class Solution {
    public String longestCommonPrefix(String[] strs) {
        if (strs.length == 0) {
            return "";
        }
        String pre = strs[0];
        int i = 1;
        while (i < strs.length) {
            if (strs[i].indexOf(pre) != 0) {
                pre = pre.substring(0, pre.length() - 1);
                i = 1;
            } else {
                i++;
            }
            
        }
        return pre;
    }
}

 7.   Reverse Words in a String - Very Important - Not Bug Free - Not Bug Free

坑： 我忘记去掉字符串尾部的space了。

public class Solution {
    public String reverseWords(String s) {
        // write your code here
        // get rid of spaces in the front and end
        // reverse the whole string
        // reverse every word
        if (s.equals("")) {
            return "";
        }
        char[] chars = s.toCharArray();
        int len = chars.length;
        reverse(chars, 0, len - 1);
        reverseWord(chars, 0, 0, len);
        return cleanSpaces(chars, len);
    }
    
    public void reverse(char[] chars, int i, int j) {
        while (i < j) {
            char tmp = chars[i];
            chars[i++] = chars[j];
            chars[j--] = tmp;
        }
    }
    
    public void reverseWord(char[] chars, int i, int j, int len) {
        while (j < len) {
            while (i < len && (i < j || chars[i] == ' ')) {
                i++;
            }
            while (j < len && (j < i || chars[j] != ' ')) {
                j++;
            }
            reverse(chars, i, j-1);
        }
    }
    
    public String cleanSpaces(char[] chars, int len) {
        int i = 0;
        int j = 0;
        System.out.println(String.valueOf(chars));
        while (j < len) {
            while (j < len && chars[j] == ' ') {
                j++;
            }
            while (j < len && chars[j] != ' ') {
                chars[i++] = chars[j++];
            }
            while (j < len && chars[j] == ' ') {
                j++;
            }
            if (j < chars.length) {
                chars[i++] = ' ';
            }
        }
        return String.valueOf(chars).substring(0, i);
    }
}

 8.   Strstr - Not Bug Free

坑：lenS - lenT 注意循环的条件；i + lenT > lenS也是循环终止的条件

public class Solution {
    public int strStr(String source, String target) {
        if (source == null || target == null) {
            return -1;
        }
        char[] s = source.toCharArray();
        char[] t = target.toCharArray();
        if (s.length < t.length) {
            return -1;
        }
        if (t.length == 0) {
            return 0;
        }
        int i = 0;
        while (i < s.length) {
            while (i < s.length && s[i] != t[0]) {
                i++;
            } 
            if (i + t.length > s.length) {
                return -1;
            }
            for (int m = 0; m < t.length; m++) {
                if (i+m < s.length && t[m] != s[i+m]) {
                    i++;
                    break;
                }
                if (m == t.length - 1) {
                    return i;
                }
            }
        }
        return -1;
    }
}

 

 

LinkedList

1.   Remove Nth Node From End of List - Not Bug Free -  Bug Free

思路：快慢指针. 

坑：n = n = n > len ? len - n%len : n;

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null) {
            return head;
        }
        int len = 0;
        ListNode cur = head;
        while (cur != null) {
            len++;
            cur = cur.next;
        }
        
        n = n > len ? len - n%len : n;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode fast = dummy;
        ListNode slow = dummy;
        while (n-- != 0) {
            fast = fast.next;
        }
        while (fast.next != null) {
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return dummy.next;
    }
}

 2.   Middle Node - Not Bug Free

坑：分奇偶讨论 fast.next != null && fast.next.next != null

public ListNode middle(ListNode head) {
    ListNode fast = head;
    ListNode slow = head;
    while (fast.next != null && fast.next.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }
    return slow;
}

3.   Linked List Cycle

思路：和Middle Node思路一致.

public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null) {
            return false;
        }
        ListNode fast = head;
        ListNode slow = head;
        while (fast.next != null && fast.next.next != null) {
            if (fast.next == slow) {
                return true;
            }
            fast = fast.next.next;
            slow = slow.next;
        }
        return false;
    }
}

 4.   Remove Duplicates from Sorted List

要和面试官讨论dummy node的值是否可以为-1

class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode dummy = new ListNode(Integer.MIN_VALUE);
        dummy.next = head;
        ListNode cur = dummy;
        while (cur.next != null) {
            if (cur.val == cur.next.val) {
                cur.next = cur.next.next;
            } else {
                cur = cur.next;
            }
        }
        return dummy.next;
    }
}

5.   Reverse Linked List - Not Bug Free

坑：当dummy的初始值为null的时候要特别注意.

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode dummy = null;
        ListNode pre = dummy;
        ListNode cur = head;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

思路二：不使用dummy node

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode cur = head;
        ListNode next = cur.next;
        while (next != null) {
            ListNode third = next.next;
            next.next = cur;
            cur = next;
            next = third;
        }
        head.next = null;
        return cur;
    }
}

 6.   Swap Nodes in Pairs - Not Bug Free

坑: 分奇偶讨论while循环的条件cur != null && cur.next != null； dummy node 作为模板使用.

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy;
        ListNode cur = head;
        while (cur != null && cur.next != null) {
            ListNode next = cur.next;
            ListNode fourth = next.next;
            pre.next = next;
            next.next = cur;
            cur.next = fourth;
            pre = cur;
            cur = fourth;
        }
        return dummy.next;
    }
}

 7.   Merge Two Sorted Lists - Not Bug Free

与merge sort思路一样

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = new ListNode(l1.val);
                l1 = l1.next;
            } else {
                cur.next = new ListNode(l2.val);
                l2 = l2.next;
            }
            cur = cur.next;
        }
        while (l1 != null) {
            cur.next = new ListNode(l1.val);
            l1 = l1.next;
            cur = cur.next;
        }
        while (l2 != null) {
            cur.next = new ListNode(l2.val);
            l2 = l2.next;
            cur = cur.next;
        }
        return dummy.next;
    }
}

 8.   Add Two Numbers - Not Bug Free

思路：计算carry然后建立node

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        int carry = 0;
        while (l1 != null || l2 != null || carry != 0) {
            if (l1 != null) {
                carry += l1.val;
                l1 = l1.next;
            }
            if(l2 != null){
                carry += l2.val;
                l2 = l2.next;
            }
            cur.next = new ListNode(carry%10);
            carry = carry/10;
            cur = cur.next;
        }
        return dummy.next;
    }
}

9.   Remove Linked List Elements

思路：建立dummy node, 注意while循环的条件.

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode cur = dummy;
        while (cur.next != null) {
            if (cur.next.val == val) {
                cur.next = cur.next.next;
            }else {
               cur = cur.next; 
            }
        }
        return dummy.next;
    }
}

 10.   Reverse Linked List II  - To be revisited

class Solution {
    public ListNode reverseBetween(ListNode head, int m, int n) {
        if (m == n) {
            return head;
        }
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy;
        int step = m - 1;
        while (step-- != 0) {
            pre = pre.next;
        }
        ListNode first = pre;
        ListNode second = pre.next;
        pre = pre.next;
        ListNode cur = pre.next;
        ListNode next = cur.next;
        step = n - m;
        while (step-- != 0) {
            next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        first.next = pre;
        second.next = cur;
        return dummy.next;
    }
}

 11.   Reorder List - To be revisited

思路： 快慢指针找到List的中部，反转后半部List, 双指针前后靠近.

坑：注意已经指向null. 

ListNode mid = slow; 
mid.next = null; 
ListNode pre = slow; 
ListNode cur = pre.next; 
while (cur != null) { ... }

public class Solution {
    public void reorderList(ListNode head) {
        if (head == null) {
            return;
        }
        ListNode fast = head;
        ListNode slow = head;
        ListNode l1 = head;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
        }
        ListNode mid = slow;
        ListNode pre = slow;
        ListNode cur = pre.next;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        mid.next = null;
        while (pre.next != null) {
            ListNode left = l1.next;
            ListNode right = pre.next;
            l1.next = pre;
            pre.next = left;
            l1 = left;
            pre = right;
        }
    }
}

 

 12.   Rotate List

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (head == null || head.next == null || k == 0) {
            return head;
        }
        int count = 0;
        ListNode dummy = new ListNode(-1);
        dummy.next = head;
        ListNode pre = dummy;
        while (pre.next != null) {
            pre = pre.next;
            count++;
        }
        ListNode end = pre;
        pre = dummy;
        int time = count - k%count;
        while (time-- != 0) {
            pre = pre.next;
        }
        end.next = head;
        dummy.next = pre.next;
        pre.next = null;
        return dummy.next;
    }
}

 13.   Partition List

按照值的大小建立2条linked list，2个dummy node. 最后把他们连起来.

class Solution {
    public ListNode partition(ListNode head, int x) {
        if (head == null) {
            return null;
        }
        
        ListNode cur = head;
        ListNode lHead = new ListNode(-1);
        ListNode rHead = new ListNode(-1);
        ListNode l = lHead;
        ListNode r = rHead;
        int lCount = 0;
        int rCount = 0;
        while (cur != null) {
            if (cur.val < x) {
                l.next = cur;
                l = l.next;
                lCount++;
            }else {
                r.next = cur;
                r = r.next;
                rCount++;
            }
            cur = cur.next;
        }
        
        if (lCount == 0 || rCount == 0) {
            return head;
        }else {
            r.next = null;
            l.next = rHead.next;
            return lHead.next;
        }
        
    }
}

14.   Palindrome Linked List

思路：快慢指针找到中点，反转第二部分，双指针一起遍历.

class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        
        ListNode fast = head;
        ListNode slow = head;
        int count = 0;
        while (fast.next != null && fast.next.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            count++;
        }
        
        count = fast.next == null ? count*2 + 1 : count*2 + 2;
        ListNode pre = slow.next;
        ListNode cur = pre.next;
        while (cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        int times = count/2;
        while (times-- != 0) {
            if (head.val != pre.val) {
                return false;
            }
            head = head.next;
            pre = pre.next;
        }
        return true;
    }
}

 

 

 

Stack & Queue

1. Implement minStack

坑：注意stack为空的情况；stack的syntax；exception的syntax

public class MinStack {
    public Stack<Integer> stack;
    public Stack<Integer> minStack;
    
    public MinStack() {
        this.stack = new Stack<Integer>();
        this.minStack = new Stack<Integer>();
    }
    
    public int pop() {
        if (this.stack.isEmpty()) {
            throw new RuntimeException("Your stack is empty");
        }
        this.stack.pop();
        this.minStack.pop();
    }
    
    public void push(int val) {
        this.stack.push(val);
        if (this.minStack.size() != 0) {
            if ((int)this.minStack.peek() > val) {
                this.minStack.push(val);
            } else {
                this.minStack.push((int)this.minStack.peek());
            }
        } else {
            this.minStack.push(val);
        }
        
    } 
    
    public int getMin() {
        if (this.stack.isEmpty()) {
            throw new RuntimeException("Your stack is empty");
        }
        return (int)this.minStack.peek();
    }

 2. Implement queue using two stacks

思路：一个stackPush，一个StackPop.

public class TwoStackQueue {
    private Stack<Integer> sPush;
    private Stack<Integer> sPop;
    
    public TwoStackQueue() {
        this.sPush = new Stack<Integer>();
        this.sPop = new Stack<Integer>();
    }
    
    public void add(int val) {
        this.sPush.push(val);
    }
    
    public int poll() {
        if (this.sPush.isEmpty() && this.sPop.isEmpty()) {
            throw new RuntimeException("Your queue is empty");
        }
        if (this.sPop.isEmpty()) {
            while (!this.sPush.isEmpty()) {
                this.sPop.push((int)this.sPush.pop());
            }
        }
        return (int)this.sPop.pop();
    }
    
    public int peek() {
        if (this.sPush.isEmpty() && this.sPop.isEmpty()) {
            throw new RuntimeException("Your queue is empty");
        }
        if (this.sPop.isEmpty()) {
            while (!this.sPush.isEmpty()) {
                this.sPop.push((int)this.sPush.pop());
            }
        }
        return (int)this.sPop.peek();
    }
}

3. Using recursive function to reverse a stack

    public static int getButtom(Stack s) {
        int ret = (int)s.pop();
        if (s.isEmpty()) {
            return ret;
        } else {
            int temp = getButtom(s);
            s.push(ret);
            return temp;
        }
    }
    
    public static void reverse(Stack s) {
        if (s.isEmpty()) {
            return;
        } else {
            int buttom = getButtom(s);
            reverse(s);
            s.push(buttom);
        }
    }

 4. Remove Duplicate Letters - 1st Not Bug Free

思路：用stack，frequency, visited, 注意frequency[cur]-- 的位置。注意是一个while 循环。

class Solution {
    public String removeDuplicateLetters(String s) {
        int[] frequency = new int[256];
        for (int i : s.toCharArray()) {
            frequency[i]++;
        }
        boolean[] visited = new boolean[256];
        Stack<Character> stack = new Stack<>();
        for (int i =0; i < s.length(); i++) {
            Character cur = s.charAt(i);
            frequency[cur]--;
            if (visited[cur]) {
                continue;
            }
            while (!stack.isEmpty() && cur < stack.peek() && frequency[stack.peek()] > 0) {
                visited[stack.pop()] = false;
            }
            stack.push(cur);
            visited[cur] = true;
        }
        StringBuilder builder = new StringBuilder();
        while (!stack.isEmpty()) {
            builder.append(stack.pop());
        }
        return builder.reverse().toString();
    }
        
}

 5. Largest Rectangle in Histogram - 1st Not Bug Free

class Solution {
    public int largestRectangleArea(int[] heights) {
        if (heights == null || heights.length == 0) {
            return 0;
        }
        Stack<Integer> s = new Stack<>();
        int max = 0;
        for (int i = 0; i <= heights.length; i++) {
            int cur = i == heights.length ? 0 : heights[i];
            while (!s.isEmpty() && cur < heights[s.peek()]) {
                int h = heights[s.pop()];
                int start = s.isEmpty() ? -1 : s.peek();
                int curArea = h * (i - start - 1);
                max = Math.max(max, curArea);
            }
            s.push(i);
        }
        return max;
    }
}

6. Trapping Rain Water - 1st Not Bug Free

class Solution {
    public int trap(int[] height) {
        int res = 0;
        int j = 0;
        Stack<Integer> s = new Stack<>();
        while (j < height.length) {
            int cur = height[j];
            if (s.isEmpty() || cur <= height[s.peek()]) {
                s.push(j++);
            } else {
                int low = height[s.pop()];
                if (s.isEmpty()) continue;
                int h = Math.min(height[s.peek()]-low, height[j]-low);
                res += h * (j - s.peek() - 1);
            }
        }
        return res;
    }
}

 7. Next Greater Element I - 1st Not Bug Free

思路：建立递增stack，如果peek < nums[i], 弹出。放入map里面。

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> s = new Stack<>();
        for (int i = 0; i < nums2.length; i++) {
            while (!s.isEmpty() && s.peek() < nums2[i]) {
                map.put(s.pop(), nums2[i]);
            } 
            s.push(nums2[i]);
        }
        int[] res = new int[nums1.length];
        for (int i = 0; i < nums1.length; i++) {
            res[i] = map.containsKey(nums1[i]) ? map.get(nums1[i]) : -1;
        }
        return res;
    }
}

8. Next Greater Element II - 1st Not Bug Free

思路：增长array，map里面存放index，建立递增stack，如果peek < nums[i], 弹出。放入map里面。

class Solution {
    public int[] nextGreaterElements(int[] nums) {
        if (nums == null || nums.length == 0) {
            return nums;
        }
        int[] newArray = new int[2*nums.length-1];
        for (int i = 0; i < nums.length; i++) {
            newArray[i] = nums[i];
            
        }

        for (int i = 0; i < nums.length - 1; i++) {
            newArray[nums.length+i] = nums[i];
        }
        
        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> s = new Stack<>();
        for (int i = 0; i < newArray.length; i++) {
            while (!s.isEmpty() && newArray[s.peek()] < newArray[i]) {
                map.put(s.pop(), i);
            } 
            s.push(i);
        }
        int[] res = new int[nums.length];
        for (int i = 0; i < nums.length; i++) {
            res[i] = map.containsKey(i) ? newArray[map.get(i)] : -1;
        }
        return res;
    }
}

9. Score of Parentheses - 1st Not Bug Free

思路：( 就push(-1), ) 就计算在同一层的个数。最后在乘以2. 会把最后一个-1给pop，所以求出stack的和就好了。

class Solution {
    public int scoreOfParentheses(String S) {
        Stack<Integer> stack = new Stack<>();
        char[] arr = S.toCharArray();
        for (char i : arr) {
            if (i == '(') {
                stack.push(-1);
            } else {
                int curLevelSum = 0;
                while (!stack.isEmpty() && stack.peek() != -1) {
                    curLevelSum += stack.pop();
                }
                stack.pop();
                stack.push(curLevelSum == 0 ? 1 : 2 * curLevelSum);
            }
        }
        int sum = 0;
        while (!stack.isEmpty()) {
            sum += stack.pop();
        }
        return sum;
    }
}

10.Daily Temperatures

思路：和Next Greater Element II一样里面存放index。

class Solution {
    public int[] dailyTemperatures(int[] temperatures) {
        if (temperatures == null || temperatures.length == 0) {
            return temperatures;
        }
        Map<Integer, Integer> map = new HashMap<>();
        Stack<Integer> s = new Stack<>();
        for (int i = 0; i < temperatures.length; i++) {
            while (!s.isEmpty() && temperatures[s.peek()] < temperatures[i]) {
                map.put(s.peek(), i - s.pop());
            }
            s.push(i);
        }
        int[] res = new int[temperatures.length];
        for (int i = 0; i < temperatures.length; i++) {
            res[i] = map.containsKey(i) ? map.get(i) : 0;
        }
        return res;
    }
}

 11. All sum 0 Subarrays - 1st Not Bug Free

思路：建立一个index 为sum（记录从0 到i的sum）， value 为i的hashmap， 如果有重复的key出现，说明i， j之间和为零。

声明一个new comparator来比较list。

    static List<List<Integer>> findSubArrays(int[] arr) {
        HashMap<Integer, List<Integer>> map = new HashMap<>();
        List<List<Integer>> results = new ArrayList<>();
        int sum = 0;
        List index = new ArrayList<>();
        index.add(-1);
        map.put(0, index);
        for (int i = 0; i < arr.length; i ++) {
            sum += arr[i];
            if (map.containsKey(sum)) {
                index = map.get(sum);
                for (int j = 0; j < index.size(); j ++) {
                    List result = new ArrayList<>();
                    result.add(index.get(j) + 1);
                    result.add(i);
                    results.add(result);
                }
                index.add(i);
            } else {
                index = new ArrayList<>();
                index.add(i);
                map.put(sum, index);
            }
        }
        Comparator comparator = new MyComparator();
        Collections.sort(results, comparator);
        return results;
    }
    
    static class MyComparator implements Comparator {
           public int compare(List a, List b) {
               for (int i = 0; i < a.size(); i ++) {
                   if (a.get(i) != b.get(i)) {
                        return a.get(i) - b.get(i);
                   }
                   else continue;
               }
               return 0;
           }
    }

12. BST Inorder Traversal - 1st Not Bug Free

思路；建立一个stack，root = cur， 如果cur ！= null 或者 stack不为空，进行判断。一直往左走，走到尽头，弹出一个，再往右走，此时cur = null，继续弹出，这时弹出的是parent，存储parent，再往右走。就可以了。

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        Stack<TreeNode> s = new Stack<>();
        TreeNode cur = root;
        while (!s.isEmpty() || cur != null) {
            while (cur != null) {
                s.push(cur);
                cur = cur.left;
            }
            cur = s.pop();
            res.add(cur.val);
            cur = cur.right;
        }
        return res;
    }
}

13. BST Preorder Traversal - 1st Not Bug Free

思路：visit中间，push 左边，push 右边

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<Integer>();
        if (root == null) return result;
        Stack<TreeNode> stack = new Stack<TreeNode>();
        stack.push(root);
        while (!stack.isEmpty()){
            TreeNode node = stack.pop();
            result.add(node.val);
            if (node.right != null) stack.push(node.right);
            if (node.left != null) stack.push(node.left);
        }
        return result;
    }
}

 14. Bad Hair Day

15. Remove Duplicate Letters - 2nd Not Bug Free

思路：建立stack，freq，visited。

while (!stack.isEmpty() && stack.peek() > cur && freq[stack.peek()] > 0) 
　　visited[stack.pop()] = false;

class Solution {
    public String removeDuplicateLetters(String s) {
        int[] freq = new int[256];
        for (char i : s.toCharArray()) {
            freq[i]++;
        }
        boolean[] visited = new boolean[256];
        Stack<Character> stack = new Stack<>();
        for (int i = 0; i < s.length(); i++) {
            char cur = s.charAt(i);
            freq[cur]--;
            if (visited[cur]) {
                continue;
            }
            while (!stack.isEmpty() && stack.peek() > cur && freq[stack.peek()] > 0) {
                visited[stack.pop()] = false;
            }
            stack.push(cur);
            visited[cur] = true;
        }
        StringBuilder res = new StringBuilder();
        while (!stack.isEmpty()) {
            res.append(stack.pop());
        }
        return res.reverse().toString();
    }
        
}

 

Recursion - DFS

1.　KnapsackI: True or false

　　思路一：最直接的recursion.

public static boolean exist(int[] nums, int target, int index) {
         if (target == 0) {
         return true;
     }
     if (index == nums.length || target < 0) {
         return false;
     }
     return exist(nums, target - nums[index], index++) || exist(nums, target, index++);
}

2.　KnapsackII: element can be reused but no dupulicate solutions

　   技巧：有for-loop就不用“用”或“不用”了

    public static void knapsackII(int[] nums, List<List<Integer>> results, List<Integer> items, int target, int index) {
        if (target == 0) {
            results.add(new ArrayList(items));
            return;
        }
        
        if (target < 0 || index == nums.length) {
            return;
        }
        
        for (int i = index; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i-1]) {
                continue;
            }
            items.add(nums[i]);
            knapsackII(nums, results, items, target - nums[i], i);
            items.remove(items.size() - 1);
            // 不需要！
            //knapsackII(nums, results, items, target, i+1);
        }
    }    

　　knapsackIII: element cannot be reused but can contain dupulicate solutions

public static void knapsackIII(int[] nums, List<List<Integer>> results, List<Integer> items, int target, int index) {
        if (target == 0) {
            results.add(new ArrayList(items));
            return;
        }
        
        if (target < 0 || index == nums.length) {
            return;
        }
        
        for (int i = index; i < nums.length; i++) {
            items.add(nums[i]);
            knapsackIII(nums, results, items, target - nums[i], i + 1);
            items.remove(items.size() - 1);
        }
    }

　　knapsackIV: return the max weight of the bag

　　注意边界条件，利用oldSize和curSize

    public static int knapsackIV(int[] nums, int target, int curSize, int oldSize, int index) {
        if (target == 0) {
            return curSize;
        }
        
        if (target < 0) {
            return oldSize;
        }
        
        if (target > 0 && index == nums.length) {
            return curSize;
        }
       
        return Math.max(knapsackIV(nums, target - nums[index], curSize + nums[index], curSize, index+1), knapsackIV(nums, target, curSize, curSize, index+1));
    }

3.   Maze - 1 

public static boolean exist(char[][] board, int startX, int startY, int targetX, int targetY) {
        if (startX == targetX && startY == targetY) {
        return true;
    }
    if (startX < 0 || startX >= board.length || startY < 0 || startY >= board[0].length || board[startX][startY] == 'X') {
        return false;
    }
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};
    board[startX][startY] = 'X';
    for (int i = 0; i < 4; i++) {
        if (exist(board,startX + dx[i], startY + dy[i], targetX, targetY)) {
            return true;
        }
    }
    board[startX][startY] = '.';
    return false;
}

4.   Maze - 2

Print all paths

public static void printPath(List<List<Character>> results, List<Character> items, char[][] board, int startX, int startY, int targetX, int targetY) {
        if (startX == targetX && startY == targetY) {
        results.add(new ArrayList<>(items));
        return;
    }
    if (startX < 0 || startX >= board.length || startY < 0 || startY >= board[0].length || board[startX][startY] == 'X') {
        return;
    }
    int[] dx = {1, -1, 0, 0};
    int[] dy = {0, 0, 1, -1};
    char[] dir = {'R', 'L', 'D', 'U'};
    board[startX][startY] = 'X';
    for (int i = 0; i < 4; i++) {
        items.add(dir[i]);
        printPath(results, items, board, startX + dx[i], startY + dy[i], targetX, targetY);
        items.remove(items.size() - 1);
    }
    board[startX][startY] = '.';
}

 5.   Subset - No duplication

public void solve2(List<List<Integer>> result, int[] num, List<Integer> item, int index){
        if(index == num.length){
            result.add(new ArrayList<Integer>(item));
            return;
        }
            
        for(int i = index; i < num.length; i++){
            item.add(num[i]);
            solve2(result, num, item, i + 1);
            item.remove(item.size() - 1);
        }

        solve2(result, num, item, num.length);
}

6.    Subset - Duplication

public static void solve3(List<List<Integer>> results, int[] nums, List<Integer> items, int index) {
        if (index == nums.length) {
            results.add(new ArrayList<>(items));
        return;
        }
        for (int i = index; i < nums.length; i++) {
            if (i > index && nums[i] == nums[i-1]) {
            continue;
        }
        items.add(nums[i]);
        solve3(results, nums, items, i + 1);
        items.remove(items.size() - 1);
        }
            solve3(results, nums, items, nums.length);
}

 7.    Permutation - No duplication

class Solution {
    public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        boolean[] visited = new boolean[nums.length];
        solve(results, new ArrayList<Integer>(), nums, visited);
        return results;

    }
    
    public void solve(List<List<Integer>> results, List<Integer> items, int[] nums, boolean[] visited) {
        if (items.size() == nums.length) {
            results.add(new ArrayList<>(items));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (visited[i]) {
                continue;
            }
            visited[i] = true;
            items.add(nums[i]);
            solve(results, items, nums, visited);
            items.remove(items.size() - 1);
            visited[i] = false;
        }
    }
}

 8.    Permutation - Duplication - 3rd Not Bug Free

坑：忘记visited[i-1] == false; 不需要用index

public class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> results = new ArrayList<>();
        Arrays.sort(nums);
        boolean[] visited = new boolean[nums.length];
        solve(results, new ArrayList<Integer>(), nums, visited);
        return results;
    }
    
    public void solve(List<List<Integer>> results, List<Integer> items, int[] nums, boolean[] visited) {
        if (items.size() == nums.length) {
            results.add(new ArrayList<>(items));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (visited[i] || (i > 0 && nums[i] == nums[i-1] && !visited[i-1])) {
                continue;
            }
            visited[i] = true;
            items.add(nums[i]);
            solve(results, items, nums, visited);
            items.remove(items.size() - 1);
            visited[i] = false;
        }
    }
}

9.    Combinational Sum - No Duplication  - To be revisited

坑：要注意for循环里面不能再solve(results, items, nums, target, i+1)了; 不然就重复了.

坑：注意题目要求，每个元素是否可以使用多次。

private void solve(List<List<Integer>> results, List<Integer> items, int [] nums, int target, int index){
    if(index == nums.length) {
        return;
    }
    if(target == 0) {
        results.add(new ArrayList<>(items));
        return;
    }
    for(int i = index; i < nums.length; i++){
        if (target >= nums[i]) {
            items.add(nums[i]);
            solve(results, items, nums, target - nums[i], i); 
            items.remove(items.size() - 1);
        }
        
    }
}

10.    Combinational Sum - Duplication  - 3rd Not Bug Free

有index的时候， 就是if (i > index && nums[i] == nums[i-1]). 要是没有就是if (i > 0 && nums[i] == nums[i-1])

注意for-loop里面是i， 而不是index参与下一次recursive call

坑：注意题目要求，每个元素是否可以使用多次。

    public void solve(List<List<Integer>> results, List<Integer> items, int[] nums, int target,  int index){
        if(target == 0){
            results.add(new ArrayList<>(items));
            return;
        }
        if(index == nums.length){
            return;
        }
        for(int i = index; i < nums.length; i++){
            if(i > index && nums[i] == nums[i-1] ){
                continue;
            }
            if(nums[i] <= target){
                items.add(nums[i]);
                solve(results, items, nums, target - nums[i],  i + 1);
                items.remove(items.size() - 1);
            }
        }
}

 11.    Palindrome

public void solve(List<List<String>> results, List<String> items, String s, int index){
    if(s.length() == index){
        results.add(new ArrayList<>(items));
        return;
    }
        
    for(int i = index; i < s.length(); i++){
        if(isPalin(s.substring(index, i+1))){
            items.add(s.substring(index, i+1));
            solve(results, items, s, i+1);
            items.remove(items.size() - 1);
        }
    }
}

12.    Restore IP address

class Solution {
    public List<String> restoreIpAddresses(String s) {
        List<String> results = new ArrayList<>();
        solve(results, "", s, 0, 4);
        return results;
    }
    
    public void solve(List<String> results, String items, String s, int index, int times){
        if(index == s.length() && times == 0){
            results.add(items);
            return;
        }
        
       if(times < 0){
           return;
       }
        
        for(int i = index; i < s.length(); i++){
            String tmp = s.substring(index, i+1);
            if(isValid(tmp)){
                String newStr = times == 1 ? items + tmp : items + tmp + ".";
                times--;
                solve(results, newStr, s, i+1, times);
                times++;
            }
        }
    }
    
    public boolean isValid(String s){
        double value = Double.parseDouble(s);
        if(s.charAt(0) == '0'){
            return s.length() == 1;
        }
        return value <= 255 && value >= 0;
    }
    
}

 13.    Word search

class Solution {
    public boolean exist(char[][] board, String word) {
        boolean[][] visited = new boolean[board.length][board[0].length];
        List<Character> items =  new ArrayList<Character>();
        for(int row = 0; row < board.length; row++){
            for(int col = 0; col < board[0].length; col++){
                if(board[row][col] == word.charAt(0)){
                if(solve(board, word, items, visited, row, col, 0)){
                    return true;
                    }
                }
            }
        }
        return false;
    }
    
    public boolean solve(char[][] board, String word, List<Character> items, boolean[][] visited, int x, int y, int index){
        if(index == word.length()){
            return true;
        }
        if(x < 0 || x > board.length - 1 || y < 0 || y > board[0].length - 1 || visited[x][y] == true || board[x][y] != word.charAt(index)){
            return false;
        }
        int[] dx = {1, 0, -1, 0};
        int[] dy = {0, 1, 0 , -1};
        visited[x][y] = true;
        for(int j = 0; j< 4; j++){
            if(solve(board, word, items, visited, x + dx[j], y + dy[j], index+1)){
                return true;
            }
        }
        visited[x][y] = false;
        return false;
    }

}

 14.    Gray Code - 1st  Not Bug Free

For example, given n = 2, return [0,1,3,2]. Its gray code sequence is: 

00 - 0
01 - 1
11 - 3
10 - 2
思路：寻找规律
解法一：Recursive

class Solution {
    public List<Integer> grayCode(int n) {
        List<Integer> result = new ArrayList();
        if (n == 0) {
            result.add(0);
            return result;
        }
        List<Integer> middle = new ArrayList();
        middle.add(0);
        middle.add(1);
        solve(n-1, middle, result, n);
        return result;
    }
    
    public void solve(int n, List<Integer> middle, List<Integer> result, int total) {
        if (n == 0) {
            for (Integer i : middle) {
                result.add(i);
            }
            return;
        }
        List<Integer> newMiddle = new ArrayList();
        for (Integer i : middle) {
            newMiddle.add(i);
        }
        for (int i = middle.size() - 1; i >=0; i--) {
            newMiddle.add(middle.get(i) + (1<<(total - n)));
        }
        solve(n-1, newMiddle, result, total);
    }
}

解法二：for-loop

class Solution {
    public List<Integer> grayCode(int n) {
        List<Integer> result = new ArrayList();
        result.add(0);
        for (int i = 1; i <= n; i++) {
            int size = result.size();
            for (int j = size - 1; j >= 0; j--) {
                result.add(result.get(j) + (1 << (i - 1)));
            }
        }
        return result;
    }
}

 15. Binary Tree Maximum Path Sum --- 2nd Not Bug Free

思路：由于TreeNode的数据结构，只能从root入手；计算左边（root.left）和右边（root.right）的值；每个node都可以选择 root, root + left, 和root + right, 和root + left + right, 这样用来保证parent-child关系但是返回上一级的时候是返回的branchMax, 也就是说root + left, 或root + right, 或root + 0。这样一来，不是每一个node都能返回 root + left + right.

class Solution {
    int max_sum = Integer.MIN_VALUE;
    public int maxPathSum(TreeNode root) {
        if (root == null) {
            return 0;
        }
        branchMax(root);
        return max_sum;
    }
    
    public int branchMax(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftSum = branchMax(root.left);
        int rightSum = branchMax(root.right);
        int bMax = root.val + Math.max(0, Math.max(leftSum, rightSum));
        max_sum = Math.max(max_sum, Math.max(bMax, root.val + leftSum + rightSum));
        return bMax;
    }
}

 16. Path Sum II --- 2nd Not Bug Free

坑：如果满足条件直接return，items将不会进行backtracking，注意item.add()的位置； 注意题目条件，必须是leaf节点.

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        solve(result, new ArrayList<Integer>(), root, sum);
        return result;
    }
    
    public void solve(List<List<Integer>> result, List<Integer> items, TreeNode root, int sum) {
        if (root == null) return;
        
        items.add(root.val);
        if (root.left == null && root.right == null && sum == root.val) {
            result.add(new ArrayList<>(items));
        }
        
        solve(result, items, root.left, sum - root.val);
        solve(result, items, root.right, sum - root.val);
        items.remove(items.size() - 1);
    }
}

解法二：坑：元素可能是负数

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> res = new ArrayList<>();
        solve(root, sum, res, new ArrayList<Integer>());
        return res;
    }
    
    public void solve(TreeNode root, int sum, List<List<Integer>> res, List<Integer> items) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null && sum == root.val) {
            items.add(root.val);
            res.add(new ArrayList<>(items));
            items.remove(items.size() - 1);
            return;
        }
        items.add(root.val);
        solve(root.left, sum - root.val, res, items);
        solve(root.right, sum - root.val, res, items);
        items.remove(items.size() - 1);
    }
}

 

 17. Lucky Numbers ---- 1st Not Bug Free

两个index: idx 和 i+1; * 和 / 要注意，定义一个post，代表表达式里面的最后一个数。

// "static void main" must be defined in a public class.
public class Main {
    public static void main(String[] args) {
        int target = 888;
        String num = "7765332111";
        System.out.println(String.valueOf(lucky(num, target)));
    }
    
    public static List<String> lucky(String num, int target) {
        List<String> res = new ArrayList<>();
        solve(num, target, res, "", 0, 0, 0);
        return res;
    }
    
    public static void solve(String num, int target, List<String> res, String cur, int idx, long curVal, long post) {
        if (idx == num.length()) {
            if ((int)curVal == target) {
                res.add(cur);
            }
            return;
        }
        for (int i = idx; i < num.length(); i++) {
            if (num.charAt(idx) == '0' && i != idx) {
                break;
            }
            String sub = num.substring(idx, i+1);
            long val = Long.valueOf(sub);
            if (idx == 0) {
                solve(num, target, res, cur + sub, i+1, val, val);
            } else {
                solve(num, target, res, cur + "+" + sub, i+1, curVal+val, val);
                solve(num, target, res, cur + "-" + sub, i+1, curVal+val, val);
                solve(num, target, res, cur + "*" + sub, i+1, curVal-post + post*val,  post*val);
                if (val != 0 &&  post%val == 0) {
                    solve(num, target, res, cur + "/" + sub, i+1, curVal-post + post/val, post/val);
                }
            }
        }
    }
}

 18. Remove Invalid Parentheses ---- 1st Not Bug Free

思路：定义rmL, rmR, open, 左括号和右括号可以要或者不要。StringBuilder 的backtrace。

class Solution {
    public List<String> removeInvalidParentheses(String s) {
        int rmL = 0, rmR = 0, open = 0;
        for (int i = 0; i < s.length(); i++) {
            char cur = s.charAt(i);
            if (cur == '(') {
                rmL++;
            } else if (cur == ')') {
                if (rmL != 0) {
                    rmL--;
                } else {
                    rmR++;
                }
                
            }
        }
        Set<String> set = new HashSet<>();
        solve(s, set, rmL, rmR, open, new StringBuilder(), 0);
        return new ArrayList<String>(set);
    }
    
    public void solve(String s, Set<String> set, int rmL, int rmR, int open, StringBuilder sb, int idx) {
        if (rmL < 0 || rmR < 0 || open < 0) {
            return;
        }
        if (idx == s.length()) {
            if (rmL == 0 && rmR == 0 && open == 0) {
                set.add(sb.toString());
            }
            return;
        }
        
        char cur = s.charAt(idx);
        
        if (cur == '(') {
            solve(s, set, rmL, rmR, open+1, sb.append(cur), idx+1);
            sb.setLength(sb.length() - 1);
            solve(s, set, rmL-1, rmR, open, sb, idx+1);
        } else if (cur == ')') {
            solve(s, set, rmL, rmR, open-1, sb.append(cur), idx+1);
            sb.setLength(sb.length() - 1);
            solve(s, set, rmL, rmR-1, open, sb, idx+1);
        } else {
            solve(s, set, rmL, rmR, open, sb.append(cur), idx+1);
            sb.setLength(sb.length() - 1);
        }
        
    }
}

 19. Validate Binary Search Tree ---- 1st Not Bug Free

思路一：转化为inOrder,看是否由小到大的顺序排列。

class Solution {
    List<Integer> res = new ArrayList<>();
    
    public boolean isValidBST(TreeNode root) {
        inOrder(root);
        for (int i = 1; i < res.size(); i++) {
            if (res.get(i) <= res.get(i-1)) {
                return false;
            }
        }
        return true;
    }
    
    public void inOrder(TreeNode root) {
        if (root == null) {
            return;
        }
        inOrder(root.left);
        res.add(root.val);
        inOrder(root.right);
    }
}

思路二：helper(node, max, min)

class Solution {
    public boolean isValidBST(TreeNode root) {
        return helper(root, Long.MAX_VALUE, Long.MIN_VALUE);
    }
    
    public boolean helper(TreeNode root, long max, long min) {
        if (root == null) return true;
        return root.val < max && root.val > min && helper(root.right, max, root.val) && helper(root.left, root.val, min);
    }
}

 20. Flatten Binary Tree to Linked List ---- 1st Not Bug Free

思路一：postOrder in terms of (right, left, root)

class Solution {
    TreeNode prev = null;
    public void flatten(TreeNode root) {
        if (root == null) {
            return;
        }
        flatten(root.right);
        flatten(root.left);
        root.right = prev;
        root.left = null;
        prev = root;
    }
}

思路二：non-recursive

class Solution {
    TreeNode prev = null;
    public void flatten(TreeNode root) {
        if (root == null) {
            return;
        }
        TreeNode cur = root;
        while (cur != null) {
            if (cur.left != null) {
                TreeNode last = cur.left;
                while (last.right != null) {
                    last = last.right;
                }
                last.right = cur.right;
                cur.right = cur.left;
                cur.left = null;
            }
            cur = cur.right;
        }
    }
}

 

BFS

1. The Maze II. --- 1st Not Bug Free

坑：

            if (dis < distance[x][y]) {
                    distance[x][y] = dis;
                    if (x != dest[0] || y != dest[1]) {
                        queue.offer(new Pair(x, y));
                    }
                }    

public class Solution {
    /**
     * @param maze: the maze
     * @param start: the start
     * @param destination: the destination
     * @return: the shortest distance for the ball to stop at the destination
     */
    public int shortestDistance(int[][] maze, int[] start, int[] dest) {
        // write your code here
        int row = maze.length;
        int col = maze[0].length;
        int[][] distance = new int[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                distance[i][j] = Integer.MAX_VALUE;
            }
        }
        int[] dx = {-1,1,0,0};
        int[] dy = {0,0,-1,1};
        Queue<Pair> queue = new LinkedList<Pair>();
        queue.offer(new Pair(start[0], start[1]));
        distance[start[0]][start[1]] = 0;
        while (!queue.isEmpty()) {
            Pair pair = queue.poll();
            
            for (int i = 0; i < 4; i++) {
                int x = pair.x;
                int y = pair.y;
                int dis = distance[x][y];
                while (x >= 0 && x < row && y >= 0 && y < col && maze[x][y] == 0) {
                    x += dx[i];
                    y += dy[i];
                    dis++;
                }
                x -= dx[i];
                y -= dy[i];
                dis--;
                if (dis < distance[x][y]) {
                    distance[x][y] = dis;
                    if (x != dest[0] || y != dest[1]) {
                        queue.offer(new Pair(x, y));
                    }
                }
                
            }
        }
        int res = distance[dest[0]][dest[1]];
        return res == Integer.MAX_VALUE ? -1 : res;
    }
}

class Pair {
    int x;
    int y;
    public Pair(int a, int b) {
        x = a;
        y = b;
    }
}

2. Maze III --- 1st Not Bug Free

坑： String[] dir = {"d", "l", "r", "u"}; 是根据行列号变化而变得

                if (dis < distance[x][y] || (dis == distance[x][y] && s1.compareTo(path[x][y]) < 0)) {
                    distance[x][y] = dis;
                    path[x][y] = s1;
                    if (x != dest[0] || y != dest[1]) {
                         queue.offer(new Pair(x, y));
                    }
                }

public class Solution {
    /**
     * @param maze: the maze
     * @param ball: the ball position
     * @param hole: the hole position
     * @return: the lexicographically smallest way
     */
    public String findShortestWay(int[][] maze, int[] start, int[] dest) {
        // write your code here
        int row = maze.length;
        int col = maze[0].length;
        int[][] distance = new int[row][col];
        String[][] path = new String[row][col];
        for (int i = 0; i < row; i++) {
            for (int j = 0; j < col; j++) {
                distance[i][j] = Integer.MAX_VALUE;
                path[i][j] = "";
            }
        }
        int[] dx = {1, 0, 0, -1};
        int[] dy = {0, -1, 1, 0};
        String[] dir = {"d", "l", "r", "u"};
        Queue<Pair> queue = new LinkedList<Pair>();
        queue.offer(new Pair(start[0], start[1]));
        distance[start[0]][start[1]] = 0;
        path[start[0]][start[1]] = "";
        while (!queue.isEmpty()) {
            Pair pair = queue.poll();
            for (int i = 0; i < 4; i++) {
                int x = pair.x;
                int y = pair.y;
                int dis = distance[x][y];
                String currentPath = path[x][y];
                while (x >= 0 && x < row && y >= 0 && y < col && maze[x][y] == 0 && (x != dest[0] || y != dest[1])) {
                    x += dx[i];
                    y += dy[i];
                    dis++;
                }
                if (x != dest[0] || y != dest[1]) {
                    x -= dx[i];
                    y -= dy[i];
                    dis--;
                }
                String s1 = currentPath.concat(dir[i]);
                if (dis < distance[x][y] || (dis == distance[x][y] && s1.compareTo(path[x][y]) < 0)) {
                    distance[x][y] = dis;
                    path[x][y] = s1;
                    if (x != dest[0] || y != dest[1]) {
                         queue.offer(new Pair(x, y));
                    }
                }
            }
        }
        
    String result = path[dest[0]][dest[1]];
    return distance[dest[0]][dest[1]] == Integer.MAX_VALUE ? "impossible" : result;
    }
}

class Pair {
    int x;
    int y;
    public Pair(int a, int b) {
        x = a;
        y = b;
    }
}

 3. Word Ladder I --- 1st Not Bug Free

思路：两个Queue，每一层存储distance为1的list。为了防止有重复建立Set

坑： 用26个字母进行for-loop，running time会大大缩短. 用set保存wordlist会让contains操作变为O(1).

class Solution {
    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
        int distance = 1;
        Set<String> wordSet = new HashSet<String>();
        Set<String> visited = new HashSet<String>();
        for (String s : wordList) {
            wordSet.add(s);
        }
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        while (!queue.isEmpty()) {
            Set<String> queue1 = new HashSet<>();
            distance++;
            while (!queue.isEmpty()) {
                String top = queue.poll();
                Set<String> oneWordList = getWordWithinDistance(top, wordList, wordSet, visited);
                if (oneWordList.contains(endWord)) {
                    return distance;
                }
                queue1.addAll(oneWordList);
            }
            queue.addAll(queue1);
        }
        return 0;
    }
    
    public Set<String> getWordWithinDistance(String beginWord, List<String> wordList, Set<String> wordSet, Set<String> visited) {
        Set<String> oneWordList = new HashSet<>();
        char[] char1 = beginWord.toCharArray();
        for (int i = 0; i < char1.length; i++) {
            char cur = char1[i];
            for (char a = 'a'; a < 'z'; a++) {
                if (a == cur) {
                    continue;
                }
                char1[i] = a;
                String newString = new String(char1);
                if (visited.contains(newString)) {
                    continue;
                }
                if (wordSet.contains(newString)) {
                    oneWordList.add(newString);
                    visited.add(newString);
                }
            }
            char1[i] = cur;
        }
        return oneWordList;
    }
    
}

4. Word Ladder II --- 1st Not Bug Free

思路：BFS + DFS， BFS用来建立shortest path， DFS 用来输出。每走一层，建立一个HashMap<String, List<String>>, 之后用于返回路径。

坑：为了防止有重复建立Set.

class Solution {
    public List<List<String>> findLadders(String beginWord, String endWord, List<String> wordList) {
        List<List<String>> result = new ArrayList<>();
        HashMap<String, List<String>> preList = new HashMap();
        Set<String> visited = new HashSet();
        visited.add(beginWord);
        Set<String> wordSet = new HashSet<String>();
        for (String s : wordList) {
            wordSet.add(s);
        }
        Queue<String> queue = new LinkedList<>();
        queue.offer(beginWord);
        
        while (!queue.isEmpty() ) {
            Set<String> queue1 = new HashSet<>();
            boolean isFinished = false;
            while (!queue.isEmpty()) {
                String top = queue.poll();
                Set<String> oneWordList = getWordWithinDistance(top, wordSet);
                for (String word : oneWordList) {
                    if (word.equals(endWord)) {
                        isFinished = true;
                    }
                    if (!visited.contains(word)) {
                        updatePreList(preList, word, top);
                        queue1.add(word);
                    }
                }
            }
            visited.addAll(queue1);
            if (isFinished) {
                getPath(result, preList, new ArrayList<>(), endWord);
                break;
            }
            queue.addAll(queue1);
        }
        return result;
    }
    
    public void updatePreList(HashMap<String, List<String>> preList, String cur, String pre) {
        if (!preList.containsKey(cur)) {
            preList.put(cur, new ArrayList<String>());
        }
        preList.get(cur).add(pre);
    }
    
    public void getPath(List<List<String>> result, HashMap<String, List<String>> preList, List<String> cur, String endWord) {
        if (!preList.containsKey(endWord)) {
            cur.add(endWord);
            Collections.reverse(cur);
            result.add(cur);
            return;
        }
        cur.add(endWord);
        for (String pre : preList.get(endWord)) {
            List<String> newCur = new ArrayList<>(cur);
            //newCur.add(endWord);
            getPath(result, preList, newCur, pre);
        }
        
    }
    
    public Set<String> getWordWithinDistance(String beginWord, Set<String> wordSet) {
        Set<String> oneWordList = new HashSet<>();
        char[] char1 = beginWord.toCharArray();
        for (int i = 0; i < char1.length; i++) {
            char cur = char1[i];
            for (char a = 'a'; a <= 'z'; a++) {
                if (a == cur) {
                    continue;
                }
                char1[i] = a;
                String newString = new String(char1);

                if (wordSet.contains(newString)) {
                    oneWordList.add(newString);
                }
            }
            char1[i] = cur;
        }
        return oneWordList;
    }
}

 5. Binary Tree Right Side View

思路：双queue，每一层先读right node, 再读left node, 每一层先peek第一个，加入list

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Queue<TreeNode> queue1 = new LinkedList<>();
            TreeNode ele = queue.peek();
            result.add(ele.val);
            while (!queue.isEmpty()) {
                TreeNode top = queue.poll();
                if (top.right != null) {
                    queue1.offer(top.right);
                }
                if (top.left != null) {
                    queue1.offer(top.left);
                }
            }
            queue = queue1;
        }
        return result;
    }
}

6. Find Largest Value in Each Tree Row --- 1st Not Bug Free

坑：每一层sort一下比较慢，设置max = Integer.MIN_VALUE, 然后每次加入node时比较大小，更新max。

最后一层的时候要设置判断条件，不然max直接等于Integer.MIN_VALUE. 合适的判断方法是boolean hasMore = false，如果有子节点hasMore = true；否则就可以退出了.

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> largestValues(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        if (root == null) {
            return result;
        }
        result.add(root.val);
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            Queue<TreeNode> queue1 = new LinkedList<>();
            int max = Integer.MIN_VALUE;
            boolean hasMore = false;
            while (!queue.isEmpty()) {
                TreeNode top = queue.poll();
                if (top.left != null) {
                    queue1.offer(top.left);
                    max = Math.max(top.left.val, max);
                    hasMore = true;
                }
                if (top.right != null) {
                    queue1.offer(top.right);
                    max = Math.max(top.right.val, max);
                    hasMore = true;
                }
            }
            if (hasMore) {
                result.add(max);
                queue = queue1;
            } 
        }
        return result;
    }
}

7. Employee Importance

思路：双queue，先建立HashMap<id, employee>, 便于之后寻找.

/*
// Employee info
class Employee {
    // It's the unique id of each node;
    // unique id of this employee
    public int id;
    // the importance value of this employee
    public int importance;
    // the id of direct subordinates
    public List<Integer> subordinates;
};
*/
class Solution {
    public int getImportance(List<Employee> employees, int id) {
        Queue<Employee> queue = new LinkedList<>();
        HashMap<Integer, Employee> map = new HashMap<>();
        for (Employee p : employees) {
            if (p.id == id) {
                queue.offer(p);
            }
            map.put(p.id, p);
        }
        int importance = 0;
        while (!queue.isEmpty()) {
            Queue<Employee> queue1 = new LinkedList<>();
            while (!queue.isEmpty()) {
                Employee top = queue.poll();
                importance += top.importance;
                if (top.subordinates.size() != 0) {
                    for (int subId : top.subordinates) {
                        queue1.offer(map.get(subId));
                    }
                }
            }
            queue = queue1;
        }
        return importance;
    }
}

 8. Minesweeper

思路：双queue，BFS， 建立visited[x][y].

坑：要判断是否出界，x < 0 || x >= board.length || y < 0 || y >= board[0].length || visited[x][y]

class Solution {
    public char[][] updateBoard(char[][] board, int[] click) {
        boolean[][] visited = new boolean[board.length][board[0].length];
        Queue<Click> queue = new LinkedList<>();
        queue.offer(new Click(click[0], click[1]));
        int[] dx = {-1,-1,-1,0,0,1,1,1};
        int[] dy = {-1,0,1,-1,1,-1,0,1};
        while (!queue.isEmpty()) {
            Queue<Click> queue1 = new LinkedList<>();
            while (!queue.isEmpty()) {
                Click top = queue.poll();
                int x = top.x;
                int y = top.y;
                if (x < 0 || x >= board.length || y < 0 || y >= board[0].length || visited[x][y]) {
                    continue;
                }
                visited[x][y] = true;
                if (board[x][y] == 'M') {
                    board[x][y] = 'X';
                    return board;
                }
                if (board[x][y] == 'E') {
                    int minesAdj = 0;
                    for (int i = 0; i < 8; i++) {
                        if (x+dx[i] >= 0 && x+dx[i] < board.length && y+dy[i] >= 0 && y+dy[i] < board[0].length && (board[x+dx[i]][y+dy[i]] == 'M')) {
                            minesAdj++;
                        }
                    }
                    if (minesAdj == 0) {
                        board[x][y] = 'B';
                        for (int i = 0; i < 8; i++) {
                            queue1.add(new Click(x+dx[i], y+dy[i]));
                        }
                    } else {
                        board[x][y] = Integer.toString(minesAdj).charAt(0);
                    }
                }
            }
            queue = queue1;
        }
        return board;
    }
}

class Click {
    int x;
    int y;
    public Click (int x, int y) {
        this.x = x;
        this.y = y;
    }
}

9. Open the Lock --- 1st Not Bug Free

思路：双queue，BFS， 建立visited. 每一位都可以向左或是向右。

坑：0 向左是9！

class Solution {
    public int openLock(String[] deadends, String target) {
        if (target.equals("0000")) {
            return 0;
        }
        int total = 0;
        Set<String> dead = new HashSet<>();
        for (String s : deadends) {
            dead.add(s);
        }
        Set<String> visited = new HashSet<>();
        Queue<String> queue = new LinkedList<>();
        queue.offer("0000");
        while (!queue.isEmpty()) {
            Queue<String> queue1 = new LinkedList<>();
            total++;
            while (!queue.isEmpty()) {
                String top = queue.poll();
                if (visited.contains(top)) {
                    continue;
                }
                if (dead.contains(top)) {
                    continue;
                }
                if (top.equals(target)) {
                    return total - 1;
                }
                visited.add(top);
                for (int i = 0; i < 4; i++) {
                    char[] lockChar = top.toCharArray();
                    int lockVal = Character.getNumericValue(top.charAt(i));
                    
                    
                    int lockValLeft = 0;
                    if (lockVal == 0) {
                        lockValLeft = 9;
                    } else {
                        lockValLeft = (lockVal - 1) % 10;
                    }
                    lockChar[i] = Integer.toString(lockValLeft).charAt(0);
                    String lockStrLeft = new String(lockChar);
                    queue1.offer(lockStrLeft);
                    
                    int lockValRight = (lockVal + 1) % 10;
                    lockChar[i] = Integer.toString(lockValRight).charAt(0);
                    String lockStrRight = new String(lockChar);
                    queue1.offer(lockStrRight);
                }
            }
            queue = queue1;
        }
        return -1;
    }
}

 10. Pacific Atlantic Water Flow --- 2nd Not Bug Free

坑：DFS时visited[x][y] 不可以是return，而应该是continue; 

思路：从4条边往里面流，流动的条件要改为正好相反；

class Solution {
    
    public List<int[]> pacificAtlantic(int[][] matrix) {
        List<int[]> result = new ArrayList<int[]>();
        if(matrix == null || matrix.length == 0 || matrix[0].length == 0) {
            return result;
        }
        boolean[][] pacific = new boolean[matrix.length][matrix[0].length];
        boolean[][] atlantic = new boolean[matrix.length][matrix[0].length];          
        
        for (int i = 0; i < matrix.length; i++) {
            solve(matrix, i, 0, pacific);
            solve(matrix, i, matrix[0].length-1, atlantic);
        }

        for (int j = 0; j < matrix[0].length; j++) {
            solve(matrix, 0, j, pacific);
            solve(matrix, matrix.length-1, j, atlantic);
        }
        
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (pacific[i][j] && atlantic[i][j]) {
                    result.add(new int[]{i, j});
                }
            }
        }
        return result;
    }
    
    public void solve(int[][] matrix, int i, int j, boolean[][] visited) {
        int[] dx = {-1,1,0,0};
        int[] dy = {0,0,-1,1};
        int m = matrix.length, n = matrix[0].length;
        visited[i][j] = true;
        for (int k = 0; k < 4; k++) {            
            int x = i + dx[k];
            int y = j + dy[k];
            if(x < 0 || y < 0 || x >= m || y >= n || visited[x][y] || matrix[i][j] > matrix[x][y]){
              continue;
            }
            solve(matrix, x, y, visited);
        }
        
    }
}

 11. Binary Tree Zigzag Level Order Traversal

思路：odd的时候先right, 再left。even的时候反过来。用stack instead of queue。最后一个list为空，不要加进去。

class Solution {
    public List<List<Integer>> zigzagLevelOrder(TreeNode root) {
        Stack<TreeNode> stack1 = new Stack<>();
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) return res;
        else stack1.push(root);
        List<Integer> initList = new ArrayList<>();
        initList.add(root.val);
        res.add(initList);
        boolean isOdd = true;
        while (!stack1.isEmpty()) {
            List<Integer> tmp = new ArrayList<>();
            Stack<TreeNode> stack2 = new Stack<>();
            while (!stack1.isEmpty()) {
                TreeNode top = stack1.pop();
                if (isOdd) {
                    if (top.right != null) {
                        stack2.push(top.right);
                        tmp.add(top.right.val);
                    }
                    if (top.left != null) {
                        stack2.push(top.left);
                        tmp.add(top.left.val);
                    }
                } else {
                    if (top.left != null) {
                        stack2.push(top.left);
                        tmp.add(top.left.val);
                    }
                    if (top.right != null) {
                        stack2.push(top.right);
                        tmp.add(top.right.val);
                    }
                }
            }
            stack1 = stack2;
            isOdd = !isOdd;
            if (tmp.size() > 0) res.add(tmp);
        }
        return res;
    }
}

 

 

Dynamic Programming

 1.  Coin Change --- 2nd Not Bug Free

坑：从最小的coin出发，先填充第一行，可以整除的就赋值，不能的赋值为-1.

分为选的不选。选k的时候从0出发能覆盖不选的情况，利于处理。

class Solution {
    public int coinChange(int[] coins, int amount) {
        Arrays.sort(coins);
        int num = coins.length;
        int[][] result = new int[num][amount+1];
        for (int i = 0; i < amount+1; i++) {
            if (i % coins[0] == 0) { 
                result[0][i] = i / coins[0];
            } else {
                result[0][i] = -1;
            }
            
        }
        
        for (int i = 1; i < num; i++) {
            for (int amt = 0; amt < amount+1; amt++) {
                int index = i;
                if (coins[index] > amt) {
                    result[i][amt] = result[i-1][amt];
                } else {
                    int tmp2 = Integer.MAX_VALUE;
                    for (int k = 0; k <= amt/coins[index]; k++) {
                        if (result[i-1][amt - coins[index] * k] != -1) {
                            tmp2 = Math.min(tmp2, k + result[i-1][amt - coins[index] * k]);
                        }
                    }
                    if (tmp2 != Integer.MAX_VALUE) {
                        result[i][amt] = tmp2;
                    } else {
                        result[i][amt] = -1;
                    }
                    
                }
            }
            
        }
        return result[num-1][amount];
    }
    
}

 2. Longest Increasing Subsequence --- 2nd Not Bug Free

思路：dp[i]代表nums[i]是sub string的最大值时候的长度，num[i]的值大于sub string里的其他值。dp[i]初始值全为1.

if nums[i] > nums[j]: dp[i] = max(dp[i], dp[j]+1),

2nd time max = 1;

class Solution {
    public int lengthOfLIS(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int len = nums.length;
        int[] result = new int[len];
        int max = 1;
        Arrays.fill(result,1);

        for (int i = 1; i < len; i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    result[i]= Math.max(result[i], result[j]+1);
                } 
            }
            max = Math.max(max, result[i]);
        }
        return max;
    }
}

3. Longest Common Sequence --- 1st Not Bug Free

思路：if a[i] = a[j]; dp[i][j]  = dp[i-1][j-1] +1 else: dp[i][j]  = max(dp[i][j-1], dp[i-1][j] );

每一个元素都有取于不取两种选择，所以row + 1, col + 1.

    public int longestCommonSubsequence(String A, String B) {
        // write your code here
        if (A == null || B == null || A.length() == 0 || B.length() == 0) {
            return 0;
        }
        
        int m = A.length();
        int n = B.length();
        int[][] maxCommon = new int[m+1][n+1];
        for(int i = 0; i <= m; i ++) {
            maxCommon[i][0] = 0;
        }
        for(int j = 0; j <= n; j ++) {
            maxCommon[0][j] = 0;
        }
        for(int i = 1; i <= m; i ++) {
            for(int j = 1; j <= n; j ++) {
                if(A.charAt(i-1) == B.charAt(j-1)) {
                    maxCommon[i][j] = maxCommon[i-1][j-1] + 1;
                }
                else {
                    maxCommon[i][j] = Math.max(maxCommon[i][j-1], maxCommon[i-1][j]);
                }
            }
        }
        return maxCommon[m][n];
    }

4. Scramble String --- 1st Not Bug Free

思路一：recursive

class Solution {
    public boolean isScramble(String s1, String s2) {
        if (s1 == null || s2 == null || s1.length() != s2.length()) {
            return false;
        }
        if (s1.equals(s2)) {
            return true;
        }
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        if (!Arrays.equals(c1, c2)) return false;
        int len = s1.length();
        for (int i = 1; i < len; i++) {
            if (isScramble(s1.substring(0,i), s2.substring(0,i)) && isScramble(s1.substring(i,len), s2.substring(i,len)))
                return true;
           if (isScramble(s1.substring(0,i), s2.substring(s2.length() - i)) && isScramble(s1.substring(i), s2.substring(0, s2.length() - i)))
               return true;
            
        }
        return false;
    }
}

思路二： DP

class Solution {
    public boolean isScramble(String s1, String s2) {
        if (s1 == null || s2 == null || s1.length() != s2.length()) {
            return false;
        }
        if (s1.equals(s2)) {
            return true;
        }
        char[] c1 = s1.toCharArray();
        char[] c2 = s2.toCharArray();
        Arrays.sort(c1);
        Arrays.sort(c2);
        int len = s1.length();
        boolean[][][] dp = new boolean[len][len][len+1];
        
        for (int i = 0; i < len; i++) {
            for (int j = 0; j < len; j++) {
                dp[i][j][1] = s1.charAt(i) == s2.charAt(j);
            }
        }
        
        for (int l = 2; l <= len; l++) {
            for (int i = 0; i <= len - l; i++) {
                for (int j = 0; j <= len - l; j++) {
                    for (int k = 1; k <= l; k++) {
                        dp[i][j][l] = dp[i][j][l] || (dp[i][j][k] && dp[i+k][j+k][l-k] || dp[i][j+l-k][k] && dp[i+k][j][l-k]);    
                    }
                }
            }
        }
        return dp[0][0][len];
    }
}

 5. Maximum Subarray--- 1st Not Bug Free

思路：dp[i-1]是否大于零，如果小于零，dp[i] = nums[i], 否则，dp[i] = dp[i-1] + nums[i].

其他题目也可以用max来记录最大/小值

class Solution {
    public int maxSubArray(int[] nums) {
        if (nums == null || nums.length == 0) {
            return Integer.MIN_VALUE;
        }
        
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int max = nums[0];
        
        for (int i = 1; i < nums.length; i++) {
            dp[i] = dp[i-1] > 0 ? dp[i-1] + nums[i] : nums[i];
            max = Math.max(dp[i], max);
        }
        return max;
    }
}

 6. Dungeon Game--- 2nd Not Bug Free

思路：从下往上走，如果某个值 <= 0, dp[i][j] = 1; 最后循环的条件要注意！！！

class Solution {
    public int calculateMinimumHP(int[][] dungeon) {
        int row = dungeon.length;
        int col = dungeon[0].length;
        
        int[][] dp = new int[row][col];
        dp[row-1][col-1] = 1 - dungeon[row-1][col-1];
        if (dp[row-1][col-1] <= 0) {
            dp[row-1][col-1] = 1;
        }
        for (int j = col - 1; j > 0; j--) { 
            dp[row-1][j-1] = dp[row-1][j] - dungeon[row-1][j-1];
            if (dp[row-1][j-1] <= 0) {
                dp[row-1][j-1] = 1;
            }
        }
        
        for (int i = row - 1; i > 0; i--) {
            dp[i-1][col-1] = dp[i][col-1] - dungeon[i-1][col-1];
            if (dp[i-1][col-1] <= 0) {
                dp[i-1][col-1] = 1;
            }
        }
        
        for (int i = row - 2; i >= 0; i--) {
            for (int j = col - 2; j >= 0; j--) {
                int pre = Math.min(dp[i + 1][j], dp[i][j + 1]);
                dp[i][j] = pre - dungeon[i][j] <= 0 ? 1 : pre - dungeon[i][j];
            }
        }
        return dp[0][0];
    }
}

 7. Ones and Zeroes--- 1st Not Bug Free

思路：拥有的资源和要解决的问题都从0开始. 逐步加大，直到最后，就得出答案了。

问：大问题的小问题是什么？ 拥有不同的m和n，能凑出多少str。前3个str能凑多少个？前五个str能凑多少个？前十个？前n个？当strs的指针指到1时能凑多少？指到2时能凑多少？n时能凑多少？

答：自然得出dp[strs.length][m+1][n+1]

问：大问题和小问题之间的关系是什么？当dp[i][j][k]无法凑出来，自然就要看dp[i-1][j][k];

答：当dp[i][j][k]能凑出来，那就要看要i和不要i的最大值，要i的话就是dp[i-1][j - lenMN[0]][k - lenMN[1]] + 1,不要i的话就是dp[i-1][j][k].

class Solution {
    public int findMaxForm(String[] strs, int m, int n) {
        int[][][] dp = new int[strs.length+1][m+1][n+1];
        
        for (int i = 1; i <= strs.length; i++) {
            for (int j = 0; j<= m; j++) {
                for (int k = 0; k <= n; k++) {
                    int[] lenMN = get(strs[i-1]);
                    if (j == 0 && k == 0) {
                        dp[i][j][k] = 0;
                    } else if (lenMN[0] > j || lenMN[1] > k) {
                        dp[i][j][k] = dp[i-1][j][k];
                    } else {
                        dp[i][j][k] = Math.max(dp[i-1][j-lenMN[0]][k-lenMN[1]] + 1, dp[i-1][j][k]);
                    }
                }
            }
        }
        
        return dp[strs.length][m][n];
    }
    
    public int[] get(String str) {
        int[] res = new int[2];
        char[] c = str.toCharArray();
        for (char i : c) {
            res[i == '0' ? 0 : 1]++;
        }
        return res;
    }
    

}

8. Interleaving String - 2nd Not Bug Free

思路：和其他dp不同之处是：看似有3个str，i, j, k, 但其实i+j = k, 所以2d的dp就可以搞定。

含义还是一样，前i个str1和前j个str2能否凑钱i+j个str3. 这样关系就出来了。

坑：dp[i][0] = dp[i-1][0] && s3.charAt(idx) == s1.charAt(idx);

dp[i][j] = (dp[i-1][j] && s3.charAt(i+j-1) == s1.charAt(idx1)) || (dp[i][j-1] && s3.charAt(i+j-1) == s2.charAt(idx2));

class Solution {
    public boolean isInterleave(String s1, String s2, String s3) {
        int len1 = s1.length();
        int len2 = s2.length();
        int len3 = s3.length();
        
        if (len1+len2 != len3) {
            return false;
        }
        
        boolean[][] dp = new boolean[len1+1][len2+1];

        for (int i = 0; i <= len1; i++) {
            for (int j = 0; j <= len2; j++) {
                if (i == 0 && j == 0) {
                    dp[i][j] = true;
                } else if (i == 0 ) {
                    dp[i][j] = dp[i][j-1] && s3.charAt(i+j-1) == s2.charAt(j-1);
                } else if (j == 0) {
                    dp[i][j] = dp[i-1][j] && s3.charAt(i+j-1) == s1.charAt(i-1);
                } else {
                    dp[i][j] = (dp[i][j-1] && (s3.charAt(i+j-1) == s2.charAt(j-1)) || (dp[i-1][j] && s3.charAt(i+j-1) == s1.charAt(i-1)));
                }
            }
        }
        
        return dp[len1][len2];
    }
}

 9. House Robber II - 2nd Not Bug Free

思路：分为第一个被rob或不被rob两种情况讨论。

class Solution {
    public int rob(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int len = nums.length;
        if (len == 1) {
            return nums[0];
        }
        
        int[] firstNums = new int[len-1];
        for (int i = 0; i < nums.length-1; i++) {
            firstNums[i] = nums[i];
        }
        int firstRobbed = helper(firstNums);
        
        int[] secondNums = new int[len-1];
        for (int i = 0; i < secondNums.length; i++) {
            secondNums[i] = nums[i+1];
        }
        int firstNotRobbed = helper(secondNums);
        return Math.max(firstRobbed, firstNotRobbed);
    }
    
    public int helper(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        int[] dp = new int[nums.length+1];
        dp[0] = 0;
        dp[1] = nums[0];
        
        for (int i = 2; i <= nums.length; i++) {
            int index = i - 1;
            dp[i] = Math.max(dp[i-2]+nums[index], dp[i-1]);
        }
        return dp[nums.length];
    }
}

10. Maximum Subarray - 2nd Not Bug Free

思路：看dp[i-1]是否大于0

class Solution {
    public int maxSubArray(int[] nums) {
        if (nums == null || nums.length == 0) {
            return 0;
        }
        if (nums.length == 1) {
            return nums[0];
        }
        int[] dp = new int[nums.length];
        dp[0] = nums[0];
        int max = nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (dp[i-1] >= 0) {
                dp[i] = dp[i-1] + nums[i];
            } else {
                dp[i] = nums[i];
            }
            max = Math.max(dp[i], max);
        }
        return max;
    }
}

 11. Triangle - 2nd Not Bug Free

思路：dp[i][j]表示第ith行，第jth列的min sum，分情况讨论，当在最右侧，最左侧，中间来讨论。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        if (triangle == null || triangle.size() == 0 || triangle.get(0).size() == 0) {
            return 0;
        }
        int size = triangle.size();
        // ith row, jth column --> min sum
        int[][] dp = new int[size][size];
        dp[0][0] = triangle.get(0).get(0);
        
        for (int i = 1; i < size; i++) {
            for (int j = 0; j <= i; j++) {
                if (i == j) {
                    dp[i][j] = dp[i-1][j-1] + triangle.get(i).get(j);
                } else {
                    if (j == 0) {
                        dp[i][j] = dp[i-1][j] + triangle.get(i).get(j);
                    } else {
                        dp[i][j] = Math.min(dp[i-1][j], dp[i-1][j-1]) + triangle.get(i).get(j);
                    }
                }
            }
        }
        int res = dp[size-1][0];
        for (int j = 1; j < size; j++) {
            res = Math.min(res, dp[size-1][j]);
        }
        return res;
    }
}

12. Distinct Subsequences  - 2nd Not Bug Free

思路：dp[i][j] = dp[i-1][j-1] + dp[i][j-1] OR dp[i][j] = dp[i][j-1];

class Solution {
    public int numDistinct(String s, String t) {
        if (s == null || t == null || s.length() < t.length()) {
            return 0;
        }
        if (s.length() == t.length()) {
            return s.equals(t) ? 1 : 0;
        }
        int[][] dp = new int[t.length()+1][s.length()+1];
        
        for (int j = 0; j <= s.length(); j++) { 
            dp[0][j] = 1;
        }
        
        for (int i = 1; i <= t.length(); i++) {
            for (int j = 1; j <= s.length(); j++) {
                
                if (s.charAt(j-1) == t.charAt(i-1)) {
                    dp[i][j] = dp[i-1][j-1] + dp[i][j-1];
                } else {
                    dp[i][j] = dp[i][j-1];
                }
                
            }
        }
        return dp[t.length()][s.length()];
    }
}

 

 

 

 

Tree & Graph

1.    DFS Treversal

public static void preOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    System.out.println(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

public static void inOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    inOrder(root.left);
    System.out.println(root.val);
    inOrder(root.right);
}

public static void postOrder(TreeNode root) {
    if (root == null) {
        return;
    }
    postOrder(root.left);
    postOrder(root.right);
    System.out.println(root.val);
}

2.    BFS Treversal

    public static void solve1(TreeNode root) {
    Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);
    while (!q.isEmpty()) {
        TreeNode top = q.poll();
        System.out.printf("%d ", top.val);
        if (top.left != null) {
            q.offer(top.left);
        }
        if (top.right != null) {
            q.offer(top.right);
        }
    }
    }

    public static void solve2(TreeNode root) {
       Queue<TreeNode> q1 = new LinkedList<TreeNode>();
       q1.offer(root);
       int level = 0;
       while (!q1.isEmpty()) {
       System.out.printf("Level %d-----", level++);
           Queue<TreeNode> q2 = new LinkedList<TreeNode>();
           while (!q1.isEmpty()) {
           TreeNode top = q1.poll();
               System.out.printf("%d ", top.val);
           if (top.left != null) {
               q2.offer(top.left);
           }
           if (top.right != null) {
               q2.offer(top.right);
           }
       }
       q1 = q2;
       System.out.printf("\n");
       }
    }

 3.   Max Binary Tree Depth

public static int maxDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    return 1 + Math.max(maxDepth(root.left), maxDepth(root.right));
}

4.    Min Binary Tree Depth

public static int minDepth(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int min = 1;
    Queue<TreeNode> q = new LinkedList<TreeNode>();
    q.offer(root);
    while (!q.isEmpty()) {
        Queue<TreeNode> q2 = new LinkedList<TreeNode>();
    while (!q.isEmpty()) {
        TreeNode top = q.poll();
            if (top.left == null && top.right == null) {
            return min;
        }
        if (top.left != null) {
            q2.offer(top.left);
        }
        if (top.right != null) {
            q2.offer(top.right);
        }
    }
    q = q2;
    min++;
    }
    return min;
}

public static int minDepth(TreeNode root) {
    if (root == null) {
           return 0;
    }
    if (root.left == null && root.right == null) {
        return 1;
    }
    if (root.left == null && root.right != null) {
        return minDepth(root.right) + 1;
    }
    if (root.left != null && root.right == null) {
        return minDepth(root.left) + 1; 
    }
    return Math.min(minDepth(root.left), minDepth(root.right)) + 1;
}

 5. Course Schedule - 1st Not Bug Free

class Solution {
    public boolean canFinish(int numCourses, int[][] prerequisites) {
        List<List<Integer>> list = new ArrayList<>();
        for (int i = 0; i < numCourses; i++) {
            list.add(new ArrayList<Integer>());
        }
        int[] preNum = new int[numCourses];
        for (int i = 0; i < prerequisites.length; i++) {
            list.get(prerequisites[i][1]).add(prerequisites[i][0]);
            preNum[prerequisites[i][0]]++;
        }
        // 进行n轮，应该有n个课可以上，不然就是false；如果没有prerequisites
        // 就可以上
        for (int i = 0; i < numCourses; i++) {
            boolean hasCourseAva = false;
            for (int j = 0; j < numCourses; j++) {
                if (preNum[j] == 0) {
                    hasCourseAva = true;
                    for (int k : list.get(j)) {
                        preNum[k]--;
                    }
                    preNum[j] = -1;
                    break;
                }
            }
            if (!hasCourseAva) {
                return false;
            }
        }
        return true;
    }
}

6. Clone Graph - 1st Not Bug Free

思路：建立 A --> A'; B --> B'的map关系。

/**
 * Definition for undirected graph.
 * class UndirectedGraphNode {
 *     int label;
 *     List<UndirectedGraphNode> neighbors;
 *     UndirectedGraphNode(int x) { label = x; neighbors = new ArrayList<UndirectedGraphNode>(); }
 * };
 */
public class Solution {
    public UndirectedGraphNode cloneGraph(UndirectedGraphNode node) {
        if (node == null) {
            return null;
        }
        Map<UndirectedGraphNode, UndirectedGraphNode> map = new HashMap<>();
        UndirectedGraphNode head = new UndirectedGraphNode(node.label);
        map.put(node, head);
        Queue<UndirectedGraphNode> queue = new LinkedList<>();
        queue.add(node);
        
        while (!queue.isEmpty()) {
            UndirectedGraphNode top = queue.poll();
            for (UndirectedGraphNode neighbor : top.neighbors) {
                if (!map.containsKey(neighbor)) {
                    queue.add(neighbor);
                    UndirectedGraphNode newneighbor = new UndirectedGraphNode(neighbor.label);
                    map.put(neighbor, newneighbor);
                }
                map.get(top).neighbors.add(map.get(neighbor));
            }
        }
        return head;
    }
}

 7. Alien Dictionary - 1st Not Bug Free

思路：和Course Schedule差不多。

public class Solution {
    /**
     * @param words: a list of words
     * @return: a string which is correct order
     */
    public String alienOrder(String[] words) {
        // Write your code here
        Map<Character, Integer> preNum = new HashMap<>();
        Map<Character, Set<Character>> map = new HashMap<>();
        Set<Character> alphabet = new HashSet<>();
        StringBuilder order = new StringBuilder();
        for (String s : words) {
            char[] arr = s.toCharArray();
            for (char i : arr) {
                alphabet.add(i);
            }
        }
        for (Character c : alphabet) {
            map.put(c, new HashSet<Character>());
            preNum.put(c, 0);
        }
        for (int i = 0; i < words.length-1; i++) {
            int len = Math.min(words[i].length(), words[i+1].length());
            for (int j = 0; j < len; j++) {
                if (words[i].charAt(j) != words[i+1].charAt(j)) {
                    Set<Character> old = map.get(words[i].charAt(j));
                    old.add(words[i+1].charAt(j));
                    map.put(words[i].charAt(j), old);
                    preNum.put(words[i+1].charAt(j), preNum.get(words[i+1].charAt(j))+1);
                    break;
                }
            }
        }
        for (int i = 0; i < alphabet.size(); i++) {
            boolean foundHead = false;
            for (Map.Entry<Character, Integer> entry : preNum.entrySet()) {
                if (entry.getValue() == 0) {
                    foundHead = true;
                    order.append(entry.getKey());
                    preNum.put(entry.getKey(), -1);
                    for (Character c : map.get(entry.getKey())) {
                        preNum.put(c, preNum.get(c)-1);
                    }
                    break;
                }
            }
            if (!foundHead) {
                return new StringBuilder().toString();
            }
        }
        return order.toString();
    }
}

 8. Minimum Height Trees - 1st Not Bug Free

思路：所有的leaves一次往里面走一步，随时更新leaves。当<= 2个node时候就可以是根。

Start two pointers from both end of the path and move one step each time, until pointers meet or one step away, at the end pointers will be at those nodes which will minimize the height because we have divided the nodes evenly so height will be minimum.

class Solution {
    public List<Integer> findMinHeightTrees(int n, int[][] edges) {
        List<Integer> res = new ArrayList<>();
        if (n < 1) return res;
        List<HashSet<Integer>> graph = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            graph.add(new HashSet<>());
        }
        for (int i = 0; i < edges.length; i++) {
            graph.get(edges[i][0]).add(edges[i][1]);
            graph.get(edges[i][1]).add(edges[i][0]);
        }
        Queue<Integer> leaves = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            if (graph.get(i).size() <= 1) {
                leaves.add(i);
            }
        }
        while (n > 2) {
            n -= leaves.size();
            Queue<Integer> newLeaves = new LinkedList<>();
            while (!leaves.isEmpty()) {
                Integer leaf = leaves.poll();
                Integer neighbor = graph.get(leaf).iterator().next();
                graph.get(neighbor).remove(leaf);
                if (graph.get(neighbor).size() == 1) {
                    newLeaves.add(neighbor);
                }
            }
            leaves = newLeaves;
        }
        return new ArrayList<Integer>(leaves);
    }
}

 9. Evaluate Division - 1st Not Bug Free

思路：建立a --> b, b --> a的路径和valu hashmap。String[] 不能作为key。

List<String> rev = Arrays.asList(start, i); 建立一个set 代表visited, 防止环出现。

class Solution {
    public double[] calcEquation(String[][] equations, double[] values, String[][] queries) {
        Map<String, Set<String>> map = new HashMap<>();
        Map<List<String>, Double> value = new HashMap<>();
        for (int i = 0; i < equations.length; i++) {
            if (map.containsKey(equations[i][0])) {
                Set<String> old = map.get(equations[i][0]);
                old.add(equations[i][1]);
                map.put(equations[i][0], old);
            } else {
                Set<String> newSet = new HashSet<>();
                newSet.add(equations[i][1]);
                map.put(equations[i][0], newSet);
            }
            
            if (map.containsKey(equations[i][1])) {
                Set<String> old = map.get(equations[i][1]);
                old.add(equations[i][0]);
                map.put(equations[i][1], old);
            } else {
                Set<String> newSet = new HashSet<>();
                newSet.add(equations[i][0]);
                map.put(equations[i][1],newSet);
            }
            List<String> rev = new ArrayList<>();
            rev.add(equations[i][1]);
            rev.add(equations[i][0]); 
            value.put(Arrays.asList(equations[i]),values[i]);
            value.put(rev, (double)1/values[i]);
        }
        double[] res = new double[queries.length];
        for (int i = 0; i < res.length; i++) {
            Set<String> visited = new HashSet<>();
            res[i] = helper(map, value, queries[i][0], queries[i][1], 1, visited);
            if (res[i] == 0)  res[i] = -1.0;
        }
        return res;
    }
    
    public double helper(Map<String, Set<String>> map, Map<List<String>, Double> value, String start, String end, double tmp, Set<String> visited) {
        if (visited.contains(start)) {
            return 0;
        }
        if (!map.containsKey(start)) {
            return -1;
        }
        if (start.equals(end)) {
            return tmp;
        }
        visited.add(start);
        double res = 0;
        for (String i : map.get(start)) {
            List<String> rev = new ArrayList<>();
            rev.add(start);
            rev.add(i); 
            if (value.containsKey(rev)) {
                double val = value.get(rev);
                res = helper(map, value, i, end, val*tmp,visited);
                if (res != 0) {
                    break;
                }
            }
        }
        return res;
    }
}

 10. Course Schedule II - 1st Not Bug Free

思路：map.put(i, new ArrayList<Integer>())

class Solution {
    public int[] findOrder(int numCourses, int[][] prerequisites) {
        Map<Integer, List<Integer>> map = new HashMap<>();
        for (int i = 0; i < numCourses; i++) {
            map.put(i, new ArrayList<Integer>());
        }
        int[] preNum = new int[numCourses];
        for (int i = 0; i < prerequisites.length; i++) {
            List<Integer> old = map.get(prerequisites[i][1]);
            old.add(prerequisites[i][0]);
            map.put(prerequisites[i][1], old);
            preNum[prerequisites[i][0]]++;
        }
        int[] res = new int[numCourses];
        int count = 0;
        for (int i = 0; i < numCourses; i++) {
            for (int j = 0; j < numCourses; j++) {
                if (preNum[j] == 0) {
                    res[i] = j;
                    count++;
                    preNum[j] = -1;
                    for (int k : map.get(j)) {
                        preNum[k]--;
                    }
                    break;
                }
            }
        }
        if (count == numCourses) {
            return res;
        } else {
            return new int[0];
        }
    }
}

 11. Binary Tree Preorder Traversal

思路：利用stack，先push root；接下来while loop，先pop root，然后加右子树，再左子树。

class Solution {
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        stack.push(root);
        while (!stack.isEmpty()) {
            TreeNode top = stack.pop();
            res.add(top.val);
            if (top.right != null) {
                stack.push(top.right);                
            }
            if (top.left != null) {
                stack.push(top.left);
            }
        }
        return res;
    }
}

12. Binary Tree Inorder Traversal - 2nd Not Bug Free

思路：while (!stack.isEmpty() || curNode != null) 和 if (curNode!= null) {} else {}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode curNode = root;
        while (!stack.isEmpty() || curNode != null) {
            if (curNode!= null) {
                stack.push(curNode);
                curNode = curNode.left;
            } else {
                curNode = stack.pop();
                res.add(curNode.val);
                System.out.println(curNode.val);
                curNode = curNode.right;
            }
        }
        return res;
    }
}

13. Binary Tree Postorder Traversal - 1st Not Bug Free

思路：画出stack的过程图，hj 得知要建立一个visited，第二次访问时才打印出来。

坑：打印时要 cur = null；

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 *     visited
 * }
 */
class Solution {
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<>();
        if (root == null) {
            return res;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (!stack.isEmpty() || cur != null) {
            if (cur != null) {
                stack.push(cur);
                cur = cur.left;
            } else {
                cur = stack.pop();
                if (!cur.visited) {
                    cur.set(true);
                    stack.push(cur);
                    cur = cur.right;
                } else {
                    res.add(cur.val);
                    cur = null;
                }
            }
        }
        return res;
    }
}

public class TreeNode{
    int val;
    boolean visited = false;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) {
        this.val = x;
    }
    
    void set(boolean visited) {
        this.visited = visited;
    }
}

 14. Unique Binary Search Trees - 1st Not Bug Free

思路：G(n) = G(0) * G(n-1) + G(1) * G(n-2) + … + G(n-1) * G(0) 

以第0个为root，第1个为root，第2个为root，分左右两侧。

class Solution {
    public int numTrees(int n) {
        if (n == 0) {
            return 1;
        }
        if (n <= 2) {
            return n;
        }
        int[] dp = new int[n+1];
        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <=n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[i-j]*dp[j-1];
            }
        }
        return dp[n];
    }
}

15. Unique Binary Search Trees II  - 1st Not Bug Free

思路：in-order来帮助。第1个为root，第2，...，n个为root，分左右两侧。

public class Solution {
    public List<TreeNode> generateTrees(int n) {
        
        return genTrees(1,n);
    }
        
    public List<TreeNode> genTrees (int start, int end)
    {

        List<TreeNode> list = new ArrayList<TreeNode>();

        if(start>end)
        {
            list.add(null);
            return list;
        }
        
        if(start == end){
            list.add(new TreeNode(start));
            return list;
        }
        
        List<TreeNode> left,right;
        for(int i=start;i<=end;i++)
        {
            
            left = genTrees(start, i-1);
            right = genTrees(i+1,end);
            
            for(TreeNode lnode: left)
            {
                for(TreeNode rnode: right)
                {
                    TreeNode root = new TreeNode(i);
                    root.left = lnode;
                    root.right = rnode;
                    list.add(root);
                }
            }
                
        }
        
        return list;
    }
}

 

 

 

 

 

 

 

Binary Search

1.    Binary Search - Not Bug Free - Bug Free

public int binarySearch(int[] nums, int target) {
    int start = 0;
    int end = nums.length - 1;
    while (start <= end) {
    int mid = (start + end)/2;
        if (nums[mid] == target) {
        return target;
    }
    if (nums[mid] > target) {
        end = mid - 1;
    }
    if (nums[mid] < target) {
        start = mid + 1;
    }
    }
    return -1;
}

 2.   Binary Insert

public int binaryInsert(int[] nums, int target) {
    int start = 0;
    int end = nums.length - 1;
    while (start <= end) {
        int mid = (start + end)/2;
    if (nums[mid] == target) {
        return mid;
    }
    if (nums[mid] > target) {
        end = target - 1;
    }
    if (nums[mid] < target) {
        start = mid + 1;
    }
    }
    return start;
}

 3.   Search in rotated array - Not Bug Free  - Not Bug Free

坑：if-else的使用；大于，小于范围不能有空隙。

class Solution {
    public int search(int[] nums, int target) {
        if (nums.length == 0) {
            return -1;
        }
        int start = 0;
        int end = nums.length - 1;
        while (start <= end) {
            int mid = (start + end)/2;            
            if (nums[mid] >= nums[start]) {
                if (nums[mid] == target) {
                    return mid;
                }
                else if (nums[mid] > target && target >= nums[start]) {
                    end = mid - 1;
                } else {
                    start = mid + 1;
                }
            } else {
                if (nums[mid] == target) {
                    return mid;
                }
                else if (nums[mid] < target && target <= nums[end]) {
                    start = mid + 1;
                } else {
                    end = mid - 1;
                }
            }
        }
        return -1;
    }
}

 4.   Sqrt - Not Bug Free - New

坑：要这样写 midVal > target / midVal, 而不是这样 midVal * midVal > target, 因为int 会溢出》

思路：三个不同的区间讨论。

class Solution {
    public int mySqrt(int target) {
        if (target < 0) {
            return -1;
        }
        if (target == 0 || target == 1) {
            return target;
        }
        int start = 1;
        int end = target;
        while (start <= end) {
            int midVal = start + (end - start)/2;
            if (midVal <= target/midVal && (midVal+1) > target/(midVal+1)) {
                return midVal;
            } else if (midVal > target/midVal) {
                end = midVal;
            } else if ((midVal+1) <= target/(midVal+1)) {
                start = midVal + 1;
            }
        }
        return start;
    }
}

 5. Find Peak Element - New - Not Bug Free

坑：考虑len = 0, 1, 2等情况。

思路：nums[mid] < nums[mid+1]: start = mid+1; else end = mid-1;

 6. Wood cut - New - Not Bug Free

心得：注意while loop 的条件, start 和 end 如何改变，以及返回的是start 还是 end.

7. Find Minimum in Rotated Sorted Array II - New - Not Bug Free

心得：当 nums[mid] = nums[h], h--, 相当于在去重！！！

8. Search a 2D Matrix II - New - Not Bug Free

思路：从左下角或右上角开始找.

 

 

 

 

 

Sort

1.    Bubble Sort

public static void bubbleSort(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
        boolean swapped = false;
        for (int j = 0; j < nums.length - 1; j++) {
            if (nums[j] > nums[j+1]) {
            swap(nums, j, j + 1);
            swapped = true;
        }
        if (!swapped) {
            return;
        }  
    }
}

2.    Insert Sort

坑：当有 nums[j] < nums[j-1]，注意for loop 的边界条件. 以及

public static void insertSort(int[] nums) {
    for (int i = 0; i < nums.length - 1; i++) {
        for (int j = i + 1; j > 0; j--) {
            if (nums[j] < nums[j-1]) {
                swap(nums, j, j - 1);
                swapped = true;
            }
        }
    }
}

3.    Selection Sort

public static void selectionSort(int[] nums) {
    for (int i = 0; i < nums.length; i++) {
    int min = nums[i];
    int minIndex = i;
        for (int j = i; j < nums.length; j++) {
        if (min > nums[j]) {
        minIndex = j;
            min = nums[j];
        }
    }
    swap(nums, i, minIndex);
    }
}
    

4.    Merge Sort

    public static void mergeSort(int[] nums) {
        solveMergeSort(nums, 0, nums.length - 1);
    }

    public static void solveMergeSort(int[] nums, int start, int end) {
        if (start < end) {
            int mid = start + (end - start)/2;
        solveMergeSort(nums, start, mid);
        solveMergeSort(nums, mid + 1, end);
        merge(nums, start, mid, end);
        }
    }

    public static void merge(int[] nums, int start, int mid, int end) {
        int k = start;
        int i = start;
        int j = mid + 1;
        int[] helper = new int[nums.length]; 
        for (int m = start; m <= end; m++) {
            helper[m] = nums[m];
        }
        while (i <= mid && j <= end) {
            if (helper[i] < helper[j]) {
            nums[k++] = helper[i++];
        } else {
            nums[k++] = helper[j++];
        }
        }
        while (i <= mid) {
            nums[k++] = helper[i++];
        }
        while (j <= end) {
            nums[k++] = helper[j++];
        }
    }

 5.    Quick Sort

    public static void quickSort(int[] nums) {
        
        quickSort(nums, 0, nums.length - 1);
        
    }

    public static void quickSort(int[] nums, int start, int end) {
         if (start < end) {
             int pivot = partition(nums, start, end);
                 quickSort(nums, start, pivot - 1);
         quickSort(nums, pivot + 1, end);
         }

    }

    public static int partition(int[] nums, int start, int end) {
        int tmp = nums[start];
        while (start < end) {
            while (start < end && nums[end] >= tmp) {
            end--;
        }
        nums[start] = nums[end];
        while (start < end && nums[start] <= tmp) {
            start++;
        }
        nums[end] = nums[start];
        }
        nums[start] = tmp;
        return start;
    }

 6. Best Meeting Point - 2nd Bug Free

思路：排序之后，最左边的点减去最右边的点。直到相遇。

public class Solution {
    /**
     * @param grid: a 2D grid
     * @return: the minimize travel distance
     */
    public int minTotalDistance(int[][] grid) {
        // Write your code here
        List<Integer> x = new ArrayList<>();
        List<Integer> y = new ArrayList<>();
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                if (grid[i][j] == 1) {
                    x.add(i);
                    y.add(j);
                }
            }
        }
        Collections.sort(x);
        Collections.sort(y);
        int i = 0;
        int j = x.size()-1;
        int sum = 0;
        while (i < j) {
            sum += x.get(j) - x.get(i);
            sum += y.get(j) - y.get(i);
            i++;
            j--;
        }
        return sum;
    }
}

7. Largest Number - 2nd Not Bug Free

思路：string a 和 string b结合看谁大。建立comprator. 首位为0时，返回0.

坑：if (strs[0].equals("0")) return "0";

class Solution {
    public String largestNumber(int[] nums) {
        if (nums == null || nums.length == 0) {
            return "";
        }
        Comparator comparator = new Comparator<String>(){
            public int compare(String a, String b) {
                return (b+a).compareTo(a+b);
            }
        };
        String[] strs = new String[nums.length];
        for (int i = 0; i < nums.length; i++) {
            strs[i] = String.valueOf(nums[i]);
        }
        Arrays.sort(strs, comparator);
        if (strs[0].charAt(0) == '0') {
            return "0";
        }
        StringBuilder builder = new StringBuilder();
        for (String s : strs) {
            builder.append(s);
        }
        return builder.toString();
    }
}

8. Merge Intervals - 2nd Not Bug Free

思路：先按start排序，然后看这个关系intervals.get(i+1).start <= intervals.get(i).end。最后一个元素要额外加进去。

坑：int max = Math.max(pre.end, cur.end); 最后一个元素要额外加入进去。

/**
 * Definition for an interval.
 * public class Interval {
 *     int start;
 *     int end;
 *     Interval() { start = 0; end = 0; }
 *     Interval(int s, int e) { start = s; end = e; }
 * }
 */
class Solution {
    public List<Interval> merge(List<Interval> intervals) {
        Comparator comparator =  new Comparator<Interval>() {
            public int compare(Interval a, Interval b) {
                return a.start - b.start;
            }
        };
        List<Interval> res = new ArrayList<>();
        if (intervals == null || intervals.size() == 0 || intervals.size() == 1) {
            return intervals;
        }
        Collections.sort(intervals, comparator);
        
        for (int i = 0; i < intervals.size()-1; i++) {
            if (intervals.get(i+1).start <= intervals.get(i).end) {
                Interval combine = new Interval(intervals.get(i).start, Math.max(intervals.get(i).end, intervals.get(i+1).end));
                intervals.set(i+1,combine);
            } else {
                res.add(intervals.get(i));
            }
        }
        res.add(intervals.get(intervals.size()-1));
        return res;
    }
}

 10. Maximum Gap - 2nd Bug Free

思路：桶排序的思路，每个筒只放最大和最小值，gap就是Math.max(gap, buckets.get(i).get(0)-buckets.get(prev).get(1));

class Solution {
    public int maximumGap(int[] nums) {
        if (nums.length == 0)  return 0;
        int max = nums[0];
        int min = nums[0];
        for (int i : nums) {
            max = Math.max(i, max);
            min = Math.min(i, min);
        }
        int len = (max-min)/nums.length + 1;
        List<List<Integer>> buckets = new ArrayList<>();
        int bucketSize = (max-min)/len + 1;
        for (int i = 0; i < bucketSize; i++) {
            buckets.add(new ArrayList<>());
        }
        for (int num : nums) {
            int i = (num-min)/len;
            if (buckets.get(i).isEmpty()) {
                buckets.get(i).add(num);
                buckets.get(i).add(num);
            } else {
                if (num < buckets.get(i).get(0))  buckets.get(i).set(0, num);
                if (num > buckets.get(i).get(1))  buckets.get(i).set(1, num);
            }
        }
        int gap = 0, prev = 0;
        for (int i = 1; i < bucketSize; i++) {
            if (buckets.get(i).isEmpty()) continue;
            gap = Math.max(gap, buckets.get(i).get(0)-buckets.get(prev).get(1));
            prev = i;
        }
        return gap;
        
    }
}

 11. Sort elements by frequency - 1st Not Bug Free

思路：定义comparator，按freq 和 index。建立关于freq和index的hashmap。

// "static void main" must be defined in a public class.
public class Main {
     static class Container{
        int val;
        int freq;
        int index;
        public Container(int val, int freq, int index) {
            this.val  =val;
            this.freq = freq;
            this.index = index;
        }
    }
    
    public static void main(String[] args) {
        System.out.println("Hello World!");
        int[] arr = {2, 5, 2, 8, 5, 6, 8, 8};
        System.out.println(Arrays.toString(sortFrequency(arr)));
    }
    
    public static int[] sortFrequency(int[] arr) {
        Map<Integer, Integer> f = new HashMap<>();
        Map<Integer, Integer> idx = new HashMap<>();
        Comparator<Container> comparator = new Comparator<Container>(){
            public int compare(Container a, Container b) {
                if (a.freq != b.freq) {
                    return b.freq - a.freq;
                } else {
                    return a.index - b.index;
                }
            }
        };
        for (int i = 0; i < arr.length; i++) {
            if (f.containsKey(arr[i])) {
                f.put(arr[i], f.get(arr[i])+1);
            } else {
                f.put(arr[i], 1);
            }
            if (!idx.containsKey(arr[i])) {
                idx.put(arr[i],i);
            }
        }
        List<Container> list = new ArrayList<>();
        for (Map.Entry<Integer, Integer> item : f.entrySet()) {
            list.add(new Container(item.getKey(), item.getValue(), idx.get(item.getKey())));
        }
        Collections.sort(list, comparator);
        int[] res = new int[arr.length];
        int total = 0;
        for (int i = 0; i < list.size(); i++) {
            int count = list.get(i).freq;
            int j = 0;
            while (j < count) {
                res[total+j] = list.get(i).val;
                j++;
            }
            total += count;
        }
        return res;
    }
}

 

HashMap

1.   Anagram - Not Bug Free

public class Solution {
    public List<String> anagrams(String[] strs) {
        List<String> ans = new ArrayList<>();
        HashMap<String, List<String>> map = new HashMap<>();
        for (String s : strs) {
            char[] arr = s.toCharArray();
            Arrays.sort(arr);
            String newStr = String.valueOf(arr);
            if (map.containsKey(newStr)) {
                List<String> newList = new ArrayList<>(map.get(newStr));
                newList.add(s);
                map.put(newStr, newList);
            } else {
                List<String> newList = new ArrayList<String>();
                newList.add(s);
                map.put(newStr, newList);
            }
        }
        for (Map.Entry<String, List<String>> entry : map.entrySet()) {
            if (entry.getValue().size() > 1) {
                for (String ss : entry.getValue()) {
                    ans.add(ss);
                }
            }
        }
        return ans;
    }
}

 2. Contiguous Array - 2nd Bug Free

思路：站在i位置上看前i-1个数的0,1差距，站在j置上看前j-1个数的0,1差距, 如果两者相等中间有j-i个0,1相等。

坑：diff长度比nums长度大1，因为要看前n个数，所以要站在n+1的位置上。

diff[i] = diff[i - 1] + (nums[i - 1] == 0 ? -1 : 1);

class Solution {
    public int findMaxLength(int[] nums) {
        int[] diff = new int[nums.length + 1];
        Map<Integer, Integer> map = new HashMap<>();
        int max = 0;
        int sum = 0;
        map.put(0,0);
        for (int i = 1; i <= nums.length; i++) {
            diff[i] = diff[i - 1] + (nums[i - 1] == 0 ? -1 : 1);
            if (!map.containsKey(diff[i])) {
                map.put(diff[i], i);
            } else {
                max = Math.max(i - map.get(diff[i]), max);
            }
        }
        return max;
    }
}

新解法：

class Solution {
    public int findMaxLength(int[] nums) {
        int sum = 0;
        int res = 0;
        Map<Integer, Integer> map = new HashMap<>();
        map.put(0, -1);
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] == 0) {
                sum++;
            } else {
                sum--;
            }
            if (map.containsKey(sum)) {
                res = Math.max(res, i - map.get(sum));                
            } else {
                map.put(sum, i);
            }
        }
        return res;
    }
}

3. Longest Substring Without Repeating Characters - 4th Not Bug Free

思路：双指针，其实都为0，一个不动，另一个往前移动。

坑：i = Math.max(map.get(cur)+1, i);，防止i 又往回走.

class Solution {
    public int lengthOfLongestSubstring(String s) {
        char[] arr = s.toCharArray();
        Map<Character, Integer> map = new HashMap<>();
        int max = 0;
        for (int i = 0, j = 0; j < arr.length; j++) {
            char cur = arr[j];
            if (map.containsKey(cur)) {
                i = Math.max(map.get(cur)+1, i);
            }
            map.put(cur, j);
            max = Math.max(j-i+1, max);
        }
        return max;
    }
}

 思路2：int[] cache = new int[256];

坑：cache默认值为0，这个cache[cur] > 0，会导致无法第一次向前跳，所以要默认 cache[cur] = j+1;

class Solution {
    public int lengthOfLongestSubstring(String s) {
        char[] arr = s.toCharArray();
        int[] cache = new int[256];
        int max = 0;
        for (int i = 0, j = 0; j < arr.length; j++) {
            char cur = arr[j];
            if (cache[cur] > 0) {
                i = Math.max(cache[cur], i);
            }
            cache[cur] = j+1;
            max = Math.max(j-i+1, max);
        }
        return max;
    }
}

4.  Word Pattern II - 2nd Not Bug Free

坑：

if (map.containsKey(cur)) {
        String curStr = map.get(cur);
        if (!str.startsWith(curStr, idx)) return false;
        else return helper(p, str, map, reMap, pIdx+1, idx+curStr.length());
}

public class Solution {
    public boolean wordPatternMatch(String pattern, String str) {
        // write your code here
        char[] p = pattern.toCharArray();
        Map<Character, String> map = new HashMap<>();
        Map<String, Character> reMap = new HashMap<>();
        return helper(p, str, map, reMap, 0, 0);
    }
    
    public boolean helper(char[] p, String str, Map<Character, String> map, Map<String, Character> reMap, int pIdx, int idx) {
        if (pIdx == p.length && idx == str.length()) {
            return true;
        }
        if (pIdx == p.length || idx == str.length()) {
            return false;
        }
        char cur = p[pIdx];
        if (map.containsKey(cur)) {
            String curStr = map.get(cur);
            if (!str.startsWith(curStr, idx)) return false;
            else return helper(p, str, map, reMap, pIdx+1, idx+curStr.length());
        }
        for (int i = idx; i < str.length(); i++) {
            String curStr = str.substring(idx, i+1);
            if (reMap.containsKey(curStr)) {
                continue;
            }
            map.put(cur, curStr);
            reMap.put(curStr, cur);
            if (helper(p, str, map, reMap, pIdx+1, i+1)) {
                return true;
            }
            map.remove(cur);
            reMap.remove(curStr);
        }
        return false;
    }
}

5. Minimum Window Substring - 1st Not Bug Free

思路：hashmap加双指针。一个指头，一个指尾。

模板：

int findSubstring(string s){
        vector<int> map(128,0);
        int counter; // check whether the substring is valid
        int begin=0, end=0; //two pointers, one point to tail and one  head
        int d; //the length of substring

        for() { /* initialize the hash map here */ }

        while(end<s.size()){

            if(map[s[end++]]-- ?){  /* 尾巴向右移动，直到所有元素都找到 */ }

            while(/* counter condition */){ 
                 
                 /* 头向右移动，直到有一个元素移出去了*/
　　　　　　　　　　
                //increase begin to make it invalid/valid again
                
                if(map[s[begin++]]++ ?){ /*modify counter here*/ }
            }  

            /* update d here if finding maximum*/
        }
        return d;
  }

 

class Solution {
    public String minWindow(String s, String t) {
        int[] number = new int[256];
        for (int i = 0; i < t.length(); i++) {
            char cur = t.charAt(i);
            number[cur]++;
        }
        int begin = 0, end = 0, head = 0;
        int len = Integer.MAX_VALUE;
        int cnt = t.length();
        while (end < s.length()) {
            if (number[s.charAt(end)] > 0) {
                cnt--;
            }
            number[s.charAt(end)]--;
            end++;
            while (cnt == 0) {
                if (end - begin < len) {
                    len = end - begin;
                    head = begin;
                }
                if (number[s.charAt(begin)] == 0) {
                    cnt++;
                }
                number[s.charAt(begin)]++;
                begin++;
            }
        }
        return len == Integer.MAX_VALUE ? "" : s.substring(head, head + len);
    }
}

 

 

 

 

Heap

Good at maintaining a dynamic data stream, from which largest/smallest is always needed, while there is no need for sorting.

1. Merge k Sorted Lists  - 2nd Not Bug Free

思路：定义一个minHeap，将所有ListNode的头加入进去，再取出时即为最小的。

再把取出元素的下一个加入heap。建立dummy node。

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) { val = x; }
 * }
 */
class Solution {
    public ListNode mergeKLists(ListNode[] lists) {
        if (lists == null || lists.length == 0) {
            return null;
        }
        Comparator<ListNode> compartor = new Comparator<ListNode>() {
            public int compare(ListNode node1, ListNode node2) {
                return node1.val - node2.val;
            }  
        };
        PriorityQueue<ListNode> minHeap = new PriorityQueue<ListNode>(lists.length, compartor);
        for (int i = 0; i < lists.length; i++) {
            if (lists[i] != null) {
                minHeap.offer(lists[i]);
            }
        }
        ListNode dummy = new ListNode(-1);
        ListNode cur = dummy;
        while (!minHeap.isEmpty()) {
            cur.next = minHeap.poll();
            cur = cur.next;
            if (cur.next != null) {
                minHeap.offer(cur.next);
            }
        }
        return dummy.next;
    }
}

 2. Sliding Window Maximum - 2nd Not Bug Free

思路：定义一个maxHeap,里面装K个数，每次移动窗口时要remove之前的一个元素.

class Solution {
    public int[] maxSlidingWindow(int[] nums, int k) {
        if (nums == null || nums.length == 0) {
            return nums;
        }
        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(k, new Comparator<Integer>(){
            public int compare(Integer a, Integer b) {
                return b - a;
            }
        });
        int[] result = new int[nums.length - k + 1];
        for (int i = 0; i < nums.length; i++) {
            if (i >= k) {
                maxHeap.remove(nums[i-k]);
            }
            maxHeap.add(nums[i]);
            if (maxHeap.size() == k) {
                result[i+1-k] = maxHeap.peek();
            }
        }
        return result;
    }
}

3. Kth Largest Element in an Array - 2nd Bug Free

思路：定义一个minHeap, 要是nums[i] > minHeap.peek()就用它替换minHeap的top.

class Solution {
    public int findKthLargest(int[] nums, int k) {
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(k, new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                return a - b;
            }
        });
        for (int i = 0; i < nums.length; i++) {
            if (minHeap.size() < k) {
                minHeap.add(nums[i]);
            } else {
                if (minHeap.peek() < nums[i]) {
                    minHeap.poll();
                    minHeap.add(nums[i]);
                }
            }
        }
        return minHeap.peek();
    }
}

4. Find Median from Data Stream - 2nd Not Bug Free

思路：定义一个maxHeap和minHeap，把minHeap的最小值给maxHeap，若是长度差大于1，把maxHeap的最大值给minHeap。

注意，maxHeap要用负值。

class MedianFinder {

    /** initialize your data structure here. */
    PriorityQueue<Integer> minHeap = new PriorityQueue<>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>();
    public MedianFinder() {
        
    }
    
    public void addNum(int num) {
        minHeap.add(num);
        maxHeap.add(-minHeap.poll());
        if (maxHeap.size() - minHeap.size() > 1) {
            minHeap.add(-maxHeap.poll());
        }
    }
    
    public double findMedian() {
        if (maxHeap.size() == minHeap.size()) {
            return (double)((-maxHeap.peek() + minHeap.peek())/2.0);
        } else {
            return -maxHeap.peek();
        }
    }
}

/**
 * Your MedianFinder object will be instantiated and called as such:
 * MedianFinder obj = new MedianFinder();
 * obj.addNum(num);
 * double param_2 = obj.findMedian();
 */

5. Top N Numbers - 1st Not Bug Free

思路：建立minHeap，每两行处理一下，注意comparator的使用.

    public static List<Integer> topN(int[]][] nums) {
        List<Integer> res = new ArrayList<>();
        PriorityQueue<Integer> minHeap = new PriorityQueue<>(n);
        int len = nums.length;
        int width = nums[0].length;
        for (int i : nums[0]) {
            minHeap.add(i);
        }
        for (int i = 1; i < len; i++) {
            int[] preList =  new int[width];
            for (int j = width-1; j >=0; j--) {
                preList[j] = minHeap.poll();
            }
            
            int[] curList = nums[i];
            Arrays.sort(curList);
            int largest = curList[width-1];
            for (int j = 0; j < width; j++) {
                minHeap.add(largest + preList[j]);
            }
            for (int j = width - 2; j >= 0; j++) {
                for (int r = 0; r < width; r++) {
                    if (curList[j] + preList[r] < minHeap.peek()) {
                        break;
                    }
                    minHeap.poll();
                    minHeap.add(curList[j] + preList[r]);
                }
            }
        }
        Comparator comparator = new Comparator<Integer>(){
            public int compare(Integer a, Integer b) {
                return b - a;
            }
        };
        result.addAll(minHeap);
        Collections.sort(result, comparator);
        return result;
    }

 6. Merge K sorted arrays - 1st Not Bug Free

思路：建立minHeap,把每个array的第一个元素放进去。每取出一个元素，就把对应元素array里的下一个元素放进去。

public class Solution {
    /**
     * @param arrays: k sorted integer arrays
     * @return: a sorted array
     */
    public int[] mergekSortedArrays(int[][] arrays) {
        // write your code here
        Comparator<Value> compartor = new Comparator<Value>() {
            public int compare(Value a, Value b) {
                return a.val - b.val;
            }  
        };
        int size = 0;
    PriorityQueue<Value> minHeap = new PriorityQueue<Value>(arrays.length, compartor);
        for (int i = 0; i < arrays.length; i++) {
            if (arrays[i].length != 0) 
                minHeap.offer(new Value(arrays[i][0], i, 0));
                size += arrays[i].length;
        }
    int[] res = new int[size];
        int total = 0;
        while (!minHeap.isEmpty()) {
            Value top = minHeap.poll();
            res[total++] = top.val;
            if (top.index2 < arrays[top.index1].length - 1) 
                minHeap.offer(new Value(arrays[top.index1][top.index2+1], top.index1, top.index2+1));
        }
    return res;
    }
}

class Value {
    int val;
    int index1;
    int index2;

    public Value(int val, int index1, int index2){
        this.val = val;
        this.index1 = index1;
        this.index2 = index2;
    }
}

 

 

 

 

Math

1.   Add Strings - Not Bug Free. 对string，char[] API不熟悉

Given two non-negative integers num1 and num2 represented as string, return the sum of num1 and num2.

class Solution {
    public String addStrings(String nums1, String nums2) {
        char[] str1 = nums1.toCharArray();
        char[] str2 = nums2.toCharArray();
        reverse(str1);
        reverse(str2);
        int len = str1.length > str2.length ? str1.length : str2.length;
        char[] result = new char[len];
        int carry = 0;
        int i = 0;
        while (i < str1.length || i < str2.length || carry > 0) {
            if (i < str1.length) {
                carry += Character.getNumericValue(str1[i]);
            }
            if (i < str2.length) {
                carry += Character.getNumericValue(str2[i]);
            }
            int digit = carry%10;
            carry = carry/10;
            if (i == len) {
                reverse(result);
                return String.valueOf((char)(digit + 48)) + new String(result);
            } else {
               result[i++] = (char)(digit + 48); 
            }
            
        }
        reverse(result);
        return new String(result); 
    }   
    
    public void reverse(char[] str) {
        int i = 0;
        int j = str.length - 1;
        while (i < j) {
            char tmp = str[i];
            str[i++] = str[j];
            str[j--] = tmp;
        }
    }
}

坑：

class Solution {
    public String addStrings(String num1, String num2) {
        //TODO empty strings
        char[] arr1 = num1.toCharArray();
        char[] arr2 = num2.toCharArray();
        reverse(arr1);
        reverse(arr2);
        int carry = 0;
        // 可以用int[] array 代替，其长度最多为max(arr1, arr2) + 1, int[] 比 List<Integer>好用
        List<Integer> ans = new ArrayList<>();
        int i = 0;
        int j = 0;
        // 加上 || carry > 0 之后不需要下面两个循环
        while (i < arr1.length || j < arr2.length) {
            if (i < arr1.length) {
                carry += Character.getNumericValue(arr1[i++]);
            }
            if (j < arr2.length) {
                carry += Character.getNumericValue(arr2[j++]);
            }
            int digit = carry%10;
            carry /= 10;
            ans.add(digit);
        }
        while (i < arr1.length) {
            carry += Character.getNumericValue(arr1[i++]);
            int digit = carry%10;
            carry /= 10;
            ans.add(digit);
        }
        while (j < arr2.length) {
            carry += Character.getNumericValue(arr2[j++]);
            int digit = carry%10;
            carry /= 10;
            ans.add(digit);
        }
        if (carry > 0) {
            ans.add(carry);
        }
        reverse(ans);
        String str = "";
        for (int m : ans) {
            str += String.valueOf(m);
        }
        return str;
    }
    
    public void reverse(List<Integer> ans) {
        int i = 0;
        int j = ans.size() - 1;
        while (i < j) {
            int tmp = ans.get(i);
            ans.set(i++, ans.get(j));
            ans.set(j--, tmp);
        }
    }
    
    public void reverse(char[] str) {
        int i = 0;
        int j = str.length - 1;
        while (i < j) {
            char tmp = str[i];
            str[i++] = str[j];
            str[j--] = tmp;
        }
    }
}

2.   Arranging Coins - Not Bug Free.

思路：二分法；注意防止int溢出

public class Solution {
    public int arrangeCoins(int n) {
        int start = 0;
        int end = n;
        int mid = 0;
        while (start <= end){
            mid = start + (end - start)/2;
            if (0.5 * mid * (mid + 1) <= n){
                start = mid + 1;
            } else {
                end = mid - 1;
            }
        }
        return start - 1;
    }
}

 3.   Self Dividing Numbers

class Solution {
    public List<Integer> selfDividingNumbers(int left, int right) {
        List<Integer> result = new ArrayList<>();
        for (int i = left; i <= right; i++) {
            int tmp = i;
            result.add(tmp);
            while (tmp > 0) {
                int digit = tmp%10;
                if (digit == 0 || i%digit != 0) {
                    result.remove(result.size() - 1);
                    break;
                }
                tmp = tmp/10;
            }
        }
        return result;
    }
}

4.   Palindrome Number - To be visited

自己的版本.

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0) {
            return false;
        }
        if (x < 10 && x >= 0) {
            return true;
        }
        int tmp = x;
        int len = 0;
        while (tmp > 0) {
            len++;
            tmp = tmp/10;
        }
        int left = x;
        int right = x;
        int lStart = len - 1;
        for (int i = 0; i <= len/2; i++) {
            int first = (int)(left/Math.pow(10, lStart));
            left = (int)(left%Math.pow(10, lStart--));
            int last = (int)(right%10);
            right = (int)(right/10);
            if (first != last) {
                return false;
            }
        }
        return true;
    }
}

改进的版本

class Solution {
    public boolean isPalindrome(int x) {
        if (x < 0 || (x != 0 && x%10 == 0)) {
            return false;
        }
        int rt = 0;
        while (rt < x) {
            rt = rt * 10 + x % 10;
            x /= 10;
        }
        return (rt == x) || (rt / 10 == x);
    }
}

 5.   Set Mismatch - To be visited

思路：所有已知从[a, b]的找missing的都可以用这个思路。本质是排序。

class Solution {
    public int[] findErrorNums(int[] nums) {
        int[] result = new int[2];
        for(int i = 0; i < nums.length; i++) {
            while (i+1 != nums[i] && nums[i] - 1 < nums.length && nums[i] != nums[nums[i] - 1]) {
                swap(nums, i, nums[i] - 1);
            }
        }
        for (int i = 0; i < nums.length; i++) {
            if (nums[i] != i + 1) {
                result[0] = nums[i];
                result[1] = i + 1;
                break;
            }
        }
        return result;
    }
    
    public void swap(int[] nums, int i, int j) {
        int tmp = nums[i];
        nums[i] = nums[j];
        nums[j] = tmp;
    }
}

 

 

 

Bit Operations

1.   Exchange two integers without using extra variable. - New

思路：异或的使用

    public static void swap(int a, int b) {
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
    }

2.   Return the larger integer without comparing them. - New

思路：利用a-b，考虑a-b是否会溢出. 注意判断a, b是否同符号的代码.

    public static int larger(int a, int b) {
        int c = a - b;
        int signA = sign(a);
        int signB = sign(b);
        int signC = sign(c);
        int signDif = signA ^ signB;
        int signSame = flip(signDif);
        int cofA = signDif * signA + signC * signSame;
        int cofB = flip(cofA);
        return cofA * a + cofB * b;
        
    }
    
    public static int sign(int a) {
        return flip((a >> 31) ^ 0);
    }
    
    public static int flip(int a) {
        return a ^ 1;
    }

3.   Implement +, -, *, / using bit operations. - New

Add: (a&b) << 1 不为零一直循环下去.

minus: add(a, getNeg(b));

times: a*2*b0 + a*4*b1 + a*8*b2 ... - Not Bug Free

divide: ans = add((1 << i), ans)或者 and |= (1 << i)都可以， 注意正负值. 注意当a = Integer.MIN_VALUE; (a+1)/c + (a-bc)/b; - Not Bug Free

    public static int add(int a, int b) {
        int c = 0;
        int d = 0;
        do {
            c = a ^ b;
            d = (a & b) << 1;
            a = c;
            b = d;
        }while (d != 0);
        return c;
    }
    
    public static int minus(int a, int b) {
        return add(a, getNeg(b));
    }
    
    public static int times(int a, int b) {
        int ans = 0;
        while (b != 0) {
            if ((b & 1) != 0) {
              ans = add(ans, a);  
            }   
            a <<= 1;
            b >>= 1;
        }
        return ans;
    }
    
    public static int divide(int a, int b) {
        if (b == 0) {
            throw new RuntimeException("divisor is 0");
        }
        if (a == Integer.MIN_VALUE && b == Integer.MIN_VALUE) {
            return 1;
        } else if (b == Integer.MIN_VALUE) {
            return 0;
        } else if (a == Integer.MIN_VALUE) {
            int c = divideHelper(add(a,1),b);
            return add(c, divideHelper(minus(a,times(c,b)),b));
        } else {
            return divideHelper(a, b);
        }
    }
    
    public static int divideHelper(int a, int b) {
        a = a < 0 ? getNeg(a) : a;
        b = b < 0 ? getNeg(b) : b;
        int ans = 0;
        for (int i = 31; i >= 0; i--) {
            if ((a >> i) < b) {
                continue;
            } else {
                ans = add((1 << i), ans);
                a = minus(a, (b << i));
            }
        }
        return (a < 0) ^ (b < 0) ? ans : getNeg(ans);
    }
    
    public static int numberOfOnes(int a) {
        int ans = 0;
        while (a != 0) {
            a &= (a-1);
            ans++;
        }
        return ans;
    }
    
    public static int getNeg(int a) {
        return add((~a), 1);
    }

4.   How many 1s in an integer - Not Bug Free

思路：n & (n-1)

    public static int numberOfOnes(int a) {
        int ans = 0;
        while (a != 0) {
            a &= (a-1);
            ans++;
        }
        return ans;
    }

5.   Odd occurance - Not Bug Free

思路：n & (n-1)

a ^ 0 = a; a ^ a = 0; a ^ b = b ^ a

    public static int OddOccurance(int[] nums) {
        int ans = 0;
        for (int i : nums) {
            ans ^= i;
        }
        return ans;
    }

Follow up question: two numbers have odd occurance. - Not Bug Free

思路：最后异或的结果a^b不为零，肯定有一位为1，找到那一位，然后和在那位为1的数去异或，最后得到的就是其中一个数。

    public static int[] twoOccurance(int[] nums) {
        int e0 = 0; 
        int e1 = 0;
        for (int i : nums) {
            e0 ^= i;
        }
        int one = e0 & (~e0 + 1);
        for (int i : nums) {
            if ((i & one) != 0) {
                e1 ^= i;
            }
        }
        int [] ans = new int[2];
        ans[0] = e1;
        ans[1] = e0 ^ e1;
        return ans;
    }

6.   Occure once among other K occurance. - Not Bug Free

In K-bit system, (a_1 ^ a_2 ^ a_3 ^ ...  ^ a_k)%k = 0.

思路：定义int[] e0, nums里面每一个数转化为KSystem，然后加上e0，最后剩下的数就是odd occurance. 再换成为10进制.  

   public static int kOccurance(int[] nums, int k) {
        int[] e0 = new int[32];
        for (int i = 0; i < nums.length; i++) {
            setExclusiveOr(e0, nums[i], k);
        }
        int ans = getNumFromKSystem(e0, k);
        return res;
    }
    
    public static void setExclusiveOr(int[] e0, int val, int k) {
        int[] curKSystem = getKSystemNumFromNum(val, k);
        for (int i = 0; i < e0.length; i++) {
            e0[i] = (e0[i] + curKSystem[i])%k;
        }
    }
    
    public static int getKSystemNumFromNum(int val, int k) {
        int[] curKSystem = new int[32];
        int i = 0;
        while (val > 0) {
            curKSystem[i++] = val%k;
            val /= k;
        }
        return curKSystem;
    }
    
    public static int getNumFromKSystem(int[] e0, int k) {
        int ans = 0;
        for (int i = e0.length - 1; i >= 0; i--) {
            ans = ans*k + e0[i];
        }
        return asn;
    }

7.   Flip Bits

Determine the number of bits required to flip if you want to convert integer n to integer m.

思路：先异或，1bit为different的地方，然后再求1的个数

public class Solution {
    public int bitSwapRequired(int m, int n) {
        int c = m ^ n;
        int ans = 0;
        while (c != 0) {
            c &= (c-1);
            ans++;
        }
        return ans;
    }
}

8.   Power of 2

Using O(1) time to check whether an integer n is a power of 2.

思路：利用n&(n-1)

public class Solution {
    public boolean checkPowerOf2(int n) {
        // write your code here
        if (n < 1) {
            return false;
        }
        return (n & (n-1)) == 0;
    }
}

9.   Trailing Zeros - Not Bug Free

Write an algorithm which computes the number of trailing zeros in n factorial.

2*5 can make 10. It can be broekn into product of primes. The number of 2s is equal or greater than number of 5s. Count the number of 5s.

class Solution {
    public int trailingZeroes(int n) {
        int count = 0;
        while(n > 0) {
            n /= 5;
            count += n;
        }

        return count;
    }
}

10.   Update Bits - Not Bug Free

Given two 32-bit numbers, N and M, and two bit positions, i and j. Write a method to set all bits between i and j in N equal to M (e g , M becomes a substring of N located at i and starting at j).

Walk backwards.

public class Solution {
    public int updateBits(int n, int m, int i, int j) {
        // write your code here
        int max = ~0;
        int left = 0;
        int right = 0;
        if (j < 31) {
            left = (1 << (j+1)) - 1;
        } else {
            left = max;
        }
        left = max - left;
        right = (1 << i) - 1;
        int mask = left | right;
        return (mask & n) | (m << i);
    }
}

11.   Fast power - Not Bug Free

Calculate the a^^n % b where a, b and n are all 32bit integers.

(a*b)%c = (a%c * b%c)%c. When n is odd, be careful.

坑：mid要为long以防溢出.

public class Solution {
    public int fastPower(int a, int b, int n) {
        // write your code here
        if (n == 0) {
            return 1%b;
        }
        if (n == 1) {
            return a%b;
        }
        long mid = fastPower(a, b, n/2);
        long ans = (mid * mid)%b;
        if (n%2 ==1) {
            ans = (a%b * ans%b)%b;
        }
        return (int)ans;
    }
}

12.   Binary Representation - Not Bug Free

Given a (decimal - e.g. 3.72) number that is passed in as a string, return the binary representation that is passed in as a string. If the fractional part of the number can not be represented accurately in binary with at most 32 characters, return ERROR.

坑：正数部分，小数部分长度均为32；

double rightVal = Double.valueOf(strs[1])/(Math.pow(10, strs[1].length()));

当right为“”时，不要‘.";

当str为"81";

小数部分先乘以2再判断.

public class Solution {
    public String binaryRepresentation(String str) {
        // write your code here
        String[] strs = str.split("\\.");
        int leftVal = Integer.valueOf(strs[0]);
        String left = getBinaryFromLeft(leftVal, 31);
        if (strs.length == 1) {
            return left;
        }
        double rightVal = Double.valueOf(strs[1])/(Math.pow(10, strs[1].length()));
        String right = getBinaryFromRight(rightVal, 31);
        if (left.equals("ERROR") || right.equals("ERROR")) {
            return "ERROR";
        }
        if (right.equals("")) {
            return left;
        }
        return left + "." + right;
    }
    
        public String getBinaryFromLeft(int val, int maxLen) {
        String ans = "";
        if (val == 0) {
            return "0";
        }
        while (val > 0 && maxLen >= 0) {
            ans = String.valueOf(val%2) + ans;
            val /= 2;
            maxLen--;
        }
        if (maxLen < 0) {
            return "ERROR";
        } else {
            return ans;
        }
    }
    
    public String getBinaryFromRight(double val, int maxLen) {
        String ans = "";
        if (val == 0) {
            return ans;
        }
        while (val != 0 && maxLen >= 0) {
            val *= 2;
            if (val < 1 && maxLen >= 0) {
                ans = ans + "0";
                maxLen--;
            }
            if (val >= 1 && maxLen >= 0) {
                ans = ans + "1";
                val -= 1;
                maxLen--;
            }
        }
        if (maxLen < 0) {
            return "ERROR";
        } else {
            return ans;
        }
    }
}

 13. Reverse Bits - 1st Not Bug Free

思路：先向左移动一位，再 | 结尾 bit。

public class Solution {
    // you need treat n as an unsigned value
    public int reverseBits(int n) {
        int res = 0;
        for (int i = 0; i < 32; i++) {
            res <<= 1;
            res |= (n & 1);
            n >>= 1;
        }
        return res;
    }
}

 14. Single Number II - 1st Not Bug Free

思路：我们可以建立一个32位的数字，来统计每一位上1出现的个数，我们知道如果某一位上为1的话，那么如果该整数出现了三次，对3去余为0，我们把每个数的对应位都加起来对3取余，最终剩下来的那个数就是单独的数字。

class Solution {
    public int singleNumber(int[] nums) {
        int res = 0;
        for (int i = 0; i < 32; i++) {
            int sum = 0;
            for (int j = 0; j < nums.length; j++) {
                sum += (nums[j] >> i) & 1;
            }
            res |= ((sum%3) << i);
        }
        return res;
    }
}

15. Single Number III - 1st Not Bug Free

思路：Once again, we need to use XOR to solve this problem. But this time, we need to do it in two passes:

In the first pass, we XOR all elements in the array, and get the XOR of the two numbers we need to find. Note that since the two numbers are distinct, so there must be a set bit (that is, the bit with value '1') in the XOR result. Find out an arbitrary set bit (for example, the rightmost set bit).

In the second pass, we divide all numbers into two groups, one with the aforementioned bit set, another with the aforementinoed bit unset. Two different numbers we need to find must fall into thte two distrinct groups. XOR numbers in each group, we can find a number in either group.

class Solution {
    public int[] singleNumber(int[] nums) {
        int diff = 0;
        for (int i : nums) {
            diff ^= i;
        }
        // find the rightmost 1-bit, which represents the different bit
        diff = diff & (-diff);
        int[] res = new int[2];
        for (int i : nums) {
            if ((i & diff) == 0) {
                res[0] ^= i;
            } else {
                res[1] ^= i;
            }
        }
        return res;
    }
}

16. Combination - 1st Not Bug Free

思路：比如有4个数，可以看成是1,0,1,0 代表只要第一个和第三个。bit 来做，看每一位是0还是1.

再加入对应的元素。

class Solution {
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0; i < (1 << nums.length); i++) {
            res.add(helper(nums, i));
        }
        return res;
    }
    
    public List<Integer> helper(int[] nums, int index) {
        List<Integer> items = new ArrayList<>();
        for (int i = 0; i < nums.length; i++) {
            if ((1 & index) == 1) {
                items.add(nums[i]);
            }
            index >>= 1;
        }
        return items;
    }
}