棧的面試題總結

1.不用輔助空間實現棧的逆序（利用函數的遞歸）
例如棧中元素1 2 3 4，逆序後棧中元素爲4 3 2 1

int GetLastNumOfStack(stack<int>& s)// 得到棧頂的元素
{
    int result = s.top();//取棧頂元素
    s.pop();//出棧
    if(s.empty()==true)
        return result;//若是棧頂元素，則將該元素返回到上級函數
    int last = GetLastNumOfStack(s);//接受返回的棧頂元素
    s.push(result);//並將此時出棧的元素壓入棧中（除棧頂元素外）
    return last;//將棧頂元素返回到上級函數
}
void ReseriveStack(stack<int>& s)//利用遞歸實現棧元素逆序
{
    if(s.empty()==true)
        return;
    int i = GetLastNumOfStack(s);//得到第一個棧底元素
    ReseriveStack(s);//函數遞歸
    s.push(i);//元素壓棧
}

測試代碼

int main()
{
    stack<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    ReseriveStack(s);
    return 0;
}

2.得到GetMin功能的棧

• 方法一：

#include<stdio.h>
#include<stack>
#include<iostream>
using namespace std;
#include<stack>

template<class T>
class Stack
{
public:
    Stack()
    {}

    void Push(const T& data)
    {
        StackData.push(data);
        if(StackMin.empty() || StackMin.top() > data)
            StackMin.push(data);
        else
            StackMin.push(StackMin.top());//StackData的值和StackMin元素的個數相同
    }

    void Pop()
    {
        if(StackData.empty())
            return;
        StackData.pop();
        StackMin.pop();
    }

    T GetMin()
    {
        return StackMin.top();
    }

private:
    stack<T> StackData;
    stack<T> StackMin;
};

• 方法二：

#include<stack>

template<class T>
class Stack
{
public:
    Stack()
    {}

    void Push(const T& data)
    {
        StackData.push(data);
        if(StackMin.empty() || StackMin.top() > data)
            StackMin.push(data);
    }

    void Pop()
    {
        if(StackData.empty())
            return;
        int value = StackData.top();
        StackData.pop();
        if(value == StackMin.top())
            StackMin.pop();
    }

    T GetMin()
    {
        return StackMin.top();
    }

private:
    stack<T> StackData;
    stack<T> StackMin;
};

測試代碼：

void funtest()
{
    Stack<int> s;
    s.Push(4);
    s.Push(1);
    s.Push(3);
    s.Push(2);
    s.Push(5);

    s.Pop();

    int ret = s.GetMin();
}

int main()
{
    funtest();
    getchar();
    return 0;
}

兩種方法的比較：
兩種方法的時間複雜度都相同，都爲O（1），且空間複雜度都爲O（N）；區別是：方法一中StackData入棧的時候要浪費空間，但是彈出的時候節省時間，方法二中StackData入棧的時候要節省空間，但彈出時浪費時間。

3.由兩個棧實現一個隊列

template<class T>
class Queue
{
public:
    Queue()
    {}

    void Push(const T& value)
    {
        StackPush.push(value);
    }

    void Pop()
    {
        if(StackPop.empty() && StackPush.empty())
            return;
        if(StackPop.empty())
        {
            while(!StackPush.empty())
            {
                int num = StackPush.top();
                StackPop.push(num);
                StackPush.pop();
            }
        }
        StackPop.pop();
    }

private:
    stack<int> StackPush;
    stack<int> StackPop;
};

測試代碼：

int main()
{
    Queue<int> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);

    q.Pop();

    getchar();
    return 0;
}

4.用一個棧來實現另一個棧的排序,要求棧由棧頂到棧底從大到小

void SortStackByStack(stack<int>& stackData)
{
    //由題意知，stackData由棧頂到棧底從大到小排序，則help由棧頂到棧底從小到大排序
    stack<int> help;

    if(stackData.empty())
        return;
    while(!stackData.empty())
    {
        int value = stackData.top();
        stackData.pop();
        if(help.empty() || value <= help.top())
            help.push(value);
        if(value > help.top())
        {
            while(!help.empty() && value > help.top())
            {
                int num = help.top();
                help.pop();
                stackData.push(num);
            }
            stackData.push(value);
        }
    }
    while(!help.empty())
    {
        int ret = help.top();
        help.pop();
        stackData.push(ret);
    }
}

測試代碼：

void funtest()
{
    stack<int> s;
    s.push(6);
    s.push(5);
    s.push(4);
    s.push(3);
    s.push(2);
    s.push(1);

    SortStackByStack(s);
}

int main()
{
    funtest();
    getchar();
    return 0;
}