LeetCode Week 1数组

常规题

• 283. 移动零
• 27. 移除元素
• 26. 删除有序数组中的重复项
• 80. 删除有序数组中的重复项 II

class Solution {
    public int removeDuplicates(int[] nums) {
        int n = nums.length;
        if (n < 2) {
            return n;
        }
        int slow = 2, fast = 2;
        while(fast < n) {
            if(nums[fast] != nums[slow-2]) {
                nums[slow] = nums[fast];
                slow++;
            }
            fast++;
        }
        return slow;
    }
}

• 75. 颜色分类
• 88. 合并两个有序数组
• 215. 数组中的第K个最大元素

对撞指针

• 167. 两数之和 II - 输入有序数组

class Solution {
    public int[] twoSum(int[] numbers, int target) {
        int i = 0, j = numbers.length - 1;
        while (i < j) {
            if (numbers[i] < target - numbers[j]) {
                i++;
            } else if (numbers[i] > target - numbers[j]) {
                j--;
            } else {
                return new int[]{i + 1, j + 1};
            }
        }
        return new int[0];
    }
}

• 125. 验证回文串
• 344. 反转字符串
• 345. 反转字符串中的元音字母
• 11. 盛最多水的容器

class Solution {
    public int maxArea(int[] height) {
        int i = 0, j = height.length - 1;
        int max = 0;
        while (i < j) {
            int h = Math.min(height[i], height[j]);
            int w = j - i;
            max = Math.max(max, h * w);
            if(height[i] <= height[j]) {
                i++;
            } else {
                j--;
            }
        }
        return max;
    }
}

滑动窗口

• 209. 长度最小的子数组

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        //假设滑动窗口[l...r]
        int l = 0, r = -1;
        int res = nums.length + 1;
        int sum = 0;
        while (l < nums.length) {
            if (r + 1 < nums.length && sum < target) {
                sum += nums[++r];
            } else {
                sum -= nums[l++];
            }

            if (sum >= target) {
                res = Math.min(res, r - l + 1);
            }
        }

        return res == nums.length + 1 ? 0 : res;
    }
}

• 3. 无重复字符的最长子串

class Solution {
    public int lengthOfLongestSubstring(String s) {
        //假设滑动窗口[l...r]为无重复子串
        int l = 0, r = -1;
        int res = 0;
        //int数组实现字符频率计数
        int[] freq = new int[256];
        while (l < s.length()) {
            if (r + 1 < s.length() && freq[s.charAt(r+1)] == 0) {
                freq[s.charAt(++r)]++;
            } else {
                freq[s.charAt(l++)]--;
            }

            res = Math.max(res, r - l + 1);
        }

        return res;
    }
}

• 438. 找到字符串中所有字母异位词

class Solution {
    public List<Integer> findAnagrams(String s, String p) {
        int n = s.length(), m = p.length();
        List<Integer> res = new ArrayList<>();
        if (n < m) return res;
        int[] pCnt = new int[26];
        int[] sCnt = new int[26];
        for (int i = 0; i < m; i++) {
            pCnt[p.charAt(i) - 'a']++;
            sCnt[s.charAt(i) - 'a']++;
        }
        if (Arrays.equals(sCnt, pCnt)) {
            res.add(0);
        }
        for (int i = m; i < n; i++) {
            sCnt[s.charAt(i - m) - 'a']--;
            sCnt[s.charAt(i) - 'a']++;
            if (Arrays.equals(sCnt, pCnt)) {
                res.add(i - m + 1);
            }
        }
        return res;
    }
}

• 76. 最小覆盖子串

class Solution {
    Map<Character, Integer> ori = new HashMap<Character, Integer>();
    Map<Character, Integer> cnt = new HashMap<Character, Integer>();

    public String minWindow(String s, String t) {
        int tLen = t.length();
        for (int i = 0; i < tLen; i++) {
            char c = t.charAt(i);
            ori.put(c, ori.getOrDefault(c, 0) + 1);
        }
        int l = 0, r = -1;
        int len = Integer.MAX_VALUE, ansL = -1, ansR = -1;
        int sLen = s.length();
        while (r < sLen) {
            ++r;
            if (r < sLen && ori.containsKey(s.charAt(r))) {
                cnt.put(s.charAt(r), cnt.getOrDefault(s.charAt(r), 0) + 1);
            }
            while (check() && l <= r) {
                if (r - l + 1 < len) {
                    len = r - l + 1;
                    ansL = l;
                    ansR = l + len;
                }
                if (ori.containsKey(s.charAt(l))) {
                    cnt.put(s.charAt(l), cnt.getOrDefault(s.charAt(l), 0) - 1);
                }
                ++l;
            }
        }
        return ansL == -1 ? "" : s.substring(ansL, ansR);
    }

    public boolean check() {
        Iterator iter = ori.entrySet().iterator();
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();
            Character key = (Character) entry.getKey();
            Integer val = (Integer) entry.getValue();
            if (cnt.getOrDefault(key, 0) < val) {
                return false;
            }
        }
        return true;
    }
}