1-数组-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_40905739/article/details/113756513

本文介绍了几种常见的算法问题解决方案，包括移动零、盛最多水的容器和两数之和等。解法涉及双指针技巧和动态规划思想，如使用zeroCnt变量记录0的个数，通过调整元素位置实现移动零的效果，以及通过双指针找到最大面积的容器。此外，还展示了如何使用动态规划解决爬楼梯问题。这些算法在解决数组和序列操作时非常实用。

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

1 - 移动元素

283. 移动零

解法一：使用 zeroCnt 变量来记录 0 当前出现的次数，对于非零元素，使其前移 zeroCnt 个位置；然后统一从后往前复制 zeroCnt 个零元素。

	void moveZeroes(vector<int>& nums) {
        int zeroCnt = 0, len = nums.size();
        for(int i = 0; i < len; i++) {
            if(nums[i] == 0)
                zeroCnt++;
            else 
                nums[i - zeroCnt] = nums[i];
        }
        for(int i = 0; i < zeroCnt; i++) 
            nums[len - 1 - i] = 0;        
    }

解法二：使用 index 变量记录非零元素的个数，如果遍历指针 i 所指向位置不能于 index 时，说明其出现过零元素，将其赋值为 0

	void moveZeroes(vector<int>& nums) {
        int index = 0, len = nums.size();
        for(int i = 0; i < len; i++) {
            if(nums[i] != 0) {
                nums[index] = nums[i];
                if(i != index) 
                    nums[i] = 0;
                index++;                
            }
        }
    }

2 - 双指针的思想

11. 盛最多水的容器

解法一：穷举的思想，两层 for 循环不断地迭代更新

class Solution {
public:     
    int maxArea(vector<int>& height) {       
       int len = height.size(), area = 0, max = 0;
       for(int i = 0; i < len - 1; i++) {
           for(int j = i + 1; j < len; j++) {
           	   // 利用三目表达式得到桶的高度，然后
               int h = (height[i] < height[j]) ? height[i] : height[j];
               area = (j - i) * h;
               if(max < area)
                    max = area; 
           }
       }
       return max;
    }
};

class Solution {
public:     
    int maxArea(vector<int>& height) {       
       int l = 0, r = height.size() - 1, ar ea = 0, max = 0;
       while(l < r) {
           if(height[l] < height[r]) {
               area = (r - l) * height[l];
               l++;
           }
           else {
               area = (r - l) * height[r];
               r--;
           }
           if(max < area)
                max = area; 
       }
       return max;
    }
};

1.两数之和
解法一：使用暴力解法，两层 for 循环迭代计算，输出

class Solution {
public:
    vector<int> twoSum(vector<int>& nums, int target) {
        vector<int> ans;
        int len = nums.size();
        for(int i = 0; i < len - 1; i++) {
            for(int j = i + 1; j < len; j++) {
                if(nums[i] + nums[j] == target) {
                    ans.push_back(i);
                    ans.push_back(j);                   
                }                    
            }
        }
        return ans;     
    }
};

15. 三数之和

class Solution {
public:
    vector<vector<int>> threeSum(vector<int>& nums) {
        vector<vector<int>> ans;
        sort(nums.begin(), nums.end());
        int len = nums.size();
        for(int i = 0; i < len; i++) { 
            if (nums[i] > 0)                     return ans;  
            if (i > 0 && nums[i] == nums[i-1])   continue;
            int l = i + 1, r = len - 1;
            while(l < r) {                
                int sum = nums[i] + nums[l] + nums[r];
                if(sum < 0) {
                    l++;
                    while(l < r && nums[l] == nums[l - 1]) l++;
                }             
                else if(sum > 0) {
                    r--;
                    while(l < r && nums[r] == nums[r + 1]) r--;
                }                    
                else {
                    ans.push_back({nums[i], nums[l], nums[r]});
                    l++;  r--;
                    while(l < r && nums[l] == nums[l - 1]) l++;
                    while(l < r && nums[r] == nums[r + 1]) r--;
                }                     
            }
        }
	    
        return ans;
    }
};

3、dp 数组动态规划

70. 爬楼梯

class Solution {
public:
    int climbStairs(int n) {
        if(n == 1)  return 1;
        vector<int> dp(n + 1, 0);
        dp[1] = 1;  dp[2] = 2;
        for(int i = 3; i <= n; i++) 
            dp[i] = dp[i - 1] + dp[i - 2];
        return dp[n];
    }
};