Leetcode（三）-数组（二）_vector<int>& height-优快云博客

本文链接：https://blog.youkuaiyun.com/googler_offer/article/details/99705152

这篇博客分享了LeetCode中关于数组的几道经典问题，包括寻找峰值、汇总区间、全局与局部倒置、合并区间等。作者提到这些题目涉及贪心算法和双指针策略，并提供了不同思路的解决方案。例如，11. 盛最多水的容器问题，通过双指针避免暴力求解导致的超时；35. 搜索插入位置问题，既可以使用直接遍历也可以采用二分查找。此外，还讨论了其他如缺失的第一个正数、颜色分类和搜索二维矩阵等有趣的问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

162. 寻找峰值

class Solution {
public:
    int findPeakElement(vector<int>& nums) {
        int left = 0,right = nums.size()-1;
        for(;left<right;)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]>nums[mid+1]) 
                right = mid;
            else
                left = mid+1;
        }
        return left;
    }
};

228. 汇总区间

class Solution {
public:
    vector<string> summaryRanges(vector<int>& nums) {
        
        if(nums.empty()) return {};
        int start = nums[0];
        int end = nums[0];
        
        vector<string> res;
        for(int i=1;i<nums.size();i++)
        {
            if(nums[i]!=end+1)
            {
                if(start==end) res.push_back(to_string(start));
                else res.push_back(to_string(start)+"->"+to_string(end));
                start = nums[i];
                end = start;
            }
            else
                end = nums[i];
        }
        if(start==end) res.push_back(to_string(start));
        else res.push_back(to_string(start)+"->"+to_string(end));
        return res;
    }
};

775. 全局倒置与局部倒置

class Solution {
public:
    bool isIdealPermutation(vector<int>& A) {
        
        for(int i=0;i<A.size();i++)
            if(abs(A[i]-i)>1) return false;
        return true;
    }
};

56. 合并区间

思路：宝刀已老啊，，，当初刷ACM这种题都是版切的，感觉。。哎。。其实这题应该属于贪心吧

class Solution {
public:
    bool cmp(const vector<int>& a,const vector<int>& b)
    {
        if(a[0]==b[0]) return a[1]<b[1];
        return a[0]<b[0];
    }
    vector<vector<int>> merge(vector<vector<int>>& intervals) {
        
        if(intervals.size()==0) return {};
        sort(intervals.begin(),intervals.end());
        vector<vector<int>> res;
        res.clear();
        int start = intervals[0][0];
        int end = intervals[0][1];
        vector<int> tmp;
        tmp.push_back(start);
        for(int i=1;i<intervals.size();i++)
        {
            if(intervals[i][0]<=end)
            {
                end = max(intervals[i][1],end);
            }
            else
            {
                tmp.push_back(end);
                res.push_back(tmp);
                tmp.clear();
                start = intervals[i][0];
                end = intervals[i][1];
                tmp.push_back(start);
            }
        }
        tmp.push_back(end);
        res.push_back(tmp);
        return res;
    }
};

1014. 最佳观光组合

思路：水水，我觉得挺有意思的，将其分为A[i]+i与A[j]-j两个部分来进行计算，这样能够缩小空间

class Solution {
public:
    int maxScoreSightseeingPair(vector<int>& A) {
        
        int i = 0;
        int Ai = A[0];
        int res = 0;
        for(int j=1;j<A.size();j++)
        {
            res = max(Ai+i+A[j]-j,res);
            if(A[j]+j>Ai+i)
            {
                Ai = A[j];
                i = j;
            }
        }
        return res;
    }
};

11. 盛最多水的容器

挺有意思的题

思路：暴力，会超时

class Solution {
public:
    int maxArea(vector<int>& height) {
        
        int res = 0;
        for(int i=0;i<height.size();i++)
        {
            for(int j=i+1;j<height.size();j++)
            {
                res = max(res,min(height[i],height[j])*(j-i));
            }
        }
        return res;
    }
};

思路：双指针，每次移动短板那根就有可能找到最佳面积，如果移动长的那根，因为res=min(height[i],height[j])*(j-i)就没啥意义，肯定会减少的。

class Solution {
public:
    int maxArea(vector<int>& height) {
        
        int left = 0;
        int right = height.size()-1;
        int res = 0;
        while(left<right)
        {
            res = max(res,min(height[left],height[right])*(right-left));
            if(height[left]<height[right]) left++;
            else right--;
        }
        return res;
    }
};

35. 搜索插入位置

思路：直接遍历，O(n)

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        for(int i=0;i<nums.size();i++)
        {
            if(nums[i]>=target) return i;
        }
        return nums.size();
    }
};

思路：二分查找

class Solution {
public:
    int searchInsert(vector<int>& nums, int target) {
        int left = 0;
        int right = nums.size();
        while(left<right)
        {
            int mid = left+(right-left)/2;
            if(nums[mid]>target) right = mid;
            else if(nums[mid]<target) left=mid+1;
            else return mid;
        }
        return left;
    }
};

41. 缺失的第一个正数

思路：遍历一遍，让所有值都回到应该有的编号上，再遍历一次，发现哪个编号上不和自己的值相等，则是它。

class Solution {
public:
    int firstMissingPositive(vector<int>& nums) {
        
        for(int i=0;i<nums.size();i++)
        {
            while(nums[i]>0&&nums[i]<=nums.size()&&nums[i]!=nums[nums[i]-1])
                swap(nums[i],nums[nums[i]-1]);
        }
        for(int i=0;i<nums.size();i++)
            if(nums[i]!=i+1) return i+1;
        return nums.size()+1;
    }
};

75. 颜色分类

思路：原地排序，如果是0则和表头交换，如果是2则和表尾交换，1也会自动排好

class Solution {
public:
    void sortColors(vector<int>& nums) {
     
        int left = 0;
        int right = nums.size()-1;
        for(int i=0;i<nums.size();i++)
        {
            if(i<left||i>right) continue;
            if(nums[i]==0)
            {
                swap(nums[i],nums[left++]);
                i--;
            }
            else if(nums[i] == 2)
            {
                swap(nums[i],nums[right--]);
                i--;
            }
        }
    }
};

74. 搜索二维矩阵

思路：O(m+n)，利用了右上角与左下角分别为一行中最大值，与一行中最小值。。。比较有趣

class Solution {
public:
    bool searchMatrix(vector<vector<int>>& matrix, int target) {
        
        if(matrix.size()==0) return false;
        int row = 0;
        int col = matrix[0].size()-1;
        while(row<matrix.size()&&col>=0)
        {
            if(matrix[row][col]>target) col--;
            else if(matrix[row][col]<target) row++;
            else return true;
        }
        return false;
    }
};

80. 删除排序数组中的重复项 II

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        
        int i = 0;
        int count = 1;
        if(nums.size()==0) return 0;
        for(int j=1;j<nums.size();j++)
        {
            if(nums[i]!=nums[j])
            {
                nums[++i] = nums[j];
                count = 1;
            }
            else if(count>=2)
                continue;
            else if(nums[i]==nums[j])
            {
                count++;
                nums[++i] = nums[j];
            }
        }
        return i+1;
    }
};

78. 子集

class Solution {
public:
    vector<bool> flag;
    vector<int> sub;
    vector<vector<int>> res;
    vector<vector<int>> subsets(vector<int>& nums) {
        
        int n = nums.size();
        flag = vector<bool>(n,false);
        dfs(nums,0,n);
        return res;
    }
    void dfs(vector<int>& nums,int start,int n)
    {
        res.push_back(sub);
        for(int i=start;i<n;i++)
        {
            if(!flag[i])
            {
                sub.push_back(nums[i]);
                flag[i] = true;
                dfs(nums,i+1,n);
                flag[i] = false;
                sub.pop_back();
                //sub.pop_back();
                //flag[i] = false;
            }
        }
    }
};