以 k 个节点翻转链表，js篇

反转链表，每 k 个节点反转一次，不足 k 就保持原有顺序

公司：bilibili->改编 概括： 给定这个链表：1->2->3->4->5 当 k = 2 时，应当返回: 2->1->4->3->5 当 k = 3 时，应当返回: 3->2->1->4->5 题：

// 原始数据
let listNodes = [{n:1,next:2},{n:2,next:3},{n:3,next:4},{n:4,next:5},{n:5,next:6},{n:6,next:7},{n:7,next:8},{n:8,next:9},{n:9,next:10},{n:10,next:11},{n:11,next:null}]
//结果数据
let reversNode = [{n:3,next:2},{n:2,next:1},{n:1,next:6},{n:6,next:5},{n:5,next:4},{n:4,next:9},{n:9,next:8},{n:8,next:7},{n:7,next:10},{n:10,next:11},{n:11,next:null}]

答案

个人思路解答，如不合理请指出

  let listNodes = [
  {n:1,next:2},
  {n:2,next:3},
  {n:3,next:4},
  {n:4,next:5},
  {n:5,next:6},
  {n:6,next:7},
  {n:7,next:8},
  {n:8,next:9},
  {n:9,next:10},
  {n:10,next:11},
  {n:11,next:null}
  ]
  function reverseKGroup(listNode,k){
    if (k listNode){
      return listNode
    }
    let resultList = []
    let otherN = listNode.length%k
    let times = (listNode.length - otherN)/k
    for (let i = 0; i = 0; j--) {
        let node = listNode[i*k+j]
        // 将翻转后的链表指向正确的位置 最后一个位置为空，下次循环往复赋值
        if (j+1===k) {
          node.next = null
        } else if(subList.length > 0){
          subList[subList.length - 1].next = node.n
        }
        subList.push(node)
      }
      // 分组中，让上一个分组的最后一个链指向当前分组的第一个链表
      if (resultList.length > 0) {
        resultList[resultList.length - 1].next = subList[0].n
      }
      resultList.push(...subList)
    }
    // 把不满k的剩余链表拼接上
    if (otherN > 0){
      let otherList = listNode.slice(-otherN,listNode.length)
      resultList[resultList.length - 1].next = otherList[0].n
      resultList = resultList.concat(otherList)
    }
    return resultList
  }
  let reversNode = reverseKGroup(listNodes,3)
  console.log(reversNode)

我们来看一个 LeetCode 题目：206. 反转链表 因为我觉得里面用js解答并不是很容易理解，所以我自己想了一个解法