[路飞]_一起刷leetcode 25. K 个一组翻转链表

·  阅读 285
[路飞]_一起刷leetcode 25. K 个一组翻转链表

「这是我参与11月更文挑战的第2天,活动详情查看:2021最后一次更文挑战

题目:

25. K 个一组翻转链表

给你一个链表,每 k 个节点一组进行翻转,请你返回翻转后的链表。

k 是一个正整数,它的值小于或等于链表的长度。

如果节点总数不是 k 的整数倍,那么请将最后剩余的节点保持原有顺序。

进阶:

  • 你可以设计一个只使用常数额外空间的算法来解决此问题吗?
  • 你不能只是单纯的改变节点内部的值,而是需要实际进行节点交换。

 

示例 1:

输入: head = [1,2,3,4,5], k = 2
输出: [2,1,4,3,5]
复制代码

示例 2:

输入: head = [1,2,3,4,5], k = 3
输出: [3,2,1,4,5]
复制代码

示例 3:

输入: head = [1,2,3,4,5], k = 1
输出: [1,2,3,4,5]
复制代码

示例 4:

输入: head = [1], k = 1
输出: [1]
复制代码

提示:

  • 列表中节点的数量在范围 sz 内
  • 1 <= sz <= 5000
  • 0 <= Node.val <= 1000
  • 1 <= k <= sz

思路:

  1. 计算出链表的总长度total
  2. 计算出链表需要执行多少次翻转count = Math.floor(total / k)
  3. 执行count次翻转,每次翻转完拼接到已经整理好的链表中
  4. 剩余不足k的链表直接添加到已经整理好的链表中

实现:

/**
 * Definition for singly-linked list.
 * function ListNode(val, next) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.next = (next===undefined ? null : next)
 * }
 */
/**
 * @param {ListNode} head
 * @param {number} k
 * @return {ListNode}
 */
function reverseKGroup(head, k) {
  let total = 0;
  let cur = head;
  // 统计链表的总长度
  while (cur) {
    cur = cur.next;
    total++;
  }

  // 计算需要经过多少次翻转
  const count = Math.floor(total / k);
  let result, temp;

  // 遍历进行翻转
  for (let i = 0; i < count; i++) {
    let { prev, next } = reverseNode(head, k);
    head = next;

    // 第一次翻转完作为头节点
    if (i === 0) {
      result = prev;
      temp = result;
    } else {
      // 链接后的数据走到最后,等待接下一组翻转后的节点
      while (temp.next) {
        temp = temp.next;
      }
      temp.next = prev;
    }
  }

  // 链接后的数据走到最后,等待接下一组翻转后的节点
  while (temp.next) {
    temp = temp.next;
  }
  temp.next = head;
  return result;
}

// 翻转链表前K个元素
function reverseNode(cur, k) {
  let prev = null;
  let next = null;

  while (k) {
    next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
    k--;
  }

  return {
    prev,
    next,
  };
}

复制代码

优化

回顾上面代码发现写了很多冗余代码,比如说每次你拿到整理好的链表后,你还得对链表进行k轮的向后取值操作 temp = temp.next; 而且一开始还得先经过一轮统计total,相当于遍历了链表三次。所以做了如下的调整:

  1. 取消第一次先求total的操作, 改成用index在每次翻转前计数,满足index === k执行翻转
  2. 每次翻转结束不返回整段链表了,只返回头节点和尾节点
  3. 把已经整理好的节点的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
 * @param {number} k
 * @return {ListNode}
 */
function reverseKGroup(head, k) {
  // 一个一组就不用旋转了
  if (k === 1) {
    return head;
  }
  // 创建一个空节点, 待会儿就不用每次循环都要判断是否头节点了。结果返回result.next即可
  let result = { val: 0, next: null };
  let cur = head;

  let prev = result; // 缓存上一个末尾节点
  
  while (cur) {
    let index = 1;
    let temp = cur;
    while (index < k && temp.next) {
      temp = temp.next;
      index++;
    }

    const next = temp && temp.next;

    // 满足k个一组,做旋转操作, 不满足则游戏结束
    if (index === k) {
      let { first, last } = reverseNode(cur, k);
      prev.next = first; // 上一轮的尾节点指向这一轮的头节点
      prev = last;
    } else {
      prev.next = cur;
    }

    cur = next;
  }

  return result.next;
}

// 翻转链表前K个元素
function reverseNode(cur, k) {
  let last = cur; // 当前的头节点翻转后就是尾节点

  let prev = null;
  let next = null;

  while (k) {
    next = cur.next;
    cur.next = prev;
    prev = cur;
    cur = next;
    k--;
  }

  return {
    first: prev,
    last,
  };
}

复制代码

看懂了的小伙伴可以点个关注、咱们下道题目见。如无意外以后文章都会以这种形式,有好的建议欢迎评论区留言。

分类:
前端
标签:
分类:
前端
标签: