88.合并两个有序数组
要求非递减
https://leetcode.cn/problems/merge-sorted-array/?envType=study-plan-v2&envId=top-interview-150
他已经帮我们开好了空间了,我们就从右边往左边填最大的数就行了
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
while(m+n){
if(nums1[m-1]>nums2[n-1]){
nums1[m+n-1] = nums1[m-1];
m--;
}else{
nums1[m+n-1] = nums1[n-1];
n--;
}
}
}
};
这样感觉是不对的,因为会覆盖掉已经有的数据,应该使用swap的操作比较好
class Solution {
public:
void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
int i = m - 1; // nums1 中的有效元素指针
int j = n - 1; // nums2 中的有效元素指针
int k = m + n - 1; // nums1 最终数组的指针
// 从后向前合并
while (i >= 0 && j >= 0) {
if (nums1[i] > nums2[j]) {
nums1[k--] = nums1[i--];
} else {
nums1[k--] = nums2[j--];
}
}
// 如果 nums2 还有剩余,继续合并
while (j >= 0) {
nums1[k--] = nums2[j--];
}
// 不需要处理 nums1,因为它们已经在正确的位置上
}
};
因为给出的参数数组都是非递减的,所以nums1其实最后可以不处理了,如果nums1还没有递减到
27 移除元素
计算有多少个不是需求的val的个数
然后返回这几个不是val的数组(这几个是数需要在前k个)
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int ans=0;
for(int i=0;i<nums.size();i++){
if(nums[i] == val){
swap(nums[i],nums[nums.size()-1]);
}else{
ans++;
}
}
return ans;
}
};
错误的,不能保证换的swap那个不是val
class Solution {
public:
int removeElement(vector<int>& nums, int val) {
int ans=0;
for(int i=0;i<nums.size();i++){
if(nums[i] != val){
nums[ans]=nums[i];
ans++;
}
}
return ans;
}
};
很简答的逻辑,如果不是val,就放在前面几个,为什么我要想是val然后去处理他呢。。。
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 已按 非严格递增 排列
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
//用字典?
unordered_map<int,int> map;
vector<int> res;
for(int i=0;i<nums.size();i++){
if(map[nums[i]]==0)
res.push_back(nums[i]);
map[nums[i]]=1;
}
nums = res;
return nums.size();
}
};
用字典统计就可以了,如果第一次出现就放入新数组,如果不是第一次出现就不用管,返回获得数组的数量就可以
80. 删除有序数组中的重复项 II
给你一个有序数组 nums ,请你 原地 删除重复出现的元素,使得出现次数超过两次的元素只出现两次 ,返回删除后数组的新长度。
不要使用额外的数组空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
说明:
为什么返回数值是整数,但输出的答案是数组呢?
请注意,输入数组是以「引用」方式传递的,这意味着在函数里修改输入数组对于调用者是可见的。
你可以想象内部操作如下:
// nums 是以“引用”方式传递的。也就是说,不对实参做任何拷贝
int len = removeDuplicates(nums);
// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中 该长度范围内 的所有元素。
for (int i = 0; i < len; i++) {
print(nums[i]);
}
示例 1:
输入:nums = [1,1,1,2,2,3]
输出:5, nums = [1,1,2,2,3]
解释:函数应返回新长度 length = 5, 并且原数组的前五个元素被修改为 1, 1, 2, 2, 3。 不需要考虑数组中超出新长度后面的元素。
示例 2:
输入:nums = [0,0,1,1,1,1,2,3,3]
输出:7, nums = [0,0,1,1,2,3,3]
解释:函数应返回新长度 length = 7, 并且原数组的前七个元素被修改为 0, 0, 1, 1, 2, 3, 3。不需要考虑数组中超出新长度后面的元素。
提示:
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按升序排列
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
unordered_map<int,int> map;
vector<int> res;
for(int i=0;i<nums.size();i++){
if(map[nums[i]]==0 || map[nums[i]]==1)
res.push_back(nums[i]);
map[nums[i]]++;
}
nums = res;
return nums.size();
}
};
和上一题一样的解法没什么好说的
class Solution {
public:
int removeDuplicates(vector<int>& nums) {
int n = nums.size();
if (n <= 2) {
return n;
}
int slow = 2, fast = 2;
while (fast < n) {
if (nums[slow - 2] != nums[fast]) {
nums[slow] = nums[fast];
++slow;
}
++fast;
}
return slow;
}
};
不相等的时候移动慢指针(代表我们的最后输出的数组),并且赋值,
相等的时候移动快指针
169. 多数元素
给定一个大小为 n 的数组 nums ,返回其中的多数元素。多数元素是指在数组中出现次数 大于 ⌊ n/2 ⌋ 的元素。
你可以假设数组是非空的,并且给定的数组总是存在多数元素。
示例 1:
输入:nums = [3,2,3]
输出:3
示例 2:
输入:nums = [2,2,1,1,1,2,2]
输出:2
提示:
n == nums.length
1 <= n <= 5 * 104
-109 <= nums[i] <= 109
进阶:尝试设计时间复杂度为 O(n)、空间复杂度为 O(1) 的算法解决此问题。