Question

我有一个序列options: { scales: { yAxes: [{ gridLines: { zeroLineColor: 'rgba(0, 0, 0, 0)' } }] } }。现在，我被给予一系列1 2 3 4 5 6 ... n删除 - 每个删除都是我要删除的数字。我需要用两个数字来回复每个删除 - 删除号码的左右邻居（n，如果有的话）。

E.g。我删除-1 - 我回复2，然后删除1 3我回复3，删除1 4我回复6等。

我想快速做到 - 线性 - 对数时间复杂度的线性。

我应该使用哪种数据结构？我想解决方案的关键是序列是排序的。

Answer 1

双重链接列表会很好。我们将链接存储在两个数组prev和next中，以允许O（1）访问删除。

首先，对于每个元素和两个末端的哨兵，将它链接到上一个和下一个整数：

init ():
    for cur := 0, 1, 2, ..., n, n+1:
        prev[cur] := cur-1
        next[cur] := cur+1

删除元素cur时，请更新O（1）中的链接，如下所示：

remove (cur):
    print (num (prev[cur]), " ", num (next[cur]), newline)
    prev[next[cur]] := prev[cur]
    next[prev[cur]] := next[cur]

在这里，插入num包装器以打印哨兵的-1：

num (cur):
    if (cur == 0) or (cur == n+1):
        return -1
    else:
        return cur

以下是它的工作原理：

                                       prev                  next
n = 6        prev/    print       0 1 2 3 4 5 6 7       0 1 2 3 4 5 6 7
             /next              -------------------   -------------------
init ()                          -1 0 1 2 3 4 5 6       1 2 3 4 5 6 7 8
remove (2)    1 3      1 3       -1 0   1 3 4 5 6       1 3   4 5 6 7 8
remove (3)    1 4      1 4       -1 0     1 4 5 6       1 4     5 6 7 8
remove (6)    5 7      5 -1      -1 0     1 4   5       1 4     5 7   8
remove (1)    0 4      -1 4      -1       0 4   5       4       5 7   8
remove (5)    4 7      4 -1      -1       0     4       4       7     8
remove (4)    0 7      -1 -1     -1             0       7             8

以上，为清楚起见，不再使用的部分被删除。数组的相应元素仍然存储打印在它们上面的值，但我们不再访问它们。

正如Jim Mischel正确地指出的那样（谢谢！），将列表存储在两个数组中而不是动态分配存储对于每次删除这个O（1）至关重要。

Answer 2

您可以使用二叉搜索树。从中删除是对数的。如果你想删除n个元素并且总元素的数量是m，那么从中删除n个元素的复杂性将是

<强> nlogm

删除元素并获取它的邻居

2 个答案: