链表添加（总大小为 n）和最后 k 个节点以 n 的顺序反转

Question

我正在关注这个挑战：

给出的是数字 m 和 p，它们都可能大到 250000。接下来的 m 行有以下命令之一：

• APPEND y，它将y 添加到我们列表（队列）的末尾
• ROTATE，反转列表的最后一个元素 p。如果列表的元素少于 p 个，它会反转列表中的所有元素。

我们的工作是在执行完所有命令后打印列表。

蛮力的方法是手动反转数组，这将具有O(pm)的复杂度，但是您需要以O(m)的复杂度来实现它.

我考虑过使用双向链表，我很确定它会起作用，但我无法完成我的答案。

示例

输入

8 3

APPEND 1
APPEND 2
APPEND 3
APPEND 4
ROTATE
APPEND 5
APPEND 6
ROTATE

输出

1 4 3 6 5 2

Answer 1

双向链表的想法是正确的。要使其正常工作，您需要摆脱上一个/下一个概念，而只需跟踪一个节点可能拥有的潜在 2 个邻居，而无需任何方向指示（上一个/下一个）。

你的双向链表会有一个头和一个尾——它们必须保留。并且您还可以维护对当前是“最后一个元素”的起始节点的节点的引用（或者当列表中没有那么多元素时更少）。每当您添加节点时，请保持更新。为了知道该引用向哪个方向移动，还要维护对它之前节点的引用。

然后，当需要执行反转时，只需将引用（和反向引用）交换到“最后一个元素”子列表的头部和尾部。不要遍历整个子列表来更改每对连续节点之间的链接。通过删除 prev/next 的想法，您可以保留那些“内部”链接。每当您需要遍历列表时，您将始终知道您来自哪一侧（即“前一个”节点是什么），因此您可以推导出哪个邻居必须是“下一个”节点。

这是该想法在 JavaScript 中的实现。在代码的末尾，针对您给出的示例输入执行算法：

class Node {
    constructor(x, neighbor1=null, neighbor2=null) {
        this.x = x;
        this.neighbors = [neighbor1, neighbor2]; // No specific order...
    }
    opposite(neighbor) { 
        // Return the neighbor that is on the other side of the argument-neighbor
        return this.neighbors[1 - this.neighbors.indexOf(neighbor)];
    }
    replaceNeighbor(find, repl) {
        let i = this.neighbors.indexOf(find);
        this.neighbors[i] = repl;
    }
}

class List {
    constructor(k) {
        this.nodeCount = 0;
        this.k = k;
        // All node references are null:
        this.head = this.tail = this.tailBeforeLastK = this.headOfLastK = null;
    }
    add(x) {
        this.nodeCount++;
        let node = new Node(x, this.tail, null);
        if (this.head === null) {
            this.headOfLastK = this.head = this.tail = node;
            return;
        }
        this.tail.replaceNeighbor(null, node);
        this.tail = node;
        if (this.nodeCount > this.k) { // Move the head of the "last K" sublist 
            [this.tailBeforeLastK, this.headOfLastK] = 
                [this.headOfLastK, this.headOfLastK.opposite(this.tailBeforeLastK)]; 
        }
    }
    reverse() {
        if (this.nodeCount < 2 || this.k < 2) return;
        // Exchange the links to the start/end of the K-last sublist
        this.tail.replaceNeighbor(null, this.tailBeforeLastK);
        if (this.tailBeforeLastK) {
            this.tailBeforeLastK.replaceNeighbor(this.headOfLastK, this.tail);
            this.headOfLastK.replaceNeighbor(this.tailBeforeLastK, null);
        }
        else this.head = this.tail;
        
        // Swap
        [this.tail, this.headOfLastK] = [this.headOfLastK, this.tail];
    }
    toArray() {
        let result = [];
        for (let prev = null, node = this.head; node; [prev, node] = 
                                                      [node, node.opposite(prev)]) {
            result.push(node.x);
        }
        return result;
    }
}

// Example
let k = 3;
// null means: REVERSE, a number means: ADD <number>:
let actions = [1, 2, 3, 4, null, 5, 6, null]; 

let list = new List(k);

for (let action of actions) {
    if (action === null) list.reverse();
    else                 list.add(action);
}
console.log(list.toArray());