如何反转一个堆栈

how to reverse a stack

本文关键字：一个 堆栈 何反转      更新时间：2023-10-16

我有一个分配，我应该采取一个堆栈，显示输出，然后反向显示输出。

它应该看起来像这样 

Stack:
262 115 74 26 34 243 22 734 113 121
Stack Reversed:
121 113 734 22 243 34 26 74 115 262

我的结果是这样的

Stack:
262 115 74 26 34 243 22 734 113 121 121 113 734 22 243 34 26 74 115 262
Stack Reversed:

有人可以看看我的代码，看看是怎么回事。我试了好几种方法，但都行不通。

#include <stdio.h>
#include <iostream>
#include "linkedStack.h"
using namespace std;
template <class Type>
void printStack(linkedStackType<Type>& stack);
template <class Type>
void reverseStack(linkedStackType<Type>& stack);
int main(int argc, char **argv)
{
   // Declare stack variables
   linkedStackType<int> stack;
   // Add some data to the stack
   stack.push(121);
   stack.push(113);
   stack.push(734);
   stack.push(22);
   stack.push(243);
   stack.push(34);
   stack.push(26);
   stack.push(74);
   stack.push(115);
   stack.push(262);
   cout << "nStack:n   ";
   printStack(stack);
   reverseStack(stack);
   cout << "nStack Reversed:n   ";
   printStack(stack);
   cout << "nn** Press any key to continue **n";
   getchar();
   return 0;
}
template <class Type>
void printStack(linkedStackType<Type>& stack)
{
   Type item;
   linkedStackType<Type> tmpStack = stack;
   while (stack.isEmptyStack() == false)
   {
      item = stack.top();
      stack.pop();
      cout << item << " ";
   }
   stack = tmpStack;

 }
template <class Type>
void reverseStack(linkedStackType<Type>& stack)
{
  Type item;
   linkedStackType<Type> tmpStack;
   while (stack.isEmptyStack() == false)
   {
      item = stack.top();
      stack.pop();
      tmpStack.push(item);
   }
   while (tmpStack.isEmptyStack() == false)
   {
      item = tmpStack.top();
      tmpStack.pop();
      stack.push(item);
      cout << item;  
   }
   stack = tmpStack;

   return;
}

我不是100%，但我想如果你删除reverseStack的第二个while循环，你的代码将工作。

template <class Type>
void reverseStack(linkedStackType<Type>& stack)
{
   Type item;
   linkedStackType<Type> tmpStack;
   while (stack.isEmptyStack() == false)
   {
      item = stack.top();
      stack.pop();
      tmpStack.push(item);
   }
   //while (tmpStack.isEmptyStack() == false)
   //{
   //   item = tmpStack.top();
   //   tmpStack.pop();
   //   stack.push(item);
   //   cout << item;
   //}
   stack = tmpStack;
   return;
}

在reverseStack()中有一个多余的打印循环，它将值打印到错误的位置。此外，这个打印循环清除tmpStack。

您的第二个while循环清空tmpStack，但随后您将现在为空的堆栈分配给stack，因此您只有一个空的堆栈。

这是我的解决方案来反转std::stack内容:

#include <stack>
#include <algorithm>    
template <class T>
class _stack : public std::stack<T>
{
    public:
        void reverse()
        {
            std::reverse(this->c.begin(),this->c.end());
        }
};
    
template <class T>
bool reverseStack(std::stack<T> & stack)
{
    bool ret = false;
    auto * s = reinterpret_cast<_stack<T>*> (&stack);
    if(s)
    {
        s->reverse();
        ret = true;
     }
     return ret;
}
    
int main()
{
   std::stack<int> stack;
   stack.push(1);
   stack.push(2);
   stack.push(3);
   stack.push(4);
   stack.push(5);
    
   reverseStack(stack);
}

您可以使用相同的方法访问容器并使用迭代器打印值。

void sortStack(struct stack **s)  
{  
if (!isEmpty(*s))  
  {  
    int x = pop(s);  
    sortStack(s);  
    sortedInsert(s, x);  
  }  
}  
void sortedInsert(struct stack **s, int x)  
{  
  if (isEmpty(*s) || x > top(*s))  
  {  
    push(s, x);  
    return;  
  }  
int temp = pop(s);  
sortedInsert(s, x);  
push(s, temp);  
}
相关文章：