C语言【数据结构】顺序表【OJ题（C++）练习】_c++顺序结构题目

目录

1.88. 合并两个有序数组

2.26. 删除有序数组中的重复项

---

前言：顺序表-> C语言【数据结构】顺序表（动态开辟）实现_糖果雨滴a的博客-CSDN博客

1.88. 合并两个有序数组

（1）描述

给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。

示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。

示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

（2）思路

想要合并数组，并且数组是有序的，那么我们很容易就能想到两种方法

方法一：直接把nums2中的元素放到nums1数组的后面，然后进行排序，但是这种方法没有用到数组有序的条件，并且时间复杂度很大，是O((m+n)log(m+n))。这个实现很简单，效率很低，就不实现这种方法了

方法二：数组既然是有序的，那么我们可以再创建一个数组，然后两个数组进行比较，小的那个就放入到数组中，最后哪个数组中还有剩余的，就把剩余的元素都放入这个新的数组中，最后再把新的数组中的元素赋值给nums1。这种方法比第一种的时间复杂度要低，是O(m+n)，但是空间复杂度是O(m+n)。

方法三：与方法二是思路差不多，但是这个是原地修改，不需要额外开空间。我们不一定非要从前往后比，我们也可以从后往前比。我们定义三个变量：end是总的长度，end1是nums1所含有效元素大小，end2是nums2元素。然后从后往前比，大的那个就放入nums1的后面，最后再把剩余的元素放入到nums1中。

        这里方法三和方法二思路差不多，就只放上方法三的了。

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        int end = m + n - 1;
        int end1 = m - 1, end2 = n - 1;
        // 大的放入数组后面
        while(end1 >= 0 && end2 >= 0)
        {
            if(nums1[end1] > nums2[end2])
            {
                nums1[end--] = nums1[end1--];
            }
            else
            {
                nums1[end--] = nums2[end2--];
            }
        }
 
        // nums1剩余，全部放入nums1
        while(end1 >= 0)
        {
            nums1[end--] = nums1[end1--];
        }
 
        // nums2剩余，全部放入nums1
        while(end2 >= 0)
        {
            nums1[end--] = nums2[end2--];
        }
    }
};

2.26. 删除有序数组中的重复项

（1）描述

给你一个 升序排列 的数组 nums ，请你 原地 删除重复出现的元素，使每个元素 只出现一次 ，返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。

由于在某些语言中不能改变数组的长度，所以必须将结果放在数组nums的第一部分。更规范地说，如果在删除重复项之后有 k 个元素，那么 nums 的前 k 个元素应该保存最终结果。

将最终结果插入 nums 的前 k 个位置后返回 k 。

不要使用额外的空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。

判题标准:

系统会用下面的代码来测试你的题解:

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 。不需要考虑数组中超出新长度后面的元素。
 

（2）思路

 采用双指针法：

        我们想要原地删除重复项，使每个元素只出现一次，并且是有序的，那么我们就可以用双指针法（快慢指针）。一个快指针和一个慢指针，快指针用来判断是否为重复项，慢指针用不重复来覆盖当前位置元素。

        首先让快慢指针起始位置为第二个元素（因为第一个元素无需判断），然后通过快指针fast当前所在元素和前一个位置fast - 1位置所在元素进行比较，如果不相等，说明不是重复项，可以进行覆盖操作，让慢指针slow位置所在元素被fast所在位置元素覆盖，然后++slow，++fast，如果相等，继续++fast，让快指针继续往后走去判断。

class Solution {
public:
    int removeDuplicates(vector<int>& nums) {
        int n = nums.size();
        if(n == 0)
            return 0;
 
        int fast = 1, slow = 1;
        while(fast < n)
        {
            if(nums[fast] != nums[fast - 1])
            {
                nums[slow] = nums[fast];
                ++slow;
            }
            ++fast;
        }
 
        return slow;
    }
};