LeetCode 偶数 - Java

本文将介绍 LeetCode 上一些偶数编号的问题，并给出 Java 语言的解法。

2. Add Two Numbers

题目描述

给出两个非空的链表用来表示两个非负的整数。其中，它们各自的位数是按照逆序的方式存储的，并且它们的每个节点只能存储一位数字。

如果，我们将这两个数相加起来，则会返回一个新的链表来表示它们的和。

您可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例：

输入：(2 -> 4 -> 3) + (5 -> 6 -> 4)
输出：7 -> 0 -> 8
原因：342 + 465 = 807

解法

本题为链表的简单题目，直接遍历两个链表即可。

class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode dummyHead = new ListNode(0);
        ListNode p = l1, q = l2, curr = dummyHead;
        int carry = 0;
        while (p != null || q != null) {
            int x = (p != null) ? p.val : 0;
            int y = (q != null) ? q.val : 0;
            int sum = carry + x + y;
            carry = sum / 10;
            curr.next = new ListNode(sum % 10);
            curr = curr.next;
            if (p != null) p = p.next;
            if (q != null) q = q.next;
        }
        if (carry > 0) {
            curr.next = new ListNode(carry);
        }
        return dummyHead.next;
    }
}

复杂度分析

• 时间复杂度：O(max(m, n))，其中 m 和 n 分别为两个链表的长度。我们要遍历两个链表一次，并对每一位进行计算和进位，所以时间复杂度为 O(max(m, n))。
• 空间复杂度：O(max(m, n))，答案链表的长度最多为较长链表的长度 + 1。所以，新链表的节点数为 O(max(m, n))。

4. Median of Two Sorted Arrays

题目描述

给定两个大小为 m 和 n 的有序数组 nums1 和 nums2。

请你找出这两个有序数组的中位数，并且要求算法的时间复杂度为 O(log(m + n))。

你可以假设 nums1 和 nums2 不会同时为空。

示例 1:

nums1 = [1, 3]
nums2 = [2]

则中位数是 2.0

示例 2:

nums1 = [1, 2]
nums2 = [3, 4]

则中位数是 (2 + 3)/2 = 2.5

解法

本题可以转化为寻找两个有序数组合并后第 k 小的数。

因为合并后的数组长度为 m + n，所以当 k 为奇数时，中位数为第 k 个数；当 k 为偶数时，中位数为第 k/2 和 (k/2)+1 个数的平均数。

此题解法较为复杂，需要采用递归二分的方法。

class Solution {
    public double findMedianSortedArrays(int[] nums1, int[] nums2) {
        int m = nums1.length, n = nums2.length;
        int left = (m + n + 1) / 2, right = (m + n + 2) / 2;
        return (findKth(nums1, 0, nums2, 0, left) + findKth(nums1, 0, nums2, 0, right)) / 2.0;
    }

    private int findKth(int[] nums1, int start1, int[] nums2, int start2, int k) {
        if (start1 >= nums1.length) return nums2[start2 + k - 1]; // nums1为空数组
        if (start2 >= nums2.length) return nums1[start1 + k - 1]; // nums2为空数组
        if (k == 1) return Math.min(nums1[start1], nums2[start2]); // 找第一个数

        int midVal1 = (start1 + k / 2 - 1 < nums1.length) ? nums1[start1 + k / 2 - 1] : Integer.MAX_VALUE;
        int midVal2 = (start2 + k / 2 - 1 < nums2.length) ? nums2[start2 + k / 2 - 1] : Integer.MAX_VALUE;
        if (midVal1 < midVal2) {
            return findKth(nums1, start1 + k / 2, nums2, start2, k - k / 2);
        } else {
            return findKth(nums1, start1, nums2, start2 + k / 2, k - k / 2);
        }
    }
}

复杂度分析

• 时间复杂度：O(log(m + n))。由于每次递归都可以排除掉 k/2 个元素，两个数组的元素总共只被访问了 2log(k)=O(log(k)) 次，所以时间复杂度为 O(log(m + n))。
• 空间复杂度：O(1)。只需要常数级别的空间。