有點難度，幾道和「滑動窗口」有關的算法面試題

時間 2019-11-06

原文原文鏈接

前言科普：什麼是滑動窗口算法

滑動問題包含一個滑動窗口，它是一個運行在一個大數組上的子列表，該數組是一個底層元素集合。前端

假設有數組 [a b c d e f g h ]，一個大小爲 3 的 **滑動窗口** 在其上滑動，則有：算法

[a b c]
  [b c d]
    [c d e]
      [d e f]
        [e f g]
          [f g h]複製代碼

通常狀況下就是使用這個窗口在數組的 合法區間 內進行滑動，同時 動態地 記錄一些有用的數據，不少狀況下，可以極大地提升算法地效率。編程

1. 滑動窗口最大值

題目來源於 LeetCode 上第 239 號問題：滑動窗口最大值。題目難度爲 Hard，目前經過率爲 40.5% 。後端

題目描述

給定一個數組 nums，有一個大小爲 k 的滑動窗口從數組的最左側移動到數組的最右側。你只能夠看到在滑動窗口 k 內的數字。滑動窗口每次只向右移動一位。數組

返回滑動窗口最大值。數據結構

示例:測試

輸入: nums = [1,3,-1,-3,5,3,6,7], 和 k = 3
輸出: [3,3,5,5,6,7] 
解釋: 

  滑動窗口的位置                最大值
---------------               -----
[1  3  -1] -3  5  3  6  7       3
 1 [3  -1  -3] 5  3  6  7       3
 1  3 [-1  -3  5] 3  6  7       5
 1  3  -1 [-3  5  3] 6  7       5
 1  3  -1  -3 [5  3  6] 7       6
 1  3  -1  -3  5 [3  6  7]      7複製代碼

題目解析

利用一個 雙端隊列，在隊列中存儲元素在數組中的位置，而且維持隊列的嚴格遞減,，也就說維持隊首元素是 最大的 ，當遍歷到一個新元素時, 若是隊列裏有比當前元素小的，就將其移除隊列，以保證隊列的遞減。當隊列元素位置之差大於 k，就將隊首元素移除。動畫

補充：什麼是雙端隊列（Dqueue）

Deque 的含義是「double ended queue」，即雙端隊列，它具備隊列和棧的性質的數據結構。顧名思義，它是一種前端與後端都支持插入和刪除操做的隊列。spa

Deque 繼承自 Queue（隊列），它的直接實現有 ArrayDeque、LinkedList 等。指針

動畫描述

代碼實現

class Solution {
   public int[] maxSlidingWindow(int[] nums, int k) {
        //有點坑，題目裏都說了數組不爲空，且 k > 0。可是看了一下，測試用例裏面仍是有nums = [], k = 0，因此只好加上這個判斷
        if (nums == null || nums.length < k || k == 0) return new int[0];
        int[] res = new int[nums.length - k + 1];
        //雙端隊列
        Deque<Integer> deque = new LinkedList<>();
        for (int i = 0; i < nums.length; i++) {
            //在尾部添加元素，並保證左邊元素都比尾部大
            while (!deque.isEmpty() && nums[deque.getLast()] < nums[i]) {
                deque.removeLast();
            }
            deque.addLast(i);
            //在頭部移除元素
            if (deque.getFirst() == i - k) {
                deque.removeFirst();
            }
            //輸出結果
            if (i >= k - 1) {
                res[i - k + 1] = nums[deque.getFirst()];
            }
        }
        return res;
     }
}複製代碼

2. 無重複字符的最長子串

題目來源於 LeetCode 上第 3 號問題：無重複字符的最長子串。題目難度爲 Medium，目前經過率爲 29.0% 。

題目描述

給定一個字符串，請你找出其中不含有重複字符的 最長子串 的長度。

示例 1:

輸入: "abcabcbb"
輸出: 3 
解釋: 由於無重複字符的最長子串是 "abc"，因此其長度爲 3。複製代碼

題目解析

創建一個256位大小的整型數組 freg ，用來創建字符和其出現位置之間的映射。

維護一個滑動窗口，窗口內的都是沒有重複的字符，去儘量的擴大窗口的大小，窗口不停的向右滑動。

（1）若是當前遍歷到的字符從未出現過，那麼直接擴大右邊界；
（2）若是當前遍歷到的字符出現過，則縮小窗口（左邊索引向右移動），而後繼續觀察當前遍歷到的字符；
（3）重複（1）（2），直到左邊索引沒法再移動；
（4）維護一個結果res，每次用出現過的窗口大小來更新結果 res，最後返回 res 獲取結果。

動畫描述

代碼實現

// 滑動窗口
// 時間複雜度: O(len(s))
// 空間複雜度: O(len(charset))
class Solution {
public:
    int lengthOfLongestSubstring(string s) {
        int freq[256] = {0};
        int l = 0, r = -1; //滑動窗口爲s[l...r]
        int res = 0;
        // 整個循環從 l == 0; r == -1 這個空窗口開始
        // 到l == s.size(); r == s.size()-1 這個空窗口截止
        // 在每次循環裏逐漸改變窗口, 維護freq, 並記錄當前窗口中是否找到了一個新的最優值
        while(l < s.size()){
            if(r + 1 < s.size() && freq[s[r+1]] == 0){
                r++;
                freq[s[r]]++;
            }else {   //r已經到頭 || freq[s[r+1]] == 1
                freq[s[l]]--;
                l++;
            }
            res = max(res, r-l+1);
        }
        return res;
    }
};複製代碼

3. 存在重複元素 II

題目來源於 LeetCode 上第 219 號問題：存在重複元素 II。題目難度爲 Easy，目前經過率爲 33.9% 。

題目描述

給定一個整數數組和一個整數 k，判斷數組中是否存在兩個不一樣的索引 i 和 j，使得 nums [i] = nums [j]，而且 i 和 j 的差的絕對值最大爲 k。

示例 1:

輸入: nums = [1,2,3,1], k = 3
輸出: true複製代碼

示例 2:

輸入: nums = [1,0,1,1], k = 1
輸出: true複製代碼

示例 3:

輸入: nums = [1,2,3,1,2,3], k = 2
輸出: false複製代碼

題目解析

使用用滑動窗口與查找表來解決。

設置查找表record，用來保存每次遍歷時插入的元素，record 的最大長度爲k
遍歷數組nums，每次遍歷的時候在record 查找是否存在相同的元素，若是存在則返回true，遍歷結束
若是這次遍歷在record 未查找到，則將該元素插入到record 中，然後查看record 的長度是否爲k + 1
若是此時record 的長度是否爲k + 1，則刪減record的元素，該元素的值爲nums[i - k]
若是遍歷完整個數組nums未查找到則返回false

動畫描述

代碼實現

// 時間複雜度: O(n)
// 空間複雜度: O(k)
class Solution {
public:
    bool containsNearbyDuplicate(vector<int>& nums, int k) {
        if(nums.size() <= 1)  return false;
        if(k <= 0)  return false;
        unordered_set<int> record;
        for(int i = 0 ; i < nums.size() ; i ++){
            if(record.find(nums[i]) != record.end()){
                return true;
            }
            record.insert(nums[i]);
            // 保持record中最多有k個元素
            // 由於在下一次循環中會添加一個新元素,使得總共考慮k+1個元素
            if(record.size() == k + 1){
                record.erase(nums[i - k]);
            }
        }
        return false;
    }
};
複製代碼

4. 長度最小的子數組

題目來源於 LeetCode 上第 209 號問題：長度最小的子數組。題目難度爲 Medium，目前經過率爲 37.7% 。

題目描述

給定一個含有 n 個正整數的數組和一個正整數 s ，找出該數組中知足其和 ≥ s 的長度最小的連續子數組。若是不存在符合條件的連續子數組，返回 0。

示例:

輸入: s = 7, nums = [2,3,1,2,4,3]
輸出: 2
解釋: 子數組 [4,3] 是該條件下的長度最小的連續子數組。
複製代碼

題目解析

定義兩個指針 left 和 right ，分別記錄子數組的左右的邊界位置。

（1）讓 right 向右移，直到子數組和大於等於給定值或者 right 達到數組末尾；
（2）更新最短距離，將 left 像右移一位, sum 減去移去的值；
（3）重複（1）（2）步驟，直到 right 到達末尾，且 left 到達臨界位置

動畫描述

設置滑動窗口的長度爲 0 ，位於數軸的最左端。

1 .滑動窗口右端 R 開始移動，直到區間知足給定的條件，也就是和大於 7 ，此時中止於第三個元素 2，當前的最優長度爲 4

2. 滑動窗口左端 L 開始移動，縮小滑動窗口的大小，中止於第一個元素 3，此時區間和爲 6，使得區間和不知足給定的條件（此時不大於 7）

3. 滑動窗口右端 R 繼續移動，中止於第四個元素 4，此時和位 10 ，但最優長度仍然爲 4

代碼實現

// 滑動窗口的思路
// 時間複雜度: O(n)
// 空間複雜度: O(1)
class Solution {
    public int minSubArrayLen(int s, int[] nums) {
        int l= 0,r = -1;    // nums[l...r]爲咱們的滑動窗口
        int sum = 0;
        int result = nums.length + 1;
        while (l < nums.length){ // 窗口的左邊界在數組範圍內,則循環繼續

            if( r+1 <nums.length && sum < s){
                r++;
                sum += nums[r];
            }else { // r已經到頭 或者 sum >= s
                sum -= nums[l];
                l++;
            }

            if(sum >= s){
                result = (r-l+1) < result ? (r-l+1) : result ;
            }
        }
        if(result==nums.length+1){
            return 0;
        }
        return result;
    }
}複製代碼