使用只读堆栈排序

请考虑以下设置：

• 我们给出一个堆栈包含ñ项目。$s$$n$
• 我们可以使用常数的额外堆栈。$O(1)$
• 我们可以在这些堆栈上应用以下操作：
  1. 检查堆栈是否为空，
  2. 比较两个堆栈的顶部项，
  3. 删除堆栈中的第一项，
  4. 打印堆栈中的顶部项目，
  5. 将堆栈的顶层项目复制到另一个堆栈中，
  6. 将一个堆栈的内容复制到另一个堆栈。

请注意，这些是唯一允许的操作。我们不能交换项目，也不允许将任何项目推入任何堆栈中，除非将最上面的项目复制到堆栈中（之后，目标堆栈的先前内容将被丢弃，并且仅包含复制的项目） 。

这是一种使用比较对堆栈进行排序的算法：$O(n^2)$

last := empty
for i from 1 to n
  min := empty
  w := s
  while w is not empty
    if w.top > last and w.top < min
      min := w.top
    delete w.top
  print min
  last := min

我们可以做得更好吗？

是否有一个程序仅使用比较来打印堆栈中项目的排序列表？$O(n\log n)$

我想我现在可以证明一个不重要的下限。这个想法是用一系列比较分支程序来实现任何这样的程序。“只读”假设意味着我们的分支程序家族使用的空间很少，即空间。然后我们应用由Borodin等人证明的下限S T = Ω （n 2）。在“在非遗忘的机器上进行排序的时空折衷”中。这给我们一个n 2 / log $O(\log n)$$ST=\Omega(n^2)$$n^2/\log n$下界。

更详细一点：我们可以省去上面的操作5。宽松地说，如果我们已经可以比较两个列表的开头并打印一个列表的开头，那么就没有必要在特定寄存器上隔离列表的开头。假设这样做，我们看到机器中的每个寄存器仅存储输入的最后一个子串。

假设我们的寄存器程序有行代码和k个寄存器X 1，… ，X k。$\ell$$k$$X_1,\dots,X_k$

修复。我们为长度为n的字符串构造比较分支程序，如下所示。创建用于每个元组的一个节点（我，d 1，... ，d ķ）其中1 ≤ 我≤ ℓ 和0 ≤ d 1，... ，d ķ ≤ Ñ。这个想法是，寄存器机中的计算与分支程序中的路径相对应，并且我们位于节点（i ，d 1，… ，$n$$n$$(i,d_1,\dots,d_k)$$1\le i\le \ell$$0\le d_1 ,\dots, d_k \le n$如果我们在套准机的第 i行，并且存储在 X i中的字符串的长度是 d $(i,d_1 ,\dots, d_k)$$i$$X_i$$d_i$。现在，我们必须定义分支程序的有向边

如果$i$的格式为

如果则转到i 1否则转到i $X_u<X_v$$i_1$$i_2$

然后，对于所有，通过比较输入的d u -th和d v -th元素来标记节点（i ，d 1，… ，d k），并使“真”边变为（i 1，d 1，… ，d k）和（i 2，d 1，… ，d）的“假”边缘$d_1,\dots,d_k$$(i,d_1,\dots,d_k)$$d_u$$d_v$$(i_1,d_1,\dots,d_k)$$(i_2,d_1,\dots,d_k)$。

如果第行的格式为$i$

，转到第 i '行$X_1 \leftarrow tail(X_2)$$i'$

那么从任何节点到（i '，d 2 − 1 ，… ，d k）都有一个箭头。$(i,d_1,\dots,d_k)$$(i',d_2-1,\dots,d_k)$

如果第行的格式为$i$

$print(head(X_u))$$i'$

$(i,d_1,\dots,d_k)$$(i',d_1,\dots,d_k)$$d_u$

$\ell\cdot n^k$$O(\log n)$

您能计算元素吗？然后，我认为有一个相当简单的Mergesort实现。如果您能够在堆栈上放置其他符号，则可以使用3个堆栈来解决它，如下所示：

If we have only one element, the list is already sorted. Now assume we have already sorted the top half of the stack. We can copy the top half (in reverse order) to the second stack and place a separation symbol on top of it. Now we have again 3 Stacks (since we can ignore the already sorted symbols below the separation symbol) and can sort the lower half. Finally we can copy the sorted lower half to a third stack in reverse order and merge both halfs back to the original stack.

All operations cost linear time, therefore we have sorted the list in $O(n \log n)$

(Note, that we need stacks of size $n \log n$ because of the separation symbols, but this can be easily corrected by using another stack)

Since you can't put new elements on the stack you may get problems at the separation points. To solve this you may do the following with some additional stacks:

Copy the top $n-2^{\lfloor \log n\rfloor}$ elements to an additional stack, then proceed with the remaining elements as before. Now you know exactly the number of elements you need to consider in each step and therefore don't need any separation symbols.

Finally repeat the procedure with the additional elements at most $\log n$ times and merge them to the original stack in linear time. Sorting the stacks costs, for some constant $c$, at most $cn \log n+c\frac{n}{2} \log \frac{n}{2}+c\frac{n}{4} \log \frac{n}{4}+\ ... = O(n \log n)$ time, while merging costs an additional $O(n \log n)$.