1.leetcode-59. 螺旋矩阵 II
（题2.题3相当于二分变形）
2.leetcode-33. 搜索旋转排序数组
3.leetcode-81. 搜索旋转排序数组 II(与题目2对比理解)
（题4和题5都是排序+双指针）
4.leetcode-15. 三数之和
5.leetcode-18. 四数之和
6.leetcode-80. 删除有序数组中的重复项 II
（通解方法）

1.leetcode-59. 螺旋矩阵 II

（1）题目描述
给你一个正整数 n ，生成一个包含 1 到 n2 所有元素，且元素按顺时针顺序螺旋排列的 n x n 正方形矩阵 matrix 。
在这里插入图片描述
（2）方法与思路（模拟）
1.首先明白螺旋矩阵的拐点是在哪里，并且在旋转一周后边界值会有哪些变化。
2.先定义四个变量，分别来表示这个正方形的上左下右的边界值。
3.走完一条边就要将这条边减去一。
4.终止条件就是数组元素所给值达到n*n。
（3）代码实现

class Solution {
public:
    vector<vector<int>> generateMatrix(int n) {
        int t = 0;      // top
        int b = n-1;    // bottom
        int l = 0;      // left
        int r = n-1;    // right
        vector<vector<int>> ans(n,vector<int>(n));
        int k=1;
        while(k<=n*n){
            for(int i=l;i<=r;++i,++k) ans[t][i] = k;
            ++t;
            for(int i=t;i<=b;++i,++k) ans[i][r] = k;
            --r;
            for(int i=r;i>=l;--i,++k) ans[b][i] = k;
            --b;
            for(int i=b;i>=t;--i,++k) ans[i][l] = k;
            ++l;
        }
        return ans;
    }
};

（题2.题3相当于二分变形）

2.leetcode-33. 搜索旋转排序数组

（1）题目描述
整数数组 nums 按升序排列，数组中的值互不相同。
在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …, nums[k-1]]（下标从 0 开始计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。
给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。
你必须设计一个时间复杂度为 O(log n) 的算法解决此问题。
在这里插入图片描述
（2）方法及思路（二分查找）（虽然可以直接查找但是还是多练练吧，嘻嘻）
先上图

由此图可以看出分两种不同情况（在由mid第一次分开后）
1.target落在左（右）半部分有序部分中。
2.target还是落在错位的区间（即不有序），那就在while循环中进行再分。但是要更新左右的值
（如果左半部分不是有序，那右半部分必有序，反之也一样）
（3）代码实现

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = (int)nums.size();
        if (!n) {
            return -1;
        }
        if (n == 1) {
            return nums[0] == target ? 0 : -1;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] == target) return mid;
            if (nums[0] <= nums[mid]) {
                if (nums[0] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return -1;
    }
};

3.leetcode-81. 搜索旋转排序数组 II(与题目2对比理解)

（1）其他条件与上题相同，唯有此题中数组是非降序。
在这里插入图片描述
（2）方法与思路（二分查找）
思路
1.对于数组中有重复元素的情况，二分查找时可能会有 a[l]=a[mid]=a[r]，此时无法判断区间 [l,mid] 和区间 [mid+1,r] 哪个是有序的。

2.例如 nums=[3,1,2,3,3,3,3]，target=2，首次二分时无法判断区间 [0,3][0,3][0,3] 和区间 [4,6][4,6][4,6] 哪个是有序的。

3.对于这种情况，我们只能将当前二分区间的左边界加一，右边界减一，然后在新区间上继续二分查找。
（3）代码实现

class Solution {
public:
    bool search(vector<int> &nums, int target) {
        int n = nums.size();
        if (n == 0) {
            return false;
        }
        if (n == 1) {
            return nums[0] == target;
        }
        int l = 0, r = n - 1;
        while (l <= r) {
            int mid = (l + r) / 2;
            if (nums[mid] == target) {
                return true;
            }
            if (nums[l] == nums[mid] && nums[mid] == nums[r]) {
                ++l;
                --r;
            } else if (nums[l] <= nums[mid]) {
                if (nums[l] <= target && target < nums[mid]) {
                    r = mid - 1;
                } else {
                    l = mid + 1;
                }
            } else {
                if (nums[mid] < target && target <= nums[n - 1]) {
                    l = mid + 1;
                } else {
                    r = mid - 1;
                }
            }
        }
        return false;
    }
};

（题4和题5都是排序+双指针）

4.leetcode-15. 三数之和

（1)题目描述
给你一个整数数组 nums ，判断是否存在三元组 [nums[i], nums[j], nums[k]] 满足 i != j、i != k 且 j != k ，同时还满足 nums[i] + nums[j] + nums[k] == 0 。请
你返回所有和为 0 且不重复的三元组。
注意：答案中不可以包含重复的三元组。
在这里插入图片描述
(2)方法与思路（排序+双指针）
1.对数组进行排序。
2.遍历排序后数组：
若 nums[i]>0：因为已经排序好，所以后面不可能有三个数加和等于 0，直接返回结果。
对于重复元素：跳过，避免出现重复解

3.令左指针 L=i+1，右指针 R=n−1，当 L<R时，执行循环：

4.当 nums[i]+nums[L]+nums[R]==0，执行循环，判断左界和右界是否和下一位置重复，去除重复解。并同时将 L,RL,RL,R 移到下一位置，寻找新的解
若和大于 0，说明 nums[R]太大，R 左移
若和小于 0，说明 nums[L] 太小，L 右移

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        int n=nums.size();
        sort(nums.begin(),nums.end());
        vector<vector<int>> ans;
        for(int first=0;first<n;++first)
        {
            if(first>0&&nums[first-1]==nums[first])
            {
                continue;
            }
            int third=n-1;
            for(int second=first+1;second<n;second++)
            {
                if(second>first+1&&nums[second-1]==nums[second])
                {
                    continue;
                }
                while(second < third &&nums[first]+nums[second]+nums[third]>0)
                {
                    third--;
                }
                if(second==third)
                {
                    break;
                }
                 if (nums[first]+nums[second] + nums[third] == 0) {
                    ans.push_back({nums[first], nums[second], nums[third]});
                }
            }
        }
        return ans;
    }
};

5.leetcode-18. 四数之和

（1）题目简述
给你一个由 n 个整数组成的数组 nums ，和一个目标值 target 。请你找出并返回满足下述全部条件且不重复的四元组 [nums[a], nums[b], nums[c], nums[d]] （若两个四元组元素一一对应，则认为两个四元组重复）：
在这里插入图片描述
（2）方法及思路（排序+双指针）
1.首先要定义四个指针first=0, second=first+1, third=second+1, forth=n-1(这是四个指针的初始位置)，后续过程还要进行循环。
2.其次是对于重复元素的处理（切记要放在循环当中，否则只能除掉一个重复，尤其是third）
3.接着是对于结果的排查，如果结果小于0，third右移，如果结果大于0，forth左移。
4.最后将找到的值插入新的数组中。

（3）代码实现

class Solution
{
public:
	vector<vector<int>> fourSum(vector<int>& num, int target)
	{
		vector<vector<int>>  newnum;
		sort(num.begin(), num.end());
		int n = num.size();
		for (int first = 0; first < n; ++first)
		{
			if (first > 0 && num[first] == num[first - 1])
				continue;
			for (int second = first + 1; second < n; ++second)
			{
				if (second > first + 1 && num[second] == num[second - 1])
					continue;
				int third = second + 1;
				int forth = n - 1;
				long long target_c = (long long)target - num[first] - num[second];
				while (third < forth)
				{
					if (target_c == num[third] + num[forth]) {
						newnum.push_back({ num[first], num[second], num[third], num[forth] });
						do {
							third++;
						} while (third < n && num[third] == num[third - 1]);
					}
					else if (target_c > num[third] + num[forth])
					{
						third++;
					}
					else
						forth--;
				}
			}
		}
		return newnum;
	}
};

6.leetcode-80. 删除有序数组中的重复项 II

(1)题目描述
给你一个有序数组 nums ，请你原地删除重复出现的元素，使得出现次数超过两次的元素只出现两次，返回删除后数组的新长度。
不要使用额外的数组空间，你必须在原地修改输入数组并在使用 O(1) 额外空间的条件下完成。
在这里插入图片描述
（2）方法及思路（双指针）
1.首先定义slow和fast位于第三个位置
2.如果slow-2和fast的元素相同，fast++
3.如果slow-2和fast不同，将slow处的元素替换为fast处的元素，并且和fast一起往前移。
（3）代码实现

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

（通解方法）

为了让解法更具有一般性，我们将原问题的「保留 2 位」修改为「保留 k 位」。
由于是保留 k 个相同数字，对于前 k 个数字，我们可以直接保留
对于后面的任意数字，能够保留的前提是：与当前写入的位置前面的第 k 个元素进行比较，不相同则保留
举个例子🌰[1,1,1,1,1,1,2,2,2,2,2,2,3]
1.首先我们先让前 2 位直接保留，得到 1,1
2.对后面的每一位进行继续遍历，能够保留的前提是与当前位置的前面 k 个元素不同（答案中的第一个 1），因此我们会跳过剩余的 1，将第一个 2 追加，得到 1,1,2
3.继续这个过程，这时候是和答案中的第 2 个 1 进行对比，因此可以得到 1,1,2,2
4.这时候和答案中的第 1 个 2 比较，只有与其不同的元素能追加到答案，因此剩余的 2 被跳过，3 被追加到答案：1,1,2,2,3
代码实现

class Solution {
public:
    int work(vector<int>& nums, int k) {
        int len = 0;
        for(auto num : nums)
            if(len < k || nums[len-k] != num)
                nums[len++] = num;
        return len;
    }
    int removeDuplicates(vector<int>& nums) {
        return work(nums, 2);
    }
};