7.删除有序数组中的重复项(26)
题目
给你一个 非严格递增排列 的数组 nums
,请你** 原地** 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。然后返回 nums
中唯一元素的个数。
考虑 nums
的唯一元素的数量为 k
,你需要做以下事情确保你的题解可以被通过:
- 更改数组
nums
,使nums
的前k
个元素包含唯一元素,并按照它们最初在nums
中出现的顺序排列。nums
的其余元素与nums
的大小不重要。 - 返回
k
。
判题标准:
系统会用下面的代码来测试你的题解:
int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案
int k = removeDuplicates(nums); // 调用
assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
assert nums[i] == expectedNums[i];
}
如果所有断言都通过,那么您的题解将被 通过。
示例 1:
输入:nums = [1,1,2]
输出:2, nums = [1,2,_]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2:
输入:nums = [0,0,1,1,1,2,2,3,3,4]
输出:5, nums = [0,1,2,3,4]
解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示:
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums
已按 非严格递增 排列
思路及题解
- 处理数组问题,按照惯例用双指针
- 这题数组元素的先后顺序不能变化,所以不考虑对撞指针,只能考虑快慢指针
- 由于数组非严格递增,因此重复元素的位置其实是知道的,就在每个不重复元素的后面
- 慢指针指向修改的元素,快指针逐个遍历元素直到越界
- 用val变量存储遇到的不重复元素,当快指针遍历到与val不同的元素时,慢指针对应的元素更改为快指针的值,同时更新val
- 最终返回慢指针的值+1,即为修改过的元素数目,即为新数组长度
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int slow = 0, fast = 0, val = nums[0];
for (; fast < nums.size(); fast++) {
if (nums[fast] != val) {
slow++;
nums[slow] = nums[fast];
val = nums[slow];
}
}
return slow + 1;
}
};
- 优化:可以不用val变量存储不重复元素,因为val的作用是判断什么时候遇到了新的不重复元素,可以用
nums[fast -1] != nums[fast]
作为判断条件
//优化的双指针算法
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int n = nums.size();
int slow = 1, fast = 1;
while (fast < n) {
if (nums[fast - 1] != nums[fast]) {
nums[slow] = nums[fast];
slow++;
}
fast++;
}
return slow;
}
};
8.移动零(283)
题目
给定一个数组 nums
,编写一个函数将所有 0
移动到数组的末尾,同时保持非零元素的相对顺序。
请注意 ,必须在不复制数组的情况下原地对数组进行操作。
示例 1:
输入: nums = [0,1,0,3,12]
输出: [1,3,12,0,0]
示例 2:
输入: nums = [0]
输出: [0]
提示:
1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1
**进阶:**你能尽量减少完成的操作次数吗?
思路及题解
- 因为要保证处理前后的顺序,所以用快慢指针
- 慢指针找到待交换的 ‘0’,快指针找到要交换的非零数
- 慢指针要注意防止越界,越界了交换结束
- 当慢指针出现在快指针前面时,不进行交换,否则会把零交换到前面,把非零数交换到后面
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int slow = 0, fast = 0;
for (; fast < nums.size(); fast++) {
while (nums[slow] != 0) {
slow++;
if (slow >= nums.size())
return;
}
if (nums[fast] != 0 && slow < fast) {
swap(nums[slow],nums[fast]);
}
}
}
};
- 另一种快慢指针:慢指针指向已经处理好的序列的尾部,快指针指向待处理的序列头部
- 这样慢指针左边永远是已经处理好的序列,快指针左边的数字都是0,直到遇见快指针
- 这种写法可以减少判断的条件,代码更加简洁,但是需要交换的次数增多
- 如输入为nums =[1,2,3,4,5,0,0,1,2,3]时,这种写法前面的1,2,3,4,5都需要与其自身交换一次,而第一种写法却不用
class Solution {
public:
void moveZeroes(vector<int>& nums) {
int slow = 0, fast = 0;
while (fast < nums.size()) {
if (nums[fast]) {
swap(nums[slow], nums[fast]);
slow++;
}
fast++;
}
}
};
9.比较含退格的字符串(844)
题目
给定 s
和 t
两个字符串,当它们分别被输入到空白的文本编辑器后,如果两者相等,返回 true
。#
代表退格字符。
**注意:**如果对空文本输入退格字符,文本继续为空。
示例 1:
输入:s = "ab#c", t = "ad#c"
输出:true
解释:s 和 t 都会变成 "ac"。
示例 2:
输入:s = "ab##", t = "c#d#"
输出:true
解释:s 和 t 都会变成 ""。
示例 3:
输入:s = "a#c", t = "b"
输出:false
解释:s 会变成 "c",但 t 仍然是 "b"。
提示:
1 <= s.length, t.length <= 200
s
和t
只含有小写字母以及字符'#'
进阶:
- 你可以用
O(n)
的时间复杂度和O(1)
的空间复杂度解决该问题吗?
思路及题解
- 双指针法,慢指针指向前一个元素,快指针指向后一个元素,如果后一个元素是 ‘#’ ,就把前一个元素和 ‘#’ 同时删除,再恢复快慢指针的位置,直到快指针越界为止
- 用到的库函数:erase、compare、[](随机访问string)
class Solution {
public:
bool backspaceCompare(string s, string t) {
//这里可以再简化,直接return
s = func(s);
t = func(t);
if (s.compare(t))
return false;
else
return true;
}
string func(string str) {
int slow = 0, fast = 0;
while (fast < str.size()) {
//一开始,两个指针指向同一个元素
//如果慢指针指向了'#',说明前面没有要删除的元素,直接把这个'#'删掉
while (str[slow] == '#') {//这里要用while而不是if,因为'#'可能连续出现
str.erase(slow, 1);
//删完之后进行一次越界判断
if (fast >= str.size())
return str;
}
//快指针指向后一个元素
fast++;
if (str[fast] == '#') {
//删除两个元素
str.erase(slow, 2);
//慢指针指向第一个元素的情况要分开讨论,否则慢指针会越界
if (slow - 1 >= 0) {
slow--;
fast = slow;
} else {
slow = 0;
fast = 0;
}
} else
slow++; //如果快指针不是指向'#',两个指针同时向前
}
return str;
}
};
- 这题用栈的解法更为简洁,如果下一个字符不为‘#’,则将让该元素进栈。如果下一个字符为’#'且栈不为空(前面有待删除的元素),则出栈,最后剩下的就是修改过的字符串
class Solution {
public:
bool backspaceCompare(string s, string t) { return func(s) == func(t); }
string func(string str) {
string stack;
for (char ch : str) {
if (ch != '#')
stack.push_back(ch);
else if (!stack.empty())
stack.pop_back();
}
return stack;
}
};