用javascript分类刷leetcode15.链表(图文视频讲解)

链表操作如下图：

动画过大，点击查看

时间复杂度：

• prepend: O(1)
• append: 如果已知尾节点O(1)，否则需要遍历到尾节点，然后加入新节点O(n)
• insert: 插入到已知节点的后面O(1)，需要先查找后插入O(n)
• lookup: O(n)
• Delete：删除已知节点O(1)，需要先查找后删除O(n)

19. 删除链表的倒数第 N 个结点 (medium)

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：

输入：head = [1], n = 1
输出：[]
示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

链表中结点的数目为 sz
1 <= sz <= 30
0 <= Node.val <= 100
1 <= n <= sz

进阶：你能尝试使用一趟扫描实现吗？

方法1：栈

• 思路：循环链表，将所有的节点入栈，然后在弹出栈n次，就是我们需要删除的节点
• 复杂度：时间复杂度O(L)，L是链表的长度，空间复杂度O(L)。

方法2:遍历2次

• 思路：遍历一次链表的到链表的长度L，在重头遍历到L-n+1的位置就是需要删除的节点。
• 复杂度：时间复杂度O(L)，L是链表的长度，空间复杂度O(1)

方法3:遍历1次

动画过大，点击查看

• 思路：新建dummy节点指向head，指针n1，n2指向head，循环n2指针到n的位置，然后在同时移动n1，n2，直到结尾，n1，n2的距离是n，此时n1的位置就是需要删除元素的位置
• 复杂度：时间复杂度O(L)，L是链表的长度，空间复杂度O(1)

js:

var removeNthFromEnd = function (head, n) {
   
    let dummy = new ListNode();
    dummy.next = head;
    let n1 = dummy;
    let n2 = dummy;
    for (let i = 0; i <= n; i++) {
   //n2移动n+1次
        n2 = n2.next;
    }
    while (n2 !== null) {
   //同时移动n1，n2
        n1 = n1.next;
        n2 = n2.next;
    }
    n1.next = n1.next.next;//删除元素
    return dummy.next;
};

206. 反转链表（easy）

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：

输入：head = [1,2]
输出：[2,1]
示例 3：

输入：head = []
输出：[]

提示：

链表中节点的数目范围是 [0, 5000]
-5000 <= Node.val <= 5000

方法1.头插法：

动画过大，点击查看

• 思路：准备一个临时节点，然后遍历链表，准备两个指针head和next，每次循环到一个节点的时候，将head.next指向temp.next，并且将temp.next指向head，head和next向后移一位。
• 复杂度分析：时间复杂度：O(n)， n为链表节点数，空间复杂度：O(1)

js:

var reverseList = function (head) {
   
  let temp = new ListNode();
  let next = null;
  while (head) {
   
    next = head.next;//下一个节点
    head.next = temp.next;
    temp.next = head;//head接在temp的后面
    head = next;//head向后移动一位
  }
  return temp.next;
};

方法2.迭代法：

动画过大，点击查看

• 思路: 遍历链表，准备prev，curr，next三个指针，在遍历的过程中，让当前指针curr.next指向前一个指针prev，然后不断让prev，curr，next向后移动，直到curr为null
• 复杂度分析：时间复杂度：O(n)， n为链表节点数，空间复杂度：O(1)

js：

var reverseList = function (head) {
   
  let prev = null;
  let curr = head;
  let next = null;
  while (curr !== null) {
   
    next = curr.next;//next向后移动一位
    curr.next = prev;//让当前指针curr.next指向前一个指针prev
    prev = curr;//prev向后移动一位
    curr = next;//curr向后移动一位
    //[curr.next, prev, curr] = [prev, curr, curr.next]
  }
  return prev;
};

方法3.递归：

动画过大，点击查看

• 思路：用递归函数不断传入head.next，直到head==null或者heade.next==null，到了递归最后一层的时候，让后面一个节点指向前一个节点，然后让前一个节点的next置为空，直到到达第一层，就是链表的第一个节点，每一层都返回最后一个节点。
• 复杂度分析：时间复杂度：O(n)，n是链表的长度。空间复杂度：O(n)， n是递归的深度，递归占用栈空间，可能会达到n层

js:

var reverseList = function(head) {
   
    if (head == null || head.next == null) {
   //递归终止条件
        return head;
    }
    const newHead = reverseList(head.next);//递归调用reverseList
    head.next.next = head;//到了递归最后一层的时候，让后面一个节点指向前一个节点
    head.next = null;//前一个节点的next置为空
    return newHead;//返回最后一个节点
};

2. 两数相加 （medium）

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

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

示例 1：

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.
示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]
示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

每个链表中的节点数在范围 [1, 100] 内
0 <= Node.val <= 9
题目数据保证列表表示的数字不含前导零

• 思路：循环两个链表，计算每个节点相加的和在加进位，然后计算进位，处理最后一次的进位。
• 复杂度：时间复杂度O(max(m，n))，循环的次数是链表较长的那个。空间复杂度O(1)

js：

var addTwoNumbers = function(l1,