算法刷题_数组篇

算法刷题笔记Day1_数组篇_移除元素

---

前提：数组的元素在内存地址中是连续的，不能单独删除数组中的某个元素，只能覆盖。erase库函数的复杂度是O（n)而不是O（1）。

---

前言

一、如何移除数组元素？

法一：暴力法（两层for循环）

	for(i=0;i<s.size();i++){
		if(s[i]=object){//假设要移除元素为object
			for(j=i+1;j<s.size();j++){
				s[j-1]=s[j];
			}
			i--;
			size--;
		}
	}

法二：双指针法（推荐重点掌握）

目的：使用双指针减少一层for循环，降低复杂度
具体做法：快指针遍历整个数组，获取到的值（除了要删除的元素）赋给慢指针；快指针用来获取，慢指针用来更新。

slow=0;
for(fast=0;fast<s.size();fast++){
	if(s[fast]!=object){
		s[slow]=s[fast];
		slow++;
	}
}
return slow;

---

提示：以下是与移除元素相关代码，下面案例可供参考
①删除有序数组中的重复项

法一：class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) return 0; // 处理空数组的特殊情况
        int slow = 0; 
        for (int fast = 0; fast < nums.size(); fast++) { 
            // 当是第一个元素或者当前元素不等于前一个元素时
            if (fast == 0 || nums[fast] != nums[fast - 1]) {//当 fast 是最后一个元素的下标（fast == nums.size() - 1）时，访问 nums[fast + 1] 会导致越界错误。
                nums[slow] = nums[fast]; // 将fast元素放入slow位置
                slow++; // 移动slow指针
            }
        }
        return slow; // slow表示新数组长度
    }
};
法二：class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        if (nums.empty()) return 0; // 处理空数组的特殊情况
        int slow = 1; // 从索引 1 开始存储不重复元素
        for (int fast = 1; fast < nums.size(); fast++) {
            if (nums[fast] != nums[slow - 1]) { // 比较当前元素与上一个已存储元素
                nums[slow] = nums[fast]; // 将不重复元素存入slow位置
                slow++; // 移动slow指针
            }
        }
        return slow; // 返回新数组的长度
    }
};

②移动零

class Solution {
public:
    void moveZeroes(vector<int>& nums) {
        int slow=0;
        for(int fast=0;fast<nums.size();fast++){
            if(nums[fast]!=0)
            {
                nums[slow]=nums[fast];
                slow++;
            }
        }//注意：两个for循环是并列的
        for(int i=slow;i<nums.size();i++)// 将 slow 之后的元素全部置为 0
        {
            nums[i]=0;
        }
    }
};

③比较含退格的字符串

如果当前字符是 #，记录一次退格操作（skipS++），并移动指针向前。
如果当前字符不是 #，但有未处理的退格操作（skipS > 0），说明它需要被跳过，减少退格计数（skipS–），继续移动指针向前。
如果当前字符不是 # 且没有退格计数（skipS == 0），说明它是有效字符，退出内层循环。

class Solution {
public:
    bool backspaceCompare(string s, string t) {
        int i = s.size() - 1, j = t.size() - 1; // 初始化双指针
        int skipS = 0, skipT = 0; // 记录需要跳过的字符数
        
        while (i >= 0 || j >= 0) {
            // 处理字符串 s 的有效字符
            while (i >= 0) {
                if (s[i] == '#') {
                    skipS++; // 增加退格计数
                    i--;
                } else if (skipS > 0) {
                    skipS--; // 跳过字符
                    i--;
                } else {
                    break;
                }
            }
            
            // 处理字符串 t 的有效字符
            while (j >= 0) {
                if (t[j] == '#') {
                    skipT++;
                    j--;
                } else if (skipT > 0) {
                    skipT--;
                    j--;
                } else {
                    break;
                }
            }
            
            // 比较当前有效字符
            if (i >= 0 && j >= 0 && s[i] != t[j]) return false; // 当前字符不相等
            if ((i >= 0) != (j >= 0)) return false; // 一个字符串已结束，另一个还未结束
            i--;
            j--;
        }
        
        return true; // 两个字符串相等
    }
};

④有序数组的平方

使用两个指针：
left：指向数组的起始位置（最小值）。
right：指向数组的末尾位置（最大值）。
比较 nums[left]^2 和 nums[right]^2，将较大的平方值放入结果数组的末尾。
如果 nums[left]^2 较大，移动 left 向右；否则移动 right 向左。
最终结果数组按倒序填充即可。

class Solution {
public:
    vector<int> sortedSquares(vector<int>& nums) {
        int n=nums.size();
        vector<int> result(n);
        int left=0,right=n-1;
        int pos=n-1;
        while(left<=right){
            int leftsquare=nums[left]*nums[left];
            int rightsquare=nums[right]*nums[right];
            if(leftsquare>rightsquare){
                result[pos]=leftsquare;
                left++;
            }
            else {
                result[pos]=rightsquare;
                right--;
            }
        pos--;

    }
    return result;
    }
};

---

总结

双指针法（快慢指针法）在数组和链表的操作中是非常常见的，很多考察数组、链表、字符串等操作的面试题，都使用双指针法。上述移除元素中时间复杂度为O(n^2)，双指针方法的复杂度为O（n）。