剑指 Offer（专项突击版）第25|26题

最新推荐文章于 2024-10-31 15:49:24 发布

Web面试那些事儿

最新推荐文章于 2024-10-31 15:49:24 发布

阅读量918

点赞数 31

分类专栏：剑指 Offer（专项突击版）文章标签：前端面试算法

本文链接：https://blog.csdn.net/Likestarr/article/details/135360504

版权

剑指 Offer（专项突击版）专栏收录该内容

14 篇文章 0 订阅

订阅专栏

前言

现在前端要求变高了,找工作的时可能会碰上算法题,每天刷几道算法题做足准备,今天是《剑指 Offer（专项突击版）》第25|26题。

剑指 Offer II 025. 链表中的两数相加

给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。

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

难度：中等

示例1：

输入：l1 = [7,2,4,3], l2 = [5,6,4] 输出：[7,8,0,7]

示例2：

输入：l1 = [2,4,3], l2 = [5,6,4] 输出：[8,0,7]

示例3：

输入：l1 = [0], l2 = [0] 输出：[0]

提示：

链表的长度范围为 [1, 100]
0 <= node.val <= 9
输入数据保证链表代表的数字无前导 0

知识点： **栈**[1] **链表**[2] **数学**[3]

方法一：栈

把表示整数的链表反转。反转之后的链表的头节点表示个位数，尾节点表示最高位数。此时从两个链表的头节点开始相加，就相当于从整数的个位数开始相加。

在做加法时还需要注意的是进位。如果两个整数的个位数相加的和超过10，就会往十位数产生一个进位。在下一步做十位数相加时就要把这个进位考虑进去。

步骤:

迭代两个链表的值放入两个栈中;
利用两个栈计算每一位的值，判断是否进位;
利用头插法构建链表;

 * 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}
 */
var addTwoNumbers = function(l1, l2) {
    let stack1 = [];
    let stack2 = [];

    
    while (l1 !== null) {
        stack1.push(l1.val);
        l1 = l1.next;
    }
    while (l2 !== null) {
        stack2.push(l2.val);
        l2 = l2.next;
    }

    let curr = null;
    let addOne = 0;

    while (addOne || stack1.length || stack2.length) {
        let val1 = stack1.length ? stack1.pop() : 0;
        let val2 = stack2.length ? stack2.pop() : 0;

        let sum = val1 + val2 + addOne;
        sum >= 10 ? addOne = 1 : addOne = 0;

        
        let currNode = new ListNode(sum % 10, curr);
        curr = currNode;
    }

    return curr;
};

复杂度分析

时间复杂度：O(max⁡(m,n))，其中 m 和 n 分别为两个链表的长度。我们需要遍历两个链表的全部位置，而处理每个位置只需要 O(1) 的时间。
空间复杂度：O(m+n)，其中 m 和 n 分别为两个链表的长度。空间复杂度主要取决于我们把链表内容放入栈中所用的空间。

剑指 Offer II 026. 重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln-1 → Ln
请将其重新排列后变为：

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

难度：中等

示例 1:

输入: head = [1,2,3,4] 输出: [1,4,2,3]

示例 2:

输入: head = [1,2,3,4,5] 输出: [1,5,2,4,3]

提示：

链表的长度范围为 [1, 5 * 104]
1 <= node.val <= 1000

知识点： **栈**[4] **递归**[5] **链表**[6] **双指针**[7]

方法一：链表中点 + 链表逆序 + 合并链表

首先把链表分成前后两半。在上图中，前半段链表包含1、2、3这3个节点，后半段链表包含4、5、6这3个节点。

然后把后半段链表反转。示例链表的后半段链表反转之后，节点的顺序变成6、5、4。

最后从前半段链表和后半段链表的头节点开始，逐个把它们的节点连接起来形成一个新的链表。先把前半段链表和后半段链表的头节点1和6连接起来，再把处在第2个位置的节点2和5连接起来，最后把两个尾节点3和4连接起来，因此在新的链表中节点的顺序是1、6、2、5、3、4。

需要解决的问题是如何把一个链表分成两半。如果能够找到链表的中间节点，那么就能根据中间节点把链表分割成前后两半。位于中间节点之前的是链表的前半段，位于中间节点之后的是链表的后半段。可以使用双节点来寻找链表的中间节点。如果一快一慢两个指针同时从链表的头节点出发，快的指针一次顺着next指针向前走两步，而慢的指针一次只走一步，那么当快的指针走到链表的尾节点时慢的指针刚好走到链表的中间节点。值得注意的问题是，链表的节点总数既可能是奇数也可能是偶数。当链表的节点总数是奇数时，就要确保链表的前半段比后半段多一个节点。

 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */

 * @param {ListNode} head
 * @return {void} Do not return anything, modify head in-place instead.
 */
var reorderList = function(head) {
  let dummy = new ListNode(0);
  dummy.next = head;
  let fast = dummy, slow = dummy;
  while (fast && fast.next) {
    slow = slow.next;
    fast = fast.next;
    if (fast.next) {
      fast = fast.next;
    }
  }
  
  let temp = slow.next;
  slow.next = null;
  
  link(head, reverseList(temp), dummy);
};

var reverseList = function(head) {
    if (!head) {
        return null;
    }
    let pre = null;
    let cur = head;
    while (cur) {
        const next = cur.next;
        cur.next = pre;
        pre = cur;
        cur = next;
    }
    return pre;
};

var link = function(node1, node2, head) {
    let prev = head;
    while (node1 && node2) {
      let temp = node1.next;
      prev.next = node1;
      node1.next = node2;
      prev = node2;
      node1 = temp;
      node2 = node2.next;
    }
    if (node1) {
      prev.next = node1;
    }
}

复杂度分析