Data structures 如何通过在O（1）中工作的方法逻辑反转堆栈？

我编写了以下堆栈代码：

#include <iostream>
using namespace std;

template <typename T>
class Stack 
{
    T *sptr;
    int cap;
    int top;
    
public:
    Stack ()
    {
        sptr = nullptr;
        top = -1;
        cap = 0;
    }
    
    void push (const T& obj)
    {
        if (top == -1)
        {
            sptr = new T[1];
            cap = 1;
            sptr[++top] = obj;
        }
        else if (cap == (top + 1))
        {
            cap *= 2;
            T *temp = new T[cap];
            for (int i = 0; i <= top; i++)
                temp[i] = sptr[i];
            temp[++top] = obj;
            delete [] sptr;
            sptr = temp;
            temp = nullptr;
        }
        else
        {
            sptr[++top] = obj;
        }
    }
    
    inline bool empty () const
    {
        return (top == -1);
    }
    
    inline int size () const
    {
        return (top + 1);
    }
    
    const T& peek () 
    {
        return sptr[top];
    }
    
    void pop ()
    {
        if (top >= 0)
        {
            if (top == 0)
            {
                top = -1;
                cap = 0;
                delete [] sptr;
            }
            else if (top >= (cap/2 -1))
            {
                top--;
            }
            else
            {
                cap /= 2;
                T *temp = new T [cap];
                for (int i = 0; i < top; i++)
                {
                    temp[i] = sptr[i];
                }
                delete [] sptr;
                sptr = temp;
                temp = nullptr;
                top--;
            }
        }
    }
    
    /*void flip() // flip method
    {
        
    }*/
};

#包括
使用名称空间std；
模板
类堆栈
{
T*sptr；
int cap；
int top；
公众：
堆栈（）
{
sptr=nullptr；
top=-1；
上限=0；
}
无效推力（常数T和obj）
{
如果（顶部==-1）
{
sptr=新的T[1]；
cap=1；
sptr[++顶部]=obj；
}
否则如果（上限==（顶部+1））
{
上限*=2；
T*temp=新的T[cap]；
对于（int i=0；i=0）
{
如果（顶部==0）
{
top=-1；
上限=0；
删除[]sptr；
}
否则如果（顶部>=（第2-1章））
{
顶部--；
}
其他的
{
上限/=2；
T*temp=新的T[cap]；
对于（int i=0；i

---

现在我想实现翻转方法，该方法将逻辑反转堆栈，使最旧的元素成为最新的元素，以便下一次pop将删除翻转之前位于堆栈底部的元素。我应该能够在O（1）中反复翻转。

在O（1）中不可能反转真正的堆栈

你能做的最好的事情就是O（n）。要看到你只需要观察，要得到堆栈的底部元素，你需要将它弹出n次

但是，您可以在O（n）中执行此操作：

你可以做什么来创建另一个堆栈，弹出内容，推另一个。当原始堆栈为空时，放下它，然后返回新的堆栈

更新：然而，您的实现是由一个数组支持的，这个数组严格来说比堆栈更坚固

您可以通过保留方向标志来反转它，并且当要求revese从头到尾切换、反转标志以及遍历方向时，也可以反转它。对于内存管理，还将有一些额外的簿记，因为您可能必须同时扩展高和低

我建议创建一个数据结构图，以便跟踪偏移量的变化

---

对于类似但大小固定的结构，您可以查看以下内容：

您需要的是一个Deque，它允许您从两端添加和删除元素：

要将其用作可逆堆栈，只需保留一个布尔变量，以确定堆栈操作将使用哪一端。

这是否会像OP所要求的那样在O（1）中工作？我认为这就是O（n）。