Question

我想创建一个函数来获取堆栈（作为数组）并且它返回堆栈，用堆栈中的最后一个元素交换第一个元素所以我将使用临时堆栈的数据我会用的但我怎么知道什么时候能到达堆栈的最后？

我已经将堆栈的实现写成了一个数组但我需要函数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

我不知道我是否真的理解你的问题，但看起来你希望堆栈的第一个元素是最后一个，最后一个是第一个。如果是这样，你还没有真正理解堆栈如何工作以及何时使用它，因为堆栈就像现实生活中的堆栈一样。例如，你会在其中一个经典的圆柱体中找到一堆Pringles（是的薯片）。现在，堆栈允许您只访问堆栈顶部的元素（添加的最后一个对象），这是因为如果您尝试取出其中一个中心，堆栈将会崩溃。但是如果你想在中心获得一个元素，你必须从顶部获取这么多元素直到你到达那个元素，但是如果你做了类似的事情，那么你使用的是错误的堆栈！堆栈是为了按顺序收集对象（如列表），但只能访问顶部。例如，您可以将它用于编辑器中的撤消功能，在此处将您执行的所有操作添加到堆栈中。现在，如果您使用撤消功能，可以撤消下一个操作之后的操作，但是如果您现在执行不同的操作，则会在堆栈顶部添加一个新元素，并且这些元素无法再次放置在该操作上，因此它们只是破碎了（如果你愿意，可以吃它们）（就像时间悖论：“你不能撤消你没做过的事情而且你不能重做一些你永远不会做的事情”。）

我希望我能帮助你理解堆栈的基本工作，但是如果你有任何其他问题或我错过了解你的问题，请纠正我。

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

我从未在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 ++交换堆栈中的第一个和最后一个元素

2 个答案: