编程之美读书笔记_3.7_队列中取最大数操作问题

3.7_队列中取最大数操作问题


若不使用C++新标准的右值引用，DeQueue的实现是低效的，因为要返回的元素，只能通过赋值操作，而不能通过引用。（书上的实现代码，竟然少了对EnQueue的实现！）

思路：用一个辅助队列来记录最大元素（为节省空间，只记录其地址），当有一个元素入队，就将辅助队列尾端不大于该元素的全部出队后（注意相等的也要出队），再将该元素压入辅助队列，这样就保证，辅助队列从头到尾的元素是递减的，辅助队列头元素是当前队列的最大值。当有一个元素出队时，就与辅助队列的头部第一个元素所指的元素比较，如果是同一个元素（注意不是相等），辅助队列头部就执行出队操作。

如果某个元素入队时，辅助队列有m次出队操作，则这所对应的m个元素在入队时，辅助队列没有执行出队操作，平均下来，每个元素入队时，辅助队列入队操作1次，出队操作1次，时间复杂度为O(1)。

为方便起见，函数名用push、pop、max，而不是EnQueue、DeQueue、MaxElement。

template<typename T>
class Queue{
 public:
  Queue(){ }
  size_t size() const{ return qa.size();}
  bool empty() const { return qa.empty();}
  const T& max() const {
    assert (!qa.empty());
    assert (!qb.empty());
    return *qb.front();
  }

  void push(const T& value)
  {
    qa.push_back(value); 
    while (!qb.empty() && value >= *qb.back()) qb.pop_back();
    qb.push_back(&qa.back());  
  }

  T pop()
  {
    assert(!qa.empty());
    assert(!qb.empty());
    if (qb.front() == &qa.front()) qb.pop_front();
    T tmp=qa.front();
    qa.pop_front();
    return tmp;
  }

 private:
   Queue (const Queue&);
   Queue& operator=(const Queue&);
   deque<T> qa;
   deque<T*> qb;
};

上面是队列的实现，如果换成栈，则要更简单：元素入栈时，如果比辅助栈的顶部元素大，就在辅助栈添加该元素，元素出栈时，如果与辅助栈的顶部元素所指的元素是同一个元素（不是相等），辅助栈就执行出栈操作。
辅助栈可以记录最大元素的地址或在栈中的相对位置，后者相比前者，
优点：可以将所用容器改为vector，并且可以直接用一个对象对另一个对象赋值；
缺点：下标方式访问元素相对较慢，特别是在deque容器。

//辅助栈记录最大元素的地址
template<typename T>
class Stack_p{
 public:
  Stack_p() { }
  size_t size() const{ return qa.size();}
  bool empty() const { return qa.empty();}
  const T& max() const {
    assert (!qa.empty());
    assert (!qb.empty());
    return *qb.back();
  }

  void push(const T& value)
  {
    qa.push_back(value);
    if (qb.empty() || value> *qb.back()) qb.push_back(&qa.back());
  }

  T pop()
  {
    assert(!qa.empty());
    assert(!qb.empty());
    if ( qb.back() == &qa.back()) qb.pop_back();
    T tmp=qa.back();
    qa.pop_back();
    return tmp;
  }

 private:
   Stack_p (const Stack_p&);
   Stack_p& operator=(const Stack_p&);
   deque<T> qa;
   deque<T*> qb;
};

//辅助栈记录最大元素在栈内的相对位置
template<typename T>
class Stack{
 public:
  size_t size() const{ return qa.size();};
  bool empty() const { return qa.empty();};
  const T& max() const 
  { 
    assert (!qa.empty());
    assert (!qb.empty());
    return qa[qb.back()];
  }

  void push(const T& value)
  {
    qa.push_back(value);
    if (qb.empty() || value> qa[qb.back()]) qb.push_back(qa.size()-1);
  }

  T pop()
  {
    assert(!qa.empty());
    assert(!qb.empty());
    if ( qa.size() == qb.back()+1) qb.pop_back();
    T tmp=qa.back();    
    qa.pop_back();
    return tmp;
  }

 private:
   deque<T> qa;
   deque<size_t> qb;
};