数据结构与算法汇总整理篇——数组与字符串双指针与滑动窗口的联系学习及框架思考

数组

数组精髓：循环不变量原则

数组是存放在连续内存空间上的相同类型数据的集合，通过索引(下标)访问元素，索引从0开始

随机访问快(O(1)时间复杂度)；插入删除慢(需要移动元素)；长度固定(部分语言中可动态调整)

其存储列表数据，可用于实现栈和队列；多维数组用于矩阵运算；缓存数据(buffer)

二分查找

(先右再左，闭区间变化在右，右边界差异)：

(1)左闭右闭

(1) while (left <= right) 要使⽤ <= ，因为left == right是有意义的，所以使⽤ <=
(2) if (nums[middle] > target) right 要赋值为 middle - 1，因为当前这个nums[middle]⼀定不是target，那么接下来要查找的左区间结束下标位置就是 middle - 1

int search(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size() - 1; // 定义target在左闭右闭的区间⾥， [left, right]
    while (left <= right) { // 当left==right，区间[left, right]依然有效，所以⽤ <=
        int middle = left + ((right - left) / 2);// 防⽌溢出 等同于(left + right)/2
        if (nums[middle] > target) {
            right = middle - 1; // target 在左区间，所以[left, middle - 1]
        } else if (nums[middle] < target) {
            left = middle + 1; // target 在右区间，所以[middle + 1, right]
        } else { // nums[middle] == target
            return middle; // 数组中找到⽬标值，直接返回下标
        }
    }
    // 未找到⽬标值
    return -1;
}

(2)左闭右开

(1) while (left < right)，这⾥使⽤ < ,因为left == right在区间[left, right)是没有意义的
(2) if (nums[middle] > target) right 更新为 middle，因为当前nums[middle]不等于target，去左区间继续寻找，⽽寻找区间是左闭右开区间，所以right更新为middle，即：下⼀个查询区间不会去⽐较nums[middle]

int search(vector<int>& nums, int target) {
    int left = 0;
    int right = nums.size(); // 定义target在左闭右开的区间⾥，即： [left, right)
    while (left < right) { // 因为left == right的时候，在[left, right)是⽆效的空间，所以使⽤ <
        int middle = left + ((right - left) >> 1);
        if (nums[middle] > target) {
            right = middle;                 // target 在左区间，在[left, middle)中
        } else if (nums[middle] < target) {
            left = middle + 1;             // target 在右区间，在[middle + 1, right)中
        } else { // nums[middle] == target
            return middle;                 // 数组中找到⽬标值，直接返回下标
        }
    }
    return -1;
}

搜索插入位置

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int right = nums.size();
        int left = 0;
        int res = nums.size();

        while(left < right){
            
            int mid = left + ((right - left) >> 1);

            if(nums[mid] >= target){
                res = mid;
                right = mid;
            }else{
                left = mid +1;
            }
        }

        return res;
    }
};

在有序数组中查找元素的第一个和最后一个位置

class Solution {
   
public:
    vector<int> searchRange(vector<int>& nums, int target) {
        int n = nums.size();
        int left = 0, right = n-1;

        while(left <= right){
            int mid = left + ((right - left) >> 1);

            if(nums[mid] == target){
                int l = mid, r = mid;
                while(l>=0 && nums[l] == target) l--;
                while(r < n && nums[r] == target) r++;

                return {l+1, r-1};
            }else if( nums[mid] > target){
                right = mid - 1;
            }else{
                left = mid + 1;
            }
        }

        return { -1, -1};
    }
};

x的平方根

class Solution {
public:
    int mySqrt(int x) {
        int res = x;
        int left =0, right = x;
        
        while(left <= right){
            int mid = left + ((right - left) >> 1);

            if((long long)mid * mid <= x){  //往目标值靠近
                res =mid;
                left = mid + 1;
            }else{
               
                right = mid -1;   //收缩
            }
        }

        return res;
    }
};

有效的完全平方数

(开区间方法一般，容易缺失一些情况考虑)

class Solution {
public:
    bool isPerfectSquare(int num) {
        int left = 0, right = num;

        while(left <= right){

            int mid = left + ((right - left) >> 1);

            if((long)mid * mid < num){              
                left = mid + 1;
            }else if ((long)mid * mid > num){
                right = mid - 1;
            }else   
                return true;
        }

        return false;
    }
};

双指针

通过⼀个快指针和慢指针在⼀个for循环下完成两个for循环的⼯作

相向移动

有序数组的平方

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int len = nums.size();
        int index = len -1;
        vector<int> res(len,0);

        for(int i = 0, j = len -1; i <= j; ){                 // 取等防止遗漏数据
            if(nums[i] * nums[i] > nums[j] * nums[j]){        // 需要从后处理起
                res[index--] = nums[i] * nums[i];
                i++;
            }else{
                res[index--] = nums[j] * nums[j];
                j--;
            }
                
        }
        return res;
    }

    vector<int> sortedSquares2(vector<int>& nums) {
        
        nums[0] = nums[0] * nums[0];

        int j;
        for(int i = 1; i < nums.size(); i++){
            int tmp = nums[i] * nums[i];
            for(j = i-1; j >= 0; j--){
                if(tmp < nums[j])
                    nums[j+1] = nums[j]; // 大数往后插入
                else
                    break;    //进行一次即可
            }
            nums[j+1] = tmp;
        }

        return nums;
    }
};

同向移动

比较含退格的字符串

(退格问题也可以用栈完成)

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int sSkipNum = 0;
        int tSkipNum = 0;

        int i = s.size() -1;
        int j = t.size() - 1;

        while(1){
            while(i >= 0){
                if(s[i] == '#')
                    sSkipNum++;
                else{
                    if(sSkipNum) sSkipNum--;
                    else break;
                }
                i--;
            }

            while(j >= 0){
                if(t[j] == '#')
                    tSkipNum++;
                else{
                    if(tSkipNum) tSkipNum--;
                    else break;
                }
                j--;
            }

            if(i <0 || j < 0){  //长度不一
                break;
            }
            else if(s[i] != t[j])  //如果两个字符串相同，退格后也理应相同
                return false;

            i--;
            j--;
        }

        //同时遍历完毕
        if(i <0 && j < 0)
            return true;
        else
            return false;
    }
};

移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int len = nums.size(), left = 0, right = 0;

        // 右指针全遍历，左指针跟踪0
        while(right < len){
            if(nums[right]){
                swap(nums[left], nums[right]);
                left++;
            }

            right++;
        }
    }
};

删除有序数组中的重复项

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int slow = 1;   //跟踪数据
        int fast = 1;   //遍历

        for( ; fast < nums.size(); fast++){
            if(nums[fast] == nums[fast -1]){
                ;
            }

            if(nums[fast] != nums[fast-1]){
                nums[slow++] = nums[fast];
            }
        }

        return slow;
    }
};

移除元素

class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int slow = 0;  //收集结果
        int fast = 0;  //遍历

        for( ; fast < nums.size(); fast++){
            if(nums[fast] != val)
                nums[slow++] = nums[fast];
        }

        return slow;
    }
};

滑动窗口

就是不断的调节⼦序列的起始位置和终⽌位置，从⽽得出我们要想的结果

滑动窗⼝的精妙之处在于根据当前⼦序列和⼤⼩的情况，不断调节⼦序列的起始位置

方法论

int left = 0, right = 0;

while (right < s.size()) {
    // 增大窗口
    window.add(s[right]);
    right++;
    
    while (window needs shrink) {
        // 缩小窗口
        window.remove(s[left]);
        left++;
    }
}

窗口控制技巧：善于利用哈希表，这一数据结构。(哈希集合和哈希映射等)都可以做窗口

(第一层遍历右边界，第二层遍历左边界) 可以用哈希表来处理第二层的边界！

void slidingWindow(string s, string t) {
    unordered_map<char, int> need, window;
    for (char c : t) need[c]++;
    
    int left = 0, right = 0;
    int valid = 0; 
    while (right < s.size()) {
        // c 是将移入窗口的字符
        char c = s[right];
        // 右移窗口
        right++;
        // 进行窗口内数据的一系列更新
        ...

        /*** debug 输出的位置 ***/
        printf("window: [%d, %d)\n", left, right);
        /********************/
        
        // 判断左侧窗口是否要收缩
        while (window needs shrink) {
            // d 是将移出窗口的字符
            char d = s[left];
            // 左移窗口
            left++;
            // 进行窗口内数据的一系列更新
            ...
        }
    }
}

长度最小的子数组

class Solution {
    public:
        int minSubArrayLen(int s, vector<int>& nums) {
            int result = INT32_MAX;
            int sum = 0; // 滑动窗⼝数值之和
            int i = 0; // 滑动窗⼝起始位置
            int subLength = 0; // 滑动窗⼝的⻓度
            for (int j = 0; j < nums.size(); j++) {
                sum += nums[j];
                // 注意这⾥使⽤while，每次更新 i（起始位置），并不断⽐较⼦序列是否符合条件
                while (sum >= s) {
                    subLength = (j - i + 1); // 取⼦序列的⻓度
                    result = result < subLength ? result : subLength;
                    sum -= nums[i++]; // 这⾥体现出滑动窗⼝的精髓之处，不断变更i（⼦序列的起始位置）
                }
            }
            // 如果result没有被赋值的话，就返回0，说明没有符合条件的⼦序列
            return result == INT32_MAX ? 0 : result;
        }
};

水果成篮

class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        vector<int> tree(100001, 0);
        int kind = 0;

        int left = 0;
        int res = 0;
        
        for(int right = 0; right < n; right++){
            tree[fruits[right]]++;
            if(tree[fruits[right]] == 1)
                kind++;

            while(kind > 2){   // 开始滑动
                tree[fruits[left]]--;
                if(tree[fruits[left]] == 0)
                    kind--;
                left++;    //子序列起始位置
            }

            res = max(res, right - left + 1);
        }

        return res == 0 ? 0 : res;
    }
};

(右边界移动，左边界不动，左边界移动，右边界不动)

(右边界先移动，找到满足条件，左边界压缩搜索,最优解产生在左边界向右移动过程中)

最小覆盖子串

(s 中覆盖 t)

class Solution {
public:
    string minWindow(string s, string t) {
      unordered_map<char, int> tmap, smap;
      int left = 0, correct = 0;
      string res = s;

      for(char item : t){
        tmap[item]++;
      }

     for(int right = 0; right < s.size(); ++right){
        smap[s[right]]++;   //顺便统计词频

        if(tmap[s[right]] >= smap[s[right]])  //当前字符的词频
            ++correct;

         while(smap[s[left]] > tmap[s[left]])   //左边界索引的词频
            --smap[s[left++]];  //同时左边界右移

        if(correct == t.size()){
            res = right - left +1 < res.size() ? s.substr(left, right - left +1) : res;
        }
        
     }

    return correct == t.size()? res : "";
    }
};

无重复字符的最长子串

class Solution {
public:
    int lengthOfLongestSubstring(string& s) {
        unordered_map<char, int> hash_map;   //char2index

        int left = -1, res = 0, len = s.size();
        for(int i = 0; i < len; i++){
            if(hash_map.find(s[i]) != hash_map.end())
                left = max(left, hash_map.find(s[i])->second);  //find 返回迭代器
            hash_map[s[i]] = i;                                 //记录字符的索引值
            res = max(res, i-left);
        }

        return res;
    }
};

多维数组模拟

螺旋矩阵II

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        vector<vector<int>> res(n, vector<int>(n,0));
        int count = 0;
        int loop = n/2;
        int mid = n/2;
        int startx = 0, starty = 0;

        int offset = 1;
        while(loop--){   //圈数
            int i = startx;
            int j = starty;

            for( ; j < n-offset; j++)
                res[i][j] = ++count;    //向右

            for(; i < n -offset; i++)
                res[i][j] = ++count;    //向下

            for( ; j > starty; j--)
                res[i][j] = ++count;    //向左

            for(; i > startx; i--)
                res[i][j] = ++count;    //向上


            startx++;
            starty++;
            offset++;

        }

        if(n%2)
            res[mid][mid] = ++count;

        return res;
    }

    vector<vector<int>> generateMatrix2(int n) {
        vector<vector<int>> res(n, vector<int>(n, 0));
        int top = 0, right = n -1, left = 0, bottom = n -1;
        int count = 0;

        while(true){

            for(int i =left; i <= right; ++i) res[top][i] = ++count;
            if(++top > bottom) break;   // 收缩边界
            for(int i =top; i <= bottom; ++i) res[i][right] = ++count;
            if(--right < left) break;
            for(int i = right; i >= left; --i) res[bottom][i] = ++count;
            if(--bottom < top) break;
            for(int i = bottom;  i>= top; --i) res[i][left] = ++count;
            if(++left > right) break;
        }

        return res;
    }
};

旋转矩阵

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();

        //水平rotate
        for(int i = 0; i < n/2; ++i){
            for(int j = 0; j < n; ++j){
                swap(matrix[i][j], matrix[n-1-i][j]);
            }
        }

        //主对角线rotate
        for(int i = 0; i< n; ++i){
            for(int j = 0; j<i; ++j){
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }

    void rotate2(vector<vector<int>>& matrix) {
        int n = matrix.size();

        for(int i = 0; i< n/2; i++){
            for(int j = 0; j < (n+1)/2; j++){
                swap(matrix[i][j], matrix[j][n-i-1]);
                swap(matrix[i][j], matrix[n-i-1][n-j-1]);
                swap(matrix[i][j], matrix[n-j-1][i]);
            }
        }
    }
};

字符串

字符串本质：近似为包含结束符的字符数组，字符的有序序列，用于文本数据。字符串通常是不可变的(immutable)

反转操作系列

关于交换

/* 数值交换 */
int tmp = s[i];
s[i] = s[j];
s[j] = tmp;

/* 位运算 异或运算 */
s[i] ^= s[j];
s[j] ^= s[i];
s[i] ^= s[j];

反转字符串II

class Solution {
    private:
        void myrever(string& s, int start, int end){
            for(int i = start, j = end; i<j; i++, j--){
                s[i] ^= s[j];
                s[j] ^= s[i];
                s[i] ^= s[j];
            }
        }
public:
    string reverseStr(string s, int k) {
        int len = s.size();

        for(int i = 0; i < len; i += 2*k){

            if(i + k < len){
                myrever(s, i, i+k-1);
            }else{
                myrever(s, i, len-1);
            }
        }

        return s;
    }
};

移除多余空格 (双指针)

void removeExtraSpaces(string& s) {//去除所有空格并在相邻单词之间添加空格, 快慢指针。
    int slow = 0;
    for (int i = 0; i < s.size(); ++i) { 
        if (s[i] != ' ') { //遇到⾮空格就处理，即删除所有空格。
            if (slow != 0) s[slow++] = ' '; //⼿动控制空格，给单词之间添加空格。 slow != 0说明不是第⼀个单词，需要在单词前添加空格。
            while (i < s.size() && s[i] != ' ') { //补上该单词，遇到空格说明单词结束。
                s[slow++] = s[i++];
            }
        }
    }
    s.resize(slow); //slow的⼤⼩即为去除多余空格后的⼤⼩。
}

反转字符串中的单词

class Solution {
    private:
        void my_rever(string& s, int start, int end){
            for(int i = start, j =end; i < j; i++, j--){
                swap(s[i], s[j]);
            }
        }

        void removeSpaces(string& s){
            int slow = 0;

            for(int fast = 0; fast < s.size(); fast++){

                if(s[fast] != ' '){
                    if(slow != 0) s[slow++] = ' ';   //中间补充单词间隔

                    while(fast < s.size() && s[fast] != ' ') //内循环需要控制边界
                        s[slow++] = s[fast++];
                }
            }

            s.resize(slow);
        }
public:
    string reverseWords(string s) {
        removeSpaces(s);
        my_rever(s, 0, s.size()-1);

        int word_start = 0;
        for(int i = 0; i <= s.size(); i++){   // 左闭右闭区间
            if(i == s.size() || s[i] == ' '){
                my_rever(s, word_start, i-1); //翻转，是左闭右闭 []的翻转。
                word_start = i+1;
            }
        }

        return s;
    }
};

动态口令

(整体反转 + 局部反转)

class Solution {
    private:
        void str_reverse(string& s, int start, int end){
            for(int i = start, j = end; i < j; i++, j--){
                s[i] ^= s[j];
                s[j] ^= s[i];
                s[i] ^= s[j];
            }
        }
public:
    string dynamicPassword(string password, int target) {
        int len = password.size();
        
        str_reverse(password, 0, target-1);
        str_reverse(password, target, len-1);
        str_reverse(password, 0, len-1);

        return password;
    }
};