寒假冬令营（算法编程）1月8日（数组）

题目描述（1）

88. 合并两个有序数组

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

给你两个按 非递减顺序 排列的整数数组 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 中。

提示：

• nums1.length == m + n

• nums2.length == n

• 0 <= m, n <= 200

• 1 <= m + n <= 200

• -109 <= nums1[i], nums2[j] <= 109

解题结果

Java

        实现了将两个有序数组合并为一个有序数组的功能。通过使用一个循环，将数组 nums2 的元素逐个复制到数组 nums1 的末尾，并随后使用 Arrays.sort(nums1) 进行排序，以确保合并后的数组仍然保持有序状态。

        这种方法的时间复杂度较高，为 O((m+n) log(m+n))，其中 m 和 n 分别是两个数组的长度，因为 Arrays.sort 的时间复杂度是 O((m+n) log(m+n))。在实际应用中，有更为高效的算法来合并两个有序数组，例如使用双指针法，可以在 O(m+n) 的时间复杂度内完成。

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        Arrays.sort(nums1);
    }
}

C语言

        通过使用一个循环，将数组 nums2 的元素逐个复制到数组 nums1 的末尾，并随后使用 qsort 函数进行排序，以确保合并后的数组仍然保持有序状态。qsort 函数通过调用比较函数 cmp 对整数数组进行升序排序，其中 cmp 函数返回两个整数的差值。

int cmp(int* a, int* b) {
    return *a - *b;
}
​
void merge(int* nums1, int nums1Size, int m, int* nums2, int nums2Size, int n) {
    for (int i = 0; i != n; ++i) {
        nums1[m + i] = nums2[i];
    }
    qsort(nums1, nums1Size, sizeof(int), cmp);
}

C++

        通过使用一个循环，将数组 nums2 的元素逐个复制到数组 nums1 的末尾，然后通过调用 sort 函数对整个数组进行升序排序，以确保合并后的数组仍然保持有序状态。

class Solution {
public:
    void merge(vector<int>& nums1, int m, vector<int>& nums2, int n) {
        for (int i = 0; i != n; ++i) {
            nums1[m + i] = nums2[i];
        }
        sort(nums1.begin(), nums1.end());
    }
};

Python

        通过切片赋值 nums1[m:] = nums2，将 nums2 的元素直接复制到 nums1 从索引 m 开始的位置，然后调用 sort() 方法对整个 nums1 进行升序排序，确保最终数组保持有序状态。

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        """
        Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:] = nums2
        nums1.sort()

题目描述（2）

217. 存在重复元素

力扣（LeetCode）官网 - 全球极客挚爱的技术成长平台

一个整数数组 nums 。如果任一值在数组中出现 至少两次 ，返回 true ；如果数组中每个元素互不相同，返回 false 。

示例 1：

输入：nums = [1,2,3,1]
输出：true

示例 2：

输入：nums = [1,2,3,4]
输出：false

示例 3：

输入：nums = [1,1,1,3,3,4,3,2,4,2]
输出：true

提示：

• 1 <= nums.length <= 105

• -109 <= nums[i] <= 109

解题结果

Java

        可以使用排序的方法，将数组排序后，只需遍历一次数组，检查相邻元素是否相同即可。如果相邻元素相同，则说明数组中存在重复元素，返回 true；否则，遍历完整个数组后返回 false。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        Arrays.sort(nums);
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] == nums[i - 1]) {
                return true;
            }
        }
        return false;
    }
}

        可以使用哈希集合（HashSet）来解决这个问题。遍历数组，将元素添加到哈希集合中，如果在添加过程中发现元素已经存在于集合中，说明数组中存在重复元素，返回 true；否则，遍历完整个数组后返回 false。

class Solution {
    public boolean containsDuplicate(int[] nums) {
        HashSet<Integer> set = new HashSet<>();
​
        for (int num : nums) {
            if (set.contains(num)) {
                return true;
            }
            set.add(num);
        }
​
        return false;
    }
}

C语言

        使用C语言标准库函数qsort对给定整数数组nums进行升序排序。然后，通过遍历排序后的数组，检查相邻元素是否相等，若存在相邻元素相等的情况，说明数组中有重复元素，返回true；否则，返回false，表示数组中每个元素互不相同。

int cmp(const void* _a, const void* _b) {
    int a = *(int*)_a, b = *(int*)_b;
    return a - b;
}
​
bool containsDuplicate(int* nums, int numsSize) {
    qsort(nums, numsSize, sizeof(int), cmp);
    for (int i = 0; i < numsSize - 1; i++) {
        if (nums[i] == nums[i + 1]) {
            return true;
        }
    }
    return false;
}

C++

        定义了一个名为Solution的类，其中包含一个成员函数containsDuplicate，用于判断给定整数向量nums是否包含重复元素。首先，对向量进行升序排序，然后遍历排序后的数组，检查相邻元素是否相等。如果发现相邻元素相等，说明存在重复元素，返回true；否则，返回false，表示向量中每个元素都是唯一的。

class Solution {
public:
    bool containsDuplicate(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int n = nums.size();
        for (int i = 0; i < n - 1; i++) {
            if (nums[i] == nums[i + 1]) {
                return true;
            }
        }
        return false;
    }
};

Python

        判断给定整数列表 nums 是否包含重复元素。首先，通过 if nums==[]: return False 判断若输入列表为空，则直接返回 False。然后，使用 len(nums) != len(set(nums)) 的逻辑来检查列表的长度是否与去重后的集合长度相同。如果不相同，说明存在重复元素，返回 True；否则，返回 False，表示列表中每个元素都是唯一的。这种方法通过将列表转换为集合进行去重，然后比较长度，简明而有效。需要注意的是，函数名和变量名应该使用小写字母，所以在返回 False 时应该使用小写的 false。

class Solution:
    def containsDuplicate(self, nums: List[int]) -> bool:
        if nums==[]: return false
        return len(nums) != len(set(nums))