栈结构

颠倒一个栈的元素顺序

问题：假设有一个栈{1,2,3,4,5,6}，6是栈顶，1是栈底，现在要把这个栈中的元素颠倒一下。

思路：最简单的办法当然是把栈中的元素依次pop到一个数组中，然后把这个数组再push回栈里面即可，但这样需要O(n)的辅助空间。

下面介绍一种仅使用O(1)辅助空间的算法，我们知道，可以使用递归来模拟栈的操作。我们借助函数递归pop元素，这样在递归的函数栈上依次有

{6,5,4,3,2,1}，1是栈顶，6是栈底，然后在递归返回的时候，如何把当前元素塞到原栈的底部呢？这里借助了另一个递归！

C++代码实现如下：

void Add2Bottom(stack<int> &s, int val)
{
    int top;

    if (s.empty()) {
        s.push(val);

    } else {

        top = s.top();

        s.pop(); 

        Add2Bottom(s, val);

        s.push(top);
    }
}

void Reverse(stack<int> &s)
{
    int top;

    if (!s.empty()) {

        top = s.top();

        s.pop();

        Reverse(s);

        Add2Bottom(s, top);
    }
}

int main()
{

    int n;
    int array[6] = {1,2,3,4,5,6};

    stack<int> s;

    for (n=0; n<6; n++) s.push(array[n]);

    Reverse(s);

    while (!s.empty()) {

        cout<<s.top()<<endl;
        s.pop();

    }   

}

栈的push、pop序列

用栈实现队列

设2 个栈为A和B，A用作入队，B用作出队。
队满：A满且B不为空；
队空：A和B都为空；
入队：
(1) 如果A未满，将新元素push 入栈A；
(2) 如果A已满，将栈A中所有元素依次pop 出并push 到栈B，然后将元素入栈A；
出队：
(1) 如果B为空，则将栈A 中所有元素依次pop 出并push 到栈B，然后将元素出栈B；
(2) 如果B不为空，将栈B 的栈顶元素pop 出；

C++代码实现：

bool queue_empty(stack<int> &s1, stack<int> &s2)
{
    return s1.empty() && s2.empty();
}

void enqueue(stack<int> &s1, stack<int> &s2, int val)
{
    s1.push(val);
}

void dequeue(stack<int> &s1, stack<int> &s2, int &val)
{
    int top;

    if (s2.empty()) {

        while (!s1.empty()) {
            top = s1.top();
            s1.pop();
            s2.push(top);
        }
    }   

    if (!s2.empty()) {
        val = s2.top();
        s2.pop();

    } else {
        cout<<"error: queue is empty"<<endl;
    }
}

int main()
{

    int n;
    int array[6] = {1,2,3,4,5,6};

    stack<int> s1;
    stack<int> s2; 

    for (n=0; n<6; n++) enqueue(s1, s2, array[n]);

    while (!queue_empty(s1, s2)) {

        dequeue(s1, s2, n);
        cout<<n<<endl;
    }

}

注意：这里没有考虑栈空间可能满的问题。

其实，也可以用一个栈来模拟队列结构，仍然是借助递归栈，每次往栈插入元素时，把它塞到栈底，这样就实现了FIFO的队列结构。

代码如下：

void enqueue2(stack<int> &s, int val)
{
    int top;

    if (s.empty()) {
        s.push(val);

    } else {

        top = s.top();
        s.pop();

        enqueue2(s, val);

        s.push(top);
    }
}

int main()
{

    int n;
    int array[6] = {1,2,3,4,5,6};

    stack<int> s;

    for (n=0; n<6; n++) enqueue2(s, array[n]); 

    while (!s.empty()) {

        n = s.top();
        s.pop();
        cout<<n<<endl;
    }
}

用队列实现栈

设2 个队列为A和B，A用作入队/出队，B用作辅助。
队满：A满且B不为空；
队空：A和B都为空；
入栈：将新元素插入队列A；
出栈：
(1) 除最后一个元素外，将队列A的元素全部插入到队列B；
(2) 将队列A的最后一个元素出队；

(3) 将队列B的元素换回到队列A；

void stack_pop(queue<int> &q1, queue<int> &q2, int &n)
{
    int i, head;

    while (!q1.empty()) {

        head = q1.front();
        q1.pop();

        if (q1.empty()) {
            n = head;

        } else {
            q2.push(head);
        }
    }

    while (!q2.empty()) {
        head = q2.front();
        q1.push(head);
        q2.pop();
    }
}

int main()
{

    int n;
    int array[6] = {1,2,3,4,5,6};

    queue<int> q1, q2;

    for (n=0; n<6; n++) q1.push(array[n]);

    while (!q1.empty()) {
        stack_pop(q1, q2, n);
        cout<<n<<endl;
    }
}