let 链表 = [ 1, 2, 3, 4 ,5]
// 用一个匿名对象作为链表上的节点，如下伪代码：
function generateNode(data) {
    return {
        data: data, // 数据域
        next: null, // 前驱指针
        // prev: null // 后继指针
    }
}
// 声明变量 HEAD, TAIL, POINTER & length 分别指代「头指针」，「尾指针」，「游标指针」和 「链表长度」，那么构建一个双向链表如下伪代码：
let HEAD, TAIL, POINTER, length = 0;
// 创建一条长度为5的双向链表
链表.forEach((data, index, arr) => {
    let node = generateNode(data);
    // 第一个节点
    if (index === 0) {
        HEAD = node;
    }
    else {
        // 指定前驱后继指针
        [/* node.prev,  */POINTER.next] = [/* POINTER, */ node];
        // 最后一个节点
        index === arr.length - 1 && (TAIL = node)
    }
    // 指向当前节点
    POINTER = node;
    ++length;
});
// 游标指针回退到头部
POINTER = HEAD;

'k个为1组去反转链表'
var reverseKGroup = function (head, k) {
    /*
        给定这个链表：1->2->3->4->5
        当 k = 2 时，应当返回: 2->1->4->3->5
        当 k = 3 时，应当返回: 3->2->1->4->5
    */
    if (head === null || k === 1) {
        return head;
    }

    let cnt = 0;
    const dummy = {
        next: head,
    };
    let start = dummy;
    let end = head;

    while (end !== null) {
        cnt++;
        if (cnt % k !== 0) {//end不是第k个
            end = end.next;
        } else {//end是第k个
            start = reverseList(start, end.next);//每次反转该组头尾之间的所有节点
            end = start.next;// 然后将链表重新拼起来即可
        }
    }

    return dummy.next;
};
        '用来反转链表的方法'// 翻转head到tail之间的部分，不包括head和tail   // 返回原链表的第一个元素，也就是翻转后的最后一个元素
        reverseList= (s, e) => {//输入两个链表
            if (s === null || s.next === null) return s;
            let cur = s.next;
            first = cur;
            let pre = s; // 这里就是翻转不包括head的原因，否则就是head.pre了（当然我们没有pre指针）
            // 这里就是翻转不包括tail的原因，否则就是tail.next了。
            while (cur !== e) {
                const next = cur.next;
                cur.next = pre;
                pre = cur;
                cur = next;
            }
            // 拼接
            s.next = pre;
            first.next = cur;
        
            return first;
        }
reverseKGroup(HEAD,2)