使用 push(x)、pop() 和 pop_max() 方法实现队列

Question

我遇到了这样一个问题：用 push(x)、pop() 和 pop_max() 方法实现一个队列。

pop_max() 函数应该按照 FIFO 规则弹出最大的元素。

例如： pop_max()之前：front-> 2,3,4,5,1,5

pop_max() 之后：front-> 2,3,4,1,5

以下是我的一些尝试。

1. 用基本队列实现它，使用支持队列通过 O(n) 扫描找到最大元素。

   pop()/push() 是 O(1)，pop_max() 应该是 O(n)。

2. 用双链表和单调栈实现它。

   pop()/pop_max() 是 O(1)，push() 应该是 O(n)。

有人知道以最小的时间复杂度做到这一点的方法是什么？我看过这个Implement a queue in which push_rear(), pop_front() and get_min() are all constant time operations，它提供的方法似乎不适合这个场景。

Answer 1

根据要求，这里有一个关于我为什么相信的详细答案 有一个最坏情况 O(1) 推送和弹出以及 O(log n) 的解决方案 流行音乐。 太复杂了，你不需要理解 它用于采访。真的。我写这个答案主要是为了娱乐 [算法] 标签正则。

变量

n 是当前结构中的元素个数，p 是 结构生命周期内的推动次数。显然 n ≤ p，并且在 一般来说，log p 不是 O(log n)。

比赛树

主要构建块是锦标赛树。锦标赛树是 带有标签的完整二叉树（每个节点都有零个或两个子节点） 节点，使得每个具有两个子节点标记为 x 和 y 的节点都被标记 最大值（x，y）。从语义上讲，这个数据结构的内容是 具有零个子节点（叶子）的节点的标签。如果你感到困惑，请查看 单淘汰锦标赛的完整括号。

锦标赛树的有用之处在于我们可以对叶子进行排序 任何我们想要的方式。对于这个问题，我们需要队列顺序。根 元素给出整体最大标签。找到最左边的叶子 标签，如果标签相同，则重复下降到左孩子 当前节点，否则为右节点。要软删除叶子，请将其设置为 值为 -∞ 并将其祖先从父更新为根。

摊销 O(1) 推送和最坏情况 O(log p) 弹出最大值

在实践中有更好的方法来实现这一点，但我们的目标是 是为了展示想法。

我们保留一个 O(log p) 锦标赛树的链表。串联起来，他们的 叶子代表队列。每棵树都是一棵完全二叉树 2^k 个叶子（计数中包括软删除的元素） 对于某个整数 k ≥ 0。

推送操作类似于将二进制数加一 表示。我们将新元素单独放入锦标赛树中 并将该树附加到列表中。而列表中的最后两棵树 具有相同的大小，通过制作第二个将它们组合成一棵树 最后一个新树的左孩子和最后一个右孩子。

pop-max 操作扫描树根以找到整体最大值，然后 软删除最左边的匹配项。

最坏情况 O(1) 推送

我们可以更懒惰地合并树木。而不是完成合并 立即循环，我们保留一个延续队列。每一个延续 可以表示为指向列表中树的可变指针。踏步 它，我们将树的大小与其左邻居的大小进行比较；如果 它们是相同的，然后合并树并更新指向 合并树。否则，继续完成。

push 操作附加一个单例树，附加一个延续 指向那棵树到队列的后面，然后继续 在前面工作几步。任何时候都会有 O(log p) 合并要继续，所以 pop-max 仍然运行得足够快。 （这来自摊销分析。）

定期流行音乐

我们可以在最坏情况时间 O(log p) 中实现弹出操作 向锦标赛树添加双向链表结构不会 尚未删除。比赛使用软删除；此列表使用硬 删除。

显然，我们希望 pop 在恒定时间内运行。我们可以得到常数 摊销时间，通过分割最左边的锦标赛树直到它 软删除之前的一个元素（带有某种障碍以确保 之前的合并延续不理会这个前缀）。

通过像我们这样的更多调度应该可以实现最坏情况下的恒定时间 为推动而做。

最坏情况 O(log n) pop-maxes

别介意挥手，此时基本上是我的整个手臂。我们的 策略是通过定期将 p 的有效值限制为 O(n) 在后台重建整个结构。这意味着发出 pop 重建操作并记住我们在重建中的距离 这样我们就可以在需要时发出 pop-maxes。假设我们做多个 每次操作都会推动重建，我们将在弹出之前完成 pop-maxes 可以将元素计数减少超过一个常数 分数。

开放式问题

我确信有一种更简洁的方法可以完成这一切。这是什么？

Answer 2

首先让我们争论一个目标运行时间。我们可以使用这种抽象数据类型对一个 n 元素列表进行排序，其中 n 个 pushes 后跟 n 个 pop-maxes。假设通用可比较元素，由于可能的最快比较排序是 Θ(n log n)，因此最坏情况的 push/pop-max 对必须是 Ω(log n)。

在下面的 C++ 中实现了为所有三个操作获得 O(log n) 最坏情况的一种方法。通过摊销会计，我们可以使推送 O(log n) 以及 pop 和 pop-maxes 免费。

这确实留下了我们是否可以获得最坏情况下的 O(1) 推送、O(1) 弹出和 O(log n) 最大弹出的问题。我相信答案是肯定的，但是我想到的解决方案相当复杂，涉及在队列的大小呈几何级数减小的段上定期维护 O(log n) 锦标赛树。

#include <list>
#include <map>

template <typename T> class QueueWithPopMax {
public:
  void Push(T element) {
    typename std::list<ListElement>::iterator back =
        list_.insert(list_.end(), ListElement{});
    back->iterator = multimap_.insert({element, back});
  }

  T Pop() {
    T element = list_.front().iterator->first;
    multimap_.erase(list_.front().iterator);
    list_.pop_front();
    return element;
  }

  T PopMax() {
    T element = multimap_.begin()->first;
    list_.erase(multimap_.begin()->second);
    multimap_.erase(multimap_.begin());
    return element;
  }

private:
  struct ListElement {
    typename std::multimap<T, typename std::list<ListElement>::iterator,
                           std::greater<T>>::iterator iterator;
  };
  std::multimap<T, typename std::list<ListElement>::iterator, std::greater<T>>
      multimap_;
  std::list<ListElement> list_;
};

#include <iostream>

int main() {
  QueueWithPopMax<int> queue;
  queue.Push(2);
  queue.Push(3);
  queue.Push(4);
  queue.Push(5);
  queue.Push(1);
  queue.Push(5);
  std::cout << queue.PopMax() << "\n";
  std::cout << queue.Pop() << "\n";
  std::cout << queue.Pop() << "\n";
  std::cout << queue.Pop() << "\n";
  std::cout << queue.Pop() << "\n";
  std::cout << queue.Pop() << "\n";
}