使用C ++交换堆栈中的第一个和最后一个元素

Question

我想制作一个函数来获取堆栈（作为数组）并将它 return 堆栈交换堆栈中的第一个元素和最后一个元素所以我将为数据使用临时堆栈我会用但是我怎么知道我什么时候到达堆栈的末尾？

我已经把栈的实现写成了一个数组但我需要有关函数 swap

的帮助

void Swap(Stack x)
{
Stack tmp(100);
int top1 = x.pop;

for (int i = 0;; i++)
{
x.pop = tmp.push;
}

}

我知道这是错误的，但我不确定任何帮助，将不胜感激，谢谢编辑我一开始是这样写函数的，发现不能带参数

void stack::Swap()
{
Stack tmp(100);
int top1 =  this->pop;

for (int i = 0;; i++)
{
this->pop = tmp.push
}

};

这里编辑的是答案中的代码

Stack Swap(Stack x){

int mytop,mybottom;

mytop=x.pop();

int tmp[x.length-2],i=0;

while(!x.isEmpty()){

    mybottom=x.pop();

    tmp[i++]=mybottom;


    }

Stack returnIt;

returnIt.push(mytop);

for(i=0;i<=x.length -3;i++){

    returnIt.push(tmp[i]);

    }

returnIt.push(mybottom);

return returnIt;

}

Answer 1

IDEA : 将堆栈的顶部和底部存储在变量中，将顶部和底部之间的元素存储在数组中。现在你只需将原始堆栈的底部推入新堆栈，然后按原始顺序将元素推入新堆栈，最后将原始堆栈的顶部推入。

code.

#include <bits/stdc++.h>
using namespace std;
void rev(stack<int>&x){
    int sz=x.size(),mytop,mybottom;
    mytop=x.top();
    x.pop();
    int tmp[sz-1],i=0;
    while(!x.empty()){
        mybottom=x.top();
        tmp[i++]=mybottom;
        x.pop();
        } 
    stack<int> returnIt;
    returnIt.push(mybottom);
    for(i=0;i<=sz-3;i++){
        returnIt.push(tmp[i]);
        }
    returnIt.push(mytop);
    while(!returnIt.empty()){
        int tt=returnIt.top();
        x.push(tt);
        returnIt.pop();
    }
    }
int main() {
    // your code goes here
    stack<int>x;
    x.push(1);
    x.push(2);
    x.push(3);
    x.push(4);
    x.push(5);
    stack<int>y=x;
    cout<<"Before reversing : ";
    while(!y.empty()){
        int tt=y.top();
        cout<<tt;
        y.pop();
    }

    rev(x);
    cout<<"\nAfter reversing : ";
    while(!x.empty()){
        cout<<x.top();
        x.pop();
    }
    return 0;
}

Answer 2

我不知道我是否真的正确理解了你的问题，但看起来你希望堆栈的第一个元素是最后一个，最后一个是第一个。如果是这样，你还没有真正理解堆栈的工作方式以及何时使用它，因为堆栈就像现实生活中的堆栈一样。例如，您将一堆品客薯片（是的薯片）放在一个经典的圆柱体中。现在堆栈允许您只访问堆栈顶部的元素（添加的最后一个对象），那是因为如果您尝试取出中心之一，堆栈将会崩溃。但是如果你想在中心获取一个元素，你必须从顶部获取很多元素直到你到达那个元素，但是如果你这样做，你就使用了错误的堆栈！堆栈用于按添加顺序收集对象（如列表），但只能访问顶部。例如，您可以将其用于编辑器中的撤消功能，在那里您可以将您执行的所有操作添加到堆栈中。现在如果你使用撤消功能，下一个动作之后的一个可以被撤消，但是如果你现在做一个不同的动作，堆栈顶部有一个新元素，你已经采取的这些不能再放在上面，所以他们只是坏了（你想吃就吃）（就像一个时间悖论："You cant undo something you havent done and you cant redo something you will never have done"）。

我希望我能帮助您理解堆栈的基本工作，但如果您有任何其他问题或者我没有理解您的问题，请纠正我。

但是如果你真的想做，你正在尝试什么，你必须考虑，你如何在现实生活中做这样的事情：你必须从堆栈中取出每个元素，一个接一个，然后在中间以相同的顺序构建一个新堆栈，但是您放入堆栈的第一个索引是旧堆栈中的第一个。

我从来没有真正用 C++ 编程过，但在伪代码中它可能看起来像这样：

Stack stack;
List<StackElement> list;
//Converting stack to list for better access
for(int i = 0; i<stack.size;i++)
{
    list.add(stack.top);
    stack.pop;
}
//Add the last element from the list (the last from the stack) on top of the stack (thats now the only object in the stack)
stack.push(list.get(list.size()-1));
list.remove(list.size()-1); //Remove this element
//Save our last element
StackElement lastElement = list.get(0);
list.remove(0);
//Inserting the mid
for(int i = 0; i<list.size;i++)
{
    stack.push(list.get(i));
}
//Now put the last element from the old stack on top of the new
stack.push(lastElement):

对不起我的英语不好，我希望你能理解我想说的基本内容。而且代码只是理论，可能是错误的！

使用C ++交换堆栈中的第一个和最后一个元素

swapping the first and last element in a stack using c++

arrays

stack

swap