算法学习———数组（Java版）

leetcode本周刷题路线：

数组题常用方法：双指针、滑动窗口

---

27. 移除元素（简单）：

        题目描述：

        给你一个数组 nums 和一个值 val，你需要原地移除所有数值等于 val 的元素，并返回移除后数组的新长度。不要使用额外的数组空间，你必须仅使用 O(1) 额外空间并原地修改输入数组。元素的顺序可以改变。你不需要考虑数组中超出新长度后面的元素。

        示例：

                输入：nums = [3,2,2,3], val = 3
                输出：2, nums = [2,2]
        解释：函数应该返回新的长度 2, 并且 nums 中的前两个元素均为 2。你不需要考虑数组中超出新长度后面的元素。例如，函数返回的新长度为 2 ，而 nums = [2,2,3,3] 或 nums = [2,2,0,0]，也会被视作正确答案。

        解题思路：双指针法

        设置两个指针 left，right 分别指向数组左右两端，从 left 处遍历数组，若检测到当前 left 处元素的值与目标值相等，则和 right 处元素的值交换，然后 left、right 指针同时向对方方向移动一位。若 right 移动一位后该位置元素的值与目标值相等，则继续移动移动一步，直至 right 位置的值不是目标值。重复进行上述操作直至 left 与 right 相交，left 的值即为所求数组的长度。

        解题代码：

class Solution {
    public int removeElement(int[] nums, int val) {
        int length = nums.length;
        int left = 0;
        int right = length - 1;
        int temp = 0;
        for(int i = 0; left <= right; i ++){
            if(nums[right] == val){
                continue;
            }
            if(nums[left] == val){
                temp = nums[right];
                nums[right] = nums[left];
                nums[left] = temp;
                right --;
                left ++;
            }
            else{
                left ++;
            }
        }
        return left;
    }
}

---

---

977.有序数组的平方（简单）：

        题目描述：

        给你一个按非递减顺序排序的整数数组 nums，返回每个数组的平方组成的新数组，要求也按非递减顺序排序。

        示例：

                输入：nums = [-4,-1,0,3,10]
                输出：[0,1,9,16,100]
        解释：平方后，数组变为 [16,1,0,9,100]；排序后，数组变为 [0,1,9,16,100]

        解题思路：双指针法

        设置两个指针 left，right 分别指向 nums 数组的左右两端。

        由于 nums 数组已排好序，因此只需考虑 left 位置元素的平方是否大于 right 位置元素的平方。为了方便操作，可以建立一个数组 pow 存放平方后的元素，存放时从数组末尾开始。

        解题代码：

class Solution {
    public int[] sortedSquares(int[] nums) {
        int left = 0;
        int right = nums.length - 1;
        int[] pow = new int[nums.length];
        int index = nums.length - 1;
        while(left <= right){
            if(nums[left] * nums[left] < nums[right] * nums[right]){
                pow[index] = nums[right] * nums[right];
                right --;
                index --;
            }
            else{
                pow[index] = nums[left] * nums[left];
                left ++;
                index --;
            }
        }
        return pow;
    }
}

---

---

209.长度最小的子数组（中等）：

        题目描述：

        给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 >= target 的长度最小的 连续子数组  [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。

        如果不存在符合条件的子数组，返回 0 。

        示例：

                输入：target = 7, nums = [2,3,1,2,4,3]

                输出：2

        解释：子数组 [4,3] 是该条件下的长度最小的子数组。

        解题思路：滑动窗口

        变量 len、sum、left、right 分别为最小窗口长度、窗内元素之和、窗口左端、窗口右端。

        从数组第一个元素开始扩大窗口，即 right 从零开始遍历，将遍历到的元素值相加并存放于变量 sum 中。当 sum >= target时，进行窗口缩小操作，即将 left 向后移动，并将当前窗口长度（right - left + 1）和 len 相比，更新 len 的大小，直到 sum < target 时，再进行扩大窗口的操作。重复上面操作直至 right 遍历到数组末端且此时的 sum >= target，此时 len 所存放的值即为长度最小的子数组。

        解题代码：

class Solution {
    public int minSubArrayLen(int target, int[] nums) {
        int len = Integer.MAX_VALUE;
        int sum = 0;
        int left = 0;
        for(int right = 0; right < nums.length; right ++){
            sum += nums[right];
            while(sum >= target){
                len = Math.min(len, right - left + 1);
                sum -= nums[left ++];
            }
        }
        return len == Integer.MAX_VALUE ? 0 : len;
    }
}

---

---

76. 最小覆盖子串（困难）：

        题目描述：

        给你一个字符串 s、一个字符串 t。返回 s 中涵盖 t 中所有字符的最小子串。 如果 s 中不存在涵盖 t 所有的子串，则返回空字符串 “”。

        示例：

                输入：s = "ADOBECODEBANC", t = "ABC"

                输出："BANC"

                输入: s = "a", t = "aa"

                输出: ""

        解释: t 中两个字符 'a' 均应包含在 s 的子串中，因此没有符合条件的子字符串，返回空字符串。

        解题思路：滑动窗口、哈希表

        本题哈希表用法：字母作为键，该字母的数量作为值，即记录每个字母出现的次数。

        先用建立一个哈希表 cover 记录 t 中每个字母出现的次数，再建立一个哈希表 window 用于记录窗口内每个字母的数量。当 window 内包含了 cover 中的所有字母且数量相等时，更新最小窗口长度并进行缩小窗口操作，即窗口从左端开始缩小，直到 window 中包含的 cover 中的字符数量不相等后，再进行扩大窗口操作，以此类推，最终得出最小窗口的大小。

        解题代码：

class Solution {
    public String minWindow(String s, String t) {
        if(s.length() < t.length())
            return "";
        HashMap<Character, Integer> cover = new HashMap<>();
        HashMap<Character, Integer> window = new HashMap<>();
        int miniLen = Integer.MAX_VALUE;
        int left = 0, right = 0;
        int winLeft = 0;
        int count = 0;
        for(int i = 0; i < t.length(); i ++) {
        	cover.put(t.charAt(i), cover.getOrDefault(t.charAt(i), 0) + 1);
        }
        while(right < s.length()) {
        	char ch = s.charAt(right);
        	right ++;
        	window.put(ch, window.getOrDefault(ch, 0) + 1);
        	if(window.get(ch).equals(cover.get(ch)))
        		count ++;
        	while(count == cover.size()) {
        		if(right - left < miniLen) {
        			miniLen = right - left;
        			winLeft = left;
        		}
        		char c = s.charAt(left);
        		if(window.get(c).equals(cover.get(c)))
        			count --;
        		window.put(c, window.get(c) - 1);
        		left ++;
        	}
        }
        return miniLen == Integer.MAX_VALUE ? "" : s.substring(winLeft, winLeft + miniLen);
    }
}

---

---

学习心得：

        二分查找、双指针和滑动窗口是数组类算法题常见的解法，基本思想并不难，但是把他用对用好很难，就比如 209.长度最小的子数组 运用了滑动窗口的方法，我首次做出 209.长度最小的子数组 这道题时所运用的活动窗口的解法执行用时达到了2000多毫秒，在看了其他人的解法后，发现与我的思路完全一致，但在结合了哈希表之后，算法效率却高了不少。我也发现了我的不足——缺乏综合思维能力，不能很好的将所学知识结合起来解决问题，题量太少占有很大一部分原因。

        继续加油吧！