链表 - Leetcode 2 & Leetcode 23

Posted 2022-06-21 GoldenaArcher

链表 - Leetcode 2 & Leetcode 23

github repo 地址: https://github.com/GoldenaArcher/js_leetcode，Github 的目录 大概 会更新的更勤快一些。

2. Add Two Numbers

题目地址：2. Add Two Numbers

Add Two Numbers 题目

如下：

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order, and each of their nodes contains a single digit. Add the two numbers and return the sum as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Add Two Numbers 解题思路

这道题应该来说还是比较简单的，只要知道怎么新建链表就能够完成这道题，而且题目中也说了，链表的顺序由左到右，也就不需要反转链表去实现。

整道题就跟图片上解释的那样去解就可以了：

唯一记得的事情就是可能需要补十。

使用 javascript 解 Add Two Numbers

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) 
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * 
 */
/**
 * @param ListNode l1
 * @param ListNode l2
 * @return ListNode
 */

// time complexity: O(n)
// space complexity: O(1)

var addTwoNumbers = function (l1, l2) 
  let res = new ListNode(0),
    reminder = 0;
  let dummy = res;

  while (l1 || l2) 
    let sum = (l1?.val || 0) + (l2?.val || 0) + reminder;
    reminder = sum >= 10 ? 1 : 0;
    sum = sum >= 10 ? sum - 10 : sum;
    dummy.next = new ListNode(sum);

    l1 = l1?.next;
    l2 = l2?.next;
    dummy = dummy.next;
  

  if (reminder === 1) dummy.next = new ListNode(1);

  return res.next;
;

23. Merge k Sorted Lists

题目地址：

Merge k Sorted Lists 题目

如下：

You are given an array of k linked-lists lists, each linked-list is sorted in ascending order.

Merge all the linked-lists into one sorted linked-list and return it.

Merge k Sorted Lists 解题思路

还有两种解法，包括：

• divide & conquer

  这个之后做到这部分再来回顾好了

  D&C 的时间复杂度与 PQ 一样，都是 $O(nlog(k))$

• priority queue

  主要还是 JavaScript 内部没有实现 PQ 数据结构，之前好像写过 PQ 的内容，不是很想重复一遍，等把 sort 的笔记整理出来之后再讲一下 heap 吧。

  使用 PQ 去解题是一个比较优的解题方法了，这个做法可以将时间复杂度压到 $O(nlog(k))$，就我的理解来说很难找到比这个还要快的解法。

遍历所有的结点

这个就是一个一个遍历去做，其核心思想大概如下：

每一次都遍历当前的 lists，找出最小值，然后将最小值的指针指向 next，这里下一步的操作就是：

再一步是：

如此往复：

直到链表的数组遍历完比，返回即可。

这样的解法时间复杂度为 $O(kN)$，其中 $k$ 是数组的长度，$ N $ 是链表的总长度。

每次过程中都需要比较 $k-1$ 次才能够找到当前的最小值，总体来说时间复杂度还是比较高的解法。

排序

排序的时间复杂度为 $O(nlog(n))$，这里会将所有的结点全都堆到一个新的数组里，然后再重写 sort() 中的 comparator 去进行排序，所以整体的时间复杂度是 $O($