27. 移除元素

题目链接
状态：一遍过
思路：直接遍历一遍，若不等则改变

1
2
3
4
5
6
7
8
9
10
class Solution {
public:
    int removeElement(vector<int>& nums, int val) {
        int k = 0, n = nums.size();
        for (int i = 0; i < n; i++)
            if (nums[i] != val)
                nums[k++] = nums[i];
        return k;
    }
};

小结：此方法为双指针法或快慢指针法

26. 删除有序数组中的重复项

题目链接
状态：有思路但错了很多次
错误原因：下标范围错误，因为要考虑第一个元素的问题，判断错误

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int k = 1, n = nums.size();
        for (int i = 1; i < n; i++)
            if (nums[i]!= nums[k-1])
                nums[k++] = nums[i];
        return k;
    }
    int removeDuplicates1(vector<int>& nums) {
        int k = 0, n = nums.size();
        for (int i = 1; i < n; i++)
            if (nums[i]!= nums[k])
                nums[++k] = nums[i];
        return k+1;
    }
};

283. 移动零

题目链接
状态：一遍过
思路：双指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size();
        int j=0,sum=0;//
        for(int i=0;i<n;i++){
            if(nums[i]==0) sum++;
            else nums[j++]=nums[i];
        }
        for(int j=n-sum;j<n;j++){
            nums[j]=0;
        }
    }
};

精简代码

1
2
3
4
5
6
7
8
class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n=nums.size(),i=0,j=0;
        for(;i<n;i++) if(nums[i]!=0) nums[j++]=nums[i];
        while(j<n) nums[j++]=0;
    }
};

844. 比较含退格的字符串

题目链接
状态：有思路但未能实现
思路：还是使用双指针，从后往前分别遍历字符串。先处理退格符，使用count1来记录字符串s中‘#’个数，当s[m]==’#’, 若count1=0，则count++;m—; 当s[m]！=’#’,若count1>0,则count—,m—,此外返回；对t也进行同样操作；操作完成后若m和n仍然大于0，则可以进行比较，相同为true，否则都为false。

错误代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int m = s.length(), n = t.length();
        int bac;
        for (; m >= 0 && n >= 0; m--, n--) {
            bac=0;
            while (m >= 0) {
                if (s[m] == '#') {
                    bac++;m--;
                } else if (bac > 0) {
                    bac--;m--;
                } else
                    break;
            }
            bac=0;
            while (n >= 0) {
                if (t[n] == '#') {
                    bac++;n--;
                } else if (bac > 0) {
                    bac--;n--;
                } else
                    break;
            }
            if(s[m]!=t[n]||m<0||n<0) return false;
        }
        return true;
    }
};

修改意见
将s和t的bac分开计数，本来想着每次执行完会自动变为0，不影响后续操作，但其实也存在前者#过多导致后续t的初始不为0；
false判断出错，两种情况会返回false，
其一是两者可以比较且两者不同
其二是两者其中一方先比完

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int m = s.length()-1, n = t.length()-1;
        int back1=0,back2=0;
        for (; m >= 0 || n >= 0; m--, n--) {
            while (m >= 0) {
                if (s[m] == '#') {
                    back1++;
                    m--;
                } else if (back1 > 0) {
                    back1--;
                    m--;
                } else
                    break;
            }
            while (n >= 0) {
                if (t[n] == '#') {
                    back2++;
                    n--;
                } else if (back2 > 0) {
                    back2--;
                    n--;
                } else
                    break;
            }
            if(m>=0&&n>=0&&s[m]!=t[n]||(m >= 0) != (n >= 0)) return false;
        }
        return true;
    }
};

977. 有序数组的平方

题目链接
状态：使用sort直接排序
思路：先平方，再排序

1
2
3
4
5
6
7
8
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        for(int &n:nums) n*=n;
        sort(nums.begin(),nums.end());
        return nums;
    }
};

使用双指针，左右开弓，放到新数组中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n = nums.size();
        vector<int> res(n,0);
        int left = 0, right = n - 1, j = n - 1;
        while (left <= right) {
            if (nums[left] * nums[left] <= nums[right] * nums[right]){
                res[j--] = nums[right]* nums[right];
                right--;
            }
            else{
                res[j--] = nums[left]* nums[left];
                left++;
            }    
        }
        return res;
    }
};

209.长度最小的子数组

题目链接

  • 状态: 超时
  • 思路：暴力解超时
    错误代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int i,j,n=nums.size(),min=n+1,sublen=0,sum;
        for(i=0;i<n;i++){
            sum=0;
            for(j=i;j<n;j++){
                sum+=nums[j];
                if(sum>=target){
                    sublen=j-i+1;
                    min=sublen<min?sublen:min;
                    break;
                }
            }
        }
        if(min==n+1) return 0;
        else return min;
    }
};

正解：滑动窗口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Solution {
public:
    int minSubArrayLen(int target, vector<int>& nums) {
        int n = nums.size(), min = n + 1, sublen = 0, sum=0;
        int left = 0, right = 0;
        while (right < n) {
            sum += nums[right++];
            while (target <= sum) {
                sublen = right - left;
                min = min < sublen ? min : sublen;
                sum -= nums[left++];
            }
        }
        if(min==n+1) return 0;
        else return min;
    }
};

904. 水果成篮

题目链接
状态：这存两个数据不会熟练使用map
思路：滑动窗口

  1. 使用一个unordered_map（无序映射）来记录数组中每种水果出现的次数。
  2. 初始化三个变量：left和right作为两个指针，分别指向数组的开始和当前检查的位置；ans用来记录最大连续水果数量。
  3. 使用一个循环，right指针从0遍历到数组的末尾。
  4. 每次循环，增加当前fruits[right]水果的计数。
  5. 如果映射中的元素数量超过2，说明有三种或更多不同类型的水果，这时需要移动left指针，减少fruits[left]的计数，直到映射中的元素数量恢复到2或更少。
  6. 每次移动left指针后，如果fruits[left]的计数变为0，则从映射中删除这个水果的记录。
  7. 更新ans为当前窗口的最大长度，即right - left + 1。
  8. 循环结束后，返回ans作为结果。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
class Solution {
public:
    int totalFruit(vector<int>& fruits) {
        int n = fruits.size();
        unordered_map<int, int> cnt;
        int left = 0, right = 0, ans = 0;
        for (; right < n; right++) {
            cnt[fruits[right]]++;
            while (cnt.size() > 2) {
                cnt[fruits[left]]--;
                if (cnt[fruits[left]] == 0) {
                    cnt.erase(fruits[left]);
                }
                left++;
            }
            ans = max(ans, right - left + 1);
        }
        return ans;
    }
};

76. 最小覆盖子串

题目链接
难题不会
先存着以后水平高了再做

59.螺旋矩阵II

题目链接

54. 螺旋矩阵

题目链接

LCR 146. 螺旋遍历二维数组

题目链接