力扣刷题笔记：数组（13）

11. 盛最多水的容器（双指针）

两个指针从两头开始搜索，记录当前最大容量，左右指针哪边高度低移动哪边

    int maxArea(vector<int>& height) {
		int n =height.size(), l=0, r=height.size()-1，ans = 0;
		//双指针法，从两头开始搜索
		while (l != r){
			int area = min(height[l], height[r]) * (r - l);
			ans = max(area, ans);
			if (height[l] >= height[r])
				r--;
			else l++;
		}
		return ans;
    }

26. 删除有序数组中的重复项（快慢指针）

1、要求原地扫一遍删除重复项，使用快慢指针
2、若快慢指针相同，快指针加一，慢指针不变；如果不同，慢指针等于快指针，快慢都加一。

    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if (n == 0) 
            return 0;
        int fast = 1, slow = 1;
        while (fast < n) {
            if (nums[fast] != nums[fast - 1]) {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
        return slow;
    }

31. 下一个排列（两次遍历）

1、从后向前找到第一个i，满足a[i]<a[i+1]
2、从后向前找到第一个比i大的数交换
3、反转i+1到末尾的数

class Solution {
public:
    void nextPermutation(vector<int>& nums) {
        int i = nums.size() - 2;
        while (i >= 0 && nums[i] >= nums[i + 1]) {
            i--;
        }
        if (i >= 0) {
            int j = nums.size() - 1;
            while (j >= 0 && nums[i] >= nums[j]) {
                j--;
            }
            swap(nums[i], nums[j]);
        }
        reverse(nums.begin() + i + 1, nums.end());
    }
};

38. 外观数列（递归+一次遍历）

递归一直到1开始，从第二层开始，每一层一次遍历，得到新的数组返回

class Solution {
public:
    string countAndSay(int n) {
        if(n == 1) return "1";
        string previous = countAndSay(n-1), result = ""; // 使用递归来一层一层往前推
        int count = 1; // count用来计数
        for(int i=0;i<previous.length();i++) {
            if(previous[i] == previous[i+1])
                count ++; // 比如previous是111221时，111部分会让count=3，此时i在第三个1处
            else{
                result += to_string(count) + previous[i]; // result会从空变成“31”（当i在第三个1处时）
                count = 1; // 由于i在第三个1处时，i+1处的值为2，1 != 2，所以count重新变成1
            }
        }
        return result;
    }
};

45. 跳跃游戏 II（贪心）

贪心算法，每次选择能跳的最远的点，维护跳数和末端，一次遍历，更新最大值，到末端时，末端替换为最大值，跳数加一

class Solution {
public:
    int jump(vector<int>& nums) {
        int maxPos = 0, n = nums.size(), end = 0, step = 0;
        for (int i = 0; i < n - 1; ++i) {
            if (maxPos >= i) {
                maxPos = max(maxPos, i + nums[i]);
                if (i == end) {
                    end = maxPos;
                    ++step;
                }
            }
        }
        return step;
    }
};

55. 跳跃游戏（贪心）

一次遍历，更新能达到右边的最大值，若达到末尾则返回

    bool canJump(vector<int>& nums) {
        int n = nums.size();
        int rightmost = 0;
        for (int i = 0; i < n; ++i) {
            if (i <= rightmost) {
                rightmost = max(rightmost, i + nums[i]);
                if (rightmost >= n - 1) {
                    return true;
                }
            }
        }
        return false;
    }

75. 颜色分类（双指针）

双指针，一个负责交换数字0，一个负责交换数字1，当p0<p1时，此时必定把1交换出去，所以需要交换回来

class Solution {
public:
    void sortColors(vector<int>& nums) {
        int n = nums.size();
        int p0 = 0, p1 = 0;
        for (int i = 0; i < n; ++i) {
            if (nums[i] == 1) 
                swap(nums[i], nums[p1++]);
            else if (nums[i] == 0) {
                swap(nums[i], nums[p0]);
                if (p0 < p1) 
                    swap(nums[i], nums[p1]);
                ++p0;
                ++p1;
            }
        }
    }
};

121. 买卖股票的最佳时机（一次遍历）

记录今天以前股价最小值，用当天的股价减去之前最小值买入得到利润，记录最大利润。

    int maxProfit(vector<int>& prices) {
    //迭代,在当前最低时候买入，每天卖出，求最大值
    int price=INT_MAX,profit=0;
    for(int i=0;i<prices.size();i++) {
        price=min(price,prices[i]);
        profit=max(profit,prices[i]-price);
    }
    return profit;
    }

122. 买卖股票的最佳时机 II（一次遍历）

1、上一题只能买卖一次，这一题不限制买卖，但是同一时间只能买卖一次
2、遍历一遍数组，找到每个股价上涨的差价并记录即可

class Solution {
public:
    int maxProfit(vector<int>& prices) {   
        int ans = 0;
        int n = prices.size();
        for (int i = 1; i < n; ++i) 
            ans += max(0, prices[i] - prices[i - 1]);
        return ans;
    }
};

189. 旋转数组（环状替换）

空间复杂度为o(1)，用一个temp记录当前数，不断往后移

class Solution {
public:
    void rotate(vector<int>& nums, int k) {
        int n = nums.size();
        k = k % n;
        int count = gcd(k, n);
        for (int start = 0; start < count; ++start) {
            int current = start;
            int prev = nums[start];
            do {
                int next = (current + k) % n;
                swap(nums[next], prev);
                current = next;
            } while (start != current);
        }
    }
};

209. 长度最小的子数组（滑动窗口）

维护一个滑动窗口，每次把end加到刚好大于指定值，记录最短长度，然后减去start使得刚好小于指定值

class Solution {
public:
    int minSubArrayLen(int s, vector<int>& nums) {
        int n = nums.size();
        if (n == 0) 
            return 0;
        int ans = INT_MAX,start = 0, end = 0,sum = 0;
        while (end < n) {
            sum += nums[end];
            while (sum >= s) {
                ans = min(ans, end - start + 1);
                sum -= nums[start];
                start++;
            }
            end++;
        }
        return ans == INT_MAX ? 0 : ans;
    }
};

283. 移动零（快慢指针）

快慢指针，快指针碰到非0的数就和慢指针交换，慢指针加一

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int n = nums.size(), left = 0, right = 0;
        while (right < n) {
            if (nums[right]) {
                swap(nums[left], nums[right]);
                left++;
            }
            right++;
        }
    }
};

剑指 Offer 21. 调整数组顺序使奇数位于偶数前面（快慢指针）

设置快慢指针，如果快指针是奇数则和慢指针交换，慢指针加1

    vector<int> exchange(vector<int>& nums) {
    //快慢指针比头尾指针代码量简单
    int first=0,second=0;
    while(second<nums.size()){
        if(nums[second]%2==1)
            swap(nums[second],nums[first++]);
        second++;
    }
    return nums;
    }