两数之和

来源：力扣（LeetCode） 链接：leetcode.cn/problems/tw…

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target 的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9 输出：[0,1] 解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

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

示例 3：

输入：nums = [3,3], target = 6 输出：[0,1]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案

代码

class Solution {
    public int[] twoSum(int[] nums, int target) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i = 0; i < nums.length; i++) {
            int complement = target - nums[i];
            if (map.containsKey(complement)) {
                return new int[] { map.get(complement), i };
            }
            map.put(nums[i], i);
        }
        throw new IllegalArgumentException("No two sum solution");
    }
}

思路分析

这个算法的时间复杂度是O(n)，其中n是数组中元素的数量。

首先，这个算法使用了一个哈希表（HashMap），将数组中的值和它们对应的索引保存在哈希表中。然后，对于每个元素，在哈希表中查找是否存在与它对应的差值，即target - nums[i]。如果存在，就说明已经找到了两个数，返回它们的索引即可。如果不存在，则将当前元素及其索引添加到哈希表中。

这个算法的优点是它的时间复杂度为O(n)，因为只需要遍历一遍数组，而不是使用嵌套循环来遍历数组。缺点是需要额外的空间来存储哈希表，因此空间复杂度是O(n)。

寻找两个正序数组的中位数

来源：力扣（LeetCode） 链接：leetcode.cn/problems/me…

给定两个大小分别为 m 和 n 的正序（从小到大）数组 nums1 和 nums2。请你找出并返回这两个正序数组的中位数。

算法的时间复杂度应该为 O(log (m+n)) 。

示例 1：

输入：nums1 = [1,3], nums2 = [2] 输出：2.00000 解释：合并数组 = [1,2,3] ，中位数 2

示例 2：

输入：nums1 = [1,2], nums2 = [3,4] 输出：2.50000 解释：合并数组 = [1,2,3,4] ，中位数 (2 + 3) / 2 = 2.5

提示：

• nums1.length == m
• nums2.length == n
• 0 <= m <= 1000
• 0 <= n <= 1000
• 1 <= m + n <= 2000
• -106 <= nums1[i], nums2[i] <= 106

代码

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int n1 = nums1.length;
        int n2 = nums2.length;
        if (n1 > n2) {
            return findMedianSortedArrays(nums2, nums1);
        }
        int k = (n1 + n2 + 1) / 2;
        int left = 0;
        int right = n1;
        while (left < right) {
            int m1 = left + (right - left) / 2;
            int m2 = k - m1;
            if (nums1[m1] < nums2[m2 - 1]) {
                left = m1 + 1;
            } else {
                right = m1;
            }
        }
        int m1 = left;
        int m2 = k - left;
        int c1 = Math.max(m1 <= 0 ? Integer.MIN_VALUE : nums1[m1 - 1],
                m2 <= 0 ? Integer.MIN_VALUE : nums2[m2 - 1]);
        if ((n1 + n2) % 2 == 1) {
            return c1;
        }
        int c2 = Math.min(m1 >= n1 ? Integer.MAX_VALUE : nums1[m1],
                m2 >= n2 ? Integer.MAX_VALUE : nums2[m2]);
        return (c1 + c2) / 2.0;
    }
}

思路分析

这个算法的时间复杂度是O(log(min(m,n)))，其中m和n分别是nums1和nums2的长度。

这个算法的思路是利用二分查找来找到两个数组的中位数。首先，如果nums1的长度大于nums2的长度，交换两个数组，这样我们可以确保nums1的长度始终小于等于nums2的长度。然后，我们用二分查找来找到nums1中的一个位置m1，以及nums2中的一个位置m2，使得：

nums1[0], nums1[1], ..., nums1[m1-1], nums2[0], nums2[1], ..., nums2[m2-1] 这些元素组成的集合中，元素的个数为k。

我们用left和right来表示m1的可能范围，即[left, right)。初始时，left=0，right=n1。然后，每次迭代时，我们将m1设置为(left+right)/2，并计算出m2=k-m1。然后，我们比较nums1[m1]和nums2[m2-1]的大小关系。如果nums1[m1]小于nums2[m2-1]，那么说明我们需要将m1向右移动，即left=m1+1。否则，我们需要将m1向左移动，即right=m1。重复这个过程，直到left=right。最终，我们就可以得到中位数。

如果m1或m2超出了数组的范围，我们可以将相应的元素设置为负无穷大或正无穷大。然后，我们使用这些元素来计算中位数。