leetcode 数组

11. Container With Most Water

在数组的头尾均设置一个指针，设置max变量记录当前的最大容量；
计算完一次后移动一个指针，木桶原理是容积取决于行长度和最短高度的积，因此每次移动短的指针，因为如果移动长的指针那么容量可能变小。直到两个指针相遇。

int maxArea(vector<int>& height) {
    int i=0,j=height.size()-1;
    int max=0,sum=0;
    while(i!=j){
        if(height[i]<height[j]){
            sum=height[i]*(j-i);
            i++;
        }
        else{
            sum=height[j]*(j-i);
            j--;
        }
        if(sum>max)
            max=sum;
    }
    return max;

}

15. 3Sum

思路：
1、求和为0，一定是有正有负或者均为零，因此先对数组进行升序排序。
2、需要二重循环：
第一层循环：挑选三个数中的第一个数；
第二层循环：分别从后面的头和尾开始，如果和为零，在两个指针向中间移动；如果和大于零，说明正数大了，末尾的指针向左移动；反之头部的指针向右移动。

很多坑：
1）因为已经是有序数组，当第一个数大于零的时候，后面不需要再看了，因为三个正数的和一定大于零；
2）第一层循环并不是到数组最后才结尾，到倒数第三个元素的时候就不需要循环了；
3）要求不重复，因此在循环时要跳过重复元素，每一次都需要判断。

vector<vector<int>> threeSum(vector<int>& nums) {
    sort(nums.begin(),nums.end());
    vector<vector<int>> out={};
    vector<int>tmp;
    int num=0;
    if(nums.size()<3)      //坑1）
        return out;
    for(int i=0;i< nums.size()-2;i++){//坑2）
        if(nums[i]>0)
            break;
        while(i > 0 && i < nums.size()-2 && nums[i] == nums[i-1])//坑3）
            i ++;
        int j=i+1;
        int k=nums.size()-1;
        while(j<k){
            if(nums[i]+nums[j]+nums[k]==0){
                tmp.push_back(nums[i]);
                tmp.push_back(nums[j]);
                tmp.push_back(nums[k]);
                out.push_back(tmp);
                tmp.clear();
                j++;
                k--;
                while(j < k && nums[j] == nums[j-1])
                    j ++;
                while(k > j && nums[k] == nums[k+1])
                    k --;
            }
            else if(nums[i]+nums[j]+nums[k]>0){
                k--;
                while(k > j && nums[k] == nums[k+1])
                    k --;
            }
            else{
                j++;
                while(j < k && nums[j] == nums[j-1])
                    j ++;
            }
        }
    }
    return out;

}

16. 3Sum Closest

思路跟上一题一样，更简单一些。每次求和之后做差，差的绝对值最小的那个数就是最接近的。
tip:当和等于target时，直接返回target，比较省时间。

int threeSumClosest(vector<int>& nums, int target) {
    sort(nums.begin(),nums.end());
    int closet=0,min=numeric_limits<int>::max(),sum;
    int len=nums.size()-2;
    for(int i=0;i< len;i++){
        int j=i+1;
        int k=nums.size()-1;
        
        while(j<k){
            sum=nums[i]+nums[j]+nums[k];
            if(sum==target)
                return target;
            else if(sum>target) k--;
            else j++;

            if(abs(sum-target)<min) {
                min = abs(sum - target);
                closet=sum;
            }
        }
    }
    return closet;
}

18. 4Sum

与3Sum的思路相同，但是需要多加一个指针，因此多一重循环。

vector<vector<int>> fourSum(vector<int>& nums,int target) {
    sort(nums.begin(),nums.end());
    vector<vector<int>> out={};
    vector<int>tmp;
    int sum=0;
    if(nums.size()<4)
        return out;
    for(int i=0;i< nums.size()-3;i++){
        while(i > 0 && i < nums.size()-3 && nums[i] == nums[i-1])
            i ++;
        int j=i+1;
        int l=j+1;
        int k=nums.size()-1;

        while(j<k-1){
            while(l<k){
                sum=nums[i]+nums[j]+nums[l]+nums[k];
                if(sum==target){
                    tmp.push_back(nums[i]);
                    tmp.push_back(nums[j]);
                    tmp.push_back(nums[l]);
                    tmp.push_back(nums[k]);
                    out.push_back(tmp);
                    tmp.clear();
                    l++;k--;
                    while(l < k && nums[l] == nums[l-1])
                        l ++;
                    while(k > l && nums[k] == nums[k+1])
                        k --;
                }
                else if(sum>target){
                    k--;
                    while(k > j && nums[k] == nums[k+1])
                        k --;
                }
                else{
                    l++;
                    while(l < k && nums[l] == nums[l-1])
                        l ++;
                }
            }
            k=nums.size()-1;
            j++;
            while(j < k-1 && nums[j] == nums[j-1])
                j ++;
            l=j+1;
        }
    }
    return out;
}

27. Remove Element

int removeElement(vector<int>& nums, int val) {
    int len=nums.size();
    vector<int>::iterator it = nums.begin();
    for(;it != nums.end();)
    {
        if(*it == val) {
            //删除指定元素，返回指向删除元素的下一个元素的位置的迭代器
            it = nums.erase(it);
            --len;
        }
        else
            //迭代器指向下一个元素位置
            ++it;
    }

    return len;

}

31. Next Permutation

1）从后向前找到不递增的元素设为tag，若没找到，全排序；
2）将tag之后的元素排序
3）对tag后的元素从前向后查找，找到比tag大的就交换

void swap(int& a,int& b){
    int tmp=a;
    a=b;
    b=tmp;
}
void nextPermutation(vector<int>& nums) {
    int tag=-1;
    if(nums.size()<2)
        return;
    vector<int>::iterator left=nums.begin();
    for(int i=nums.size()-1;i>0;i--){
        if(nums[i]>nums[i-1]){
            if(i==nums.size()-1){
                swap(nums[i],nums[i-1]);
                return;
            }
            else
                tag=i-1;
            break;//坑1
        }
    }
    if(tag==-1) {
        sort(nums.begin(), nums.end());
        return;
    }
    for(int i=1;i<=tag+1;i++){
        ++ left ;
    }
    sort(left,nums.end());

    for(int i=tag+1;i<nums.size();i++){
        if(nums[i]>nums[tag]) {
            swap(nums[i],nums[tag]);
            break;//坑2
        }
    }
    return;
}