【算法】经典算法题合集

专题一：双指针

---

1. 移动零

---

题目解析

算法原理

代码编写

// 写法一
class Solution 
{
   
   
public:
    void moveZeroes(vector<int>& nums) 
    {
   
   
        // 1、下标初始化
        int dest = -1, cur = 0;
        // 2、数组划分
        while(cur < nums.size())
        {
   
   
            if(nums[cur]) 
                swap(nums[++dest], nums[cur++]);
            else 
                ++cur;
        }
    }
};

// 写法二
class Solution 
{
   
   
public:
    void moveZeroes(vector<int>& nums) 
    {
   
   
       for(int dest = -1, cur = 0; cur < nums.size(); ++cur)
            if(nums[cur]) // 处理 非0 元素
                swap(nums[++dest], nums[cur]);
    }
};

/*
- 时间复杂度：O(n)
- 空间复杂度：O(1)
*/

---

2. 复写零

---

算法原理

代码编写

class Solution 
{
   
   
public:
    void duplicateZeros(vector<int>& nums) 
    {
   
   
        // 1、初始化
        int dest = -1, cur = 0, n = nums.size();
        // 2、找到最后一个复写的数
        while(true)
        {
   
   
            if(nums[cur]) dest += 1;
            else dest += 2;
            if(dest >= n - 1) break;
            ++cur;
        }
        cout << nums[cur] << endl;
        // 1.5、预处理 -> 让 dest 的下标有效
        if(dest == n)
        {
   
   
            if(nums[cur]) --cur, --dest;
            else 
            {
   
   
                nums[n - 1] = 0;
                dest -= 2;
                cur -= 1;
            }
        }
        // 2、双指针从后往前进行复写操作
        while(cur >= 0)
        {
   
   
            if(nums[cur]) nums[dest--] = nums[cur--];
            else
            {
   
   
                nums[dest--] = 0;
                nums[dest--] = 0;
                cur--;
            } 
        }
    }
};
/*
- 时间复杂度：O(n)
- 空间复杂度：O(1)
*/

---

3. 快乐数

---

算法原理

代码编写

class Solution 
{
   
   
private:
    // 计算每个位置上的数字的平方和
    inline static int BitSum(int num)
    {
   
   
        int ret = 0;
        while(num)
        {
   
   
            int t = num % 10;
            ret += t * t;
            num /= 10;
        }
        return ret;
    }

public:
    bool isHappy(int n) 
    {
   
   
        int slow = n, fast = BitSum(n);
        while(slow != fast)
        {
   
   
            slow = BitSum(slow);
            fast = BitSum(BitSum(fast));
        }
        return slow == 1;
    }
};

---

4. 盛最多水的容器

---

算法原理

代码编写

class Solution 
{
   
   
public:
    int maxArea(vector<int>& height) 
    {
   
   
        int left = 0, right = height.size() - 1;
        int ret = INT_MIN;
        while(left != right)
        {
   
   
            // 容积 = 长度 * 高度
            int v = (right - left) * min(height[left], height[right]);
            ret = max(ret, v);
            // 移动指针 - 谁小移动谁
            height[left] < height[right] ? ++left : --right;
        }
        return ret;
    }
};
/*
- 时间复杂度：O(n)
- 空间复杂度：O(1)
*/

---

5. 有效三角形的个数

---

算法原理

代码编写

class Solution 
{
   
   
public:
    int triangleNumber(vector<int>& nums) 
    {
   
   
        // 1、优化
        sort(nums.begin(), nums.end());
        // 2、利用双指针解决问题
        int ret = 0, n = nums.size();
        for(int i = n - 1; i >= 2; --i)
        {
   
   
            int left = 0, right = i - 1;
            while(left < right)
            {
   
   
                // 当 a+b>c ，a下标属于 [left, right-1]时，都能和 b、c 构成三角形
                // 当 a+b<=c ，b下标属于[left-1, right]时，都不能和 a、c 构成三角形
                if(nums[left] + nums[right] > nums[i])
                {
   
   
                    ret += right - left;
                    --right;
                }
                else ++left;
            }
        }
        // 返回值
        return ret;
    }
};

/*
- 时间复杂度：O(n^2)
- 空间复杂度：O(1)
*/

---

6. 查找总价格为目标值的两个商品

---

算法原理

代码编写

class Solution 
{
   
   
public:
    vector<int> twoSum(vector<int>& price, int target) 
    {
   
   
        // 1、数据初始化
        int left = 0, right = price.size() - 1;
        // 2、利用双指针解决问题
        while(left < right)
        {
   
   
            int sum = price[left] + price[right];
            if(sum < target) ++left;
            else if(sum > target) --right;
            else return {
   
   price[left], price[right]};
        }
        // 题目没有明确说明没有结果的话会怎么样，那么该题的测试用例应该都是有结果的
        // 为了照顾编译器要求一定要返回一个结果，所以我们最后返回一个空数组即可
        return {
   
   };
    }
};
/*
- 时间复杂度：O(n)
- 空间复杂度：O(1)
*/

---

7. 三数之和

---

算法原理

代码编写

class Solution 
{
   
   
public:
    vector<vector<int>> threeSum(vector<int>& nums) 
    {
   
   
        // 1、初始化
        int n = nums.size();
        vector<vector<int>> ret;
        // 2、排序
        sort(nums.begin(), nums.end());
        // 3、依次固定一个数
        for(int i = 0; i < n - 2;)
        {
   
   
            // 4、双指针算法找到两数之和等于 aim 的元素
            int left = i + 1, right = n - 1, aim = -nums[i];
            while(left < right)
            {
   
   
                int sum = nums[left] + nums[right];
                if(sum < aim) ++left;
                else if(sum > aim) --right;
                else 
                {
   
   
                    ret.push_back( {
   
   nums[i], nums[left], nums[right]} );
                    ++left, --right; // 保证 left、right 选择的元素不漏
                    // 对 left、right 已经选择过的元素去重
                    while(left < right && nums[left] == nums[left - 1]) ++left;
                    while(left < right && nums[