栈面试题总结

1.求栈上的最小值

具体要求：在O（1）的时间复杂度内求出栈上的最小值，并且不受出栈入栈的影响。
思路：借助一个辅助栈，原栈在有数据入栈的时候，辅助栈也有数据入栈。辅助栈入栈的数据为当前的最小值。
实现：

template<typename T>
class StackMin
{
public:
    void Push(const T&data);
    void Pop();
    T Min();
private:
    stack<T>st1;
    stack<T>st2;
};

template<typename T>
void StackMin<T>::Push(const T&data)
{
    st1.push(data);
    if (st2.size() == 0 || st2.top() > data)
        st2.push(data);
    else
        st2.push(st2.top());
}

template<typename T>
void StackMin<T>::Pop()
{
    if (st1.size() == 0)
        return;
    st1.pop();
    st2.pop();
}

template<typename T>
T StackMin<T>::Min()
{
    return st2.top();
}

2.利用两个栈实现队列

具体要求：实现队列的push，pop，front，back操作
思路：栈上的数据为先进后出，队列上的数据为先进先出。可以用栈1专门用来放push的数据，如果要pop的时候，就把栈1的数据存入到栈2中去，对栈2进行pop。
实现：

template<typename T>
class QueueOfTwoStack
{
public:
    void Push(const T&data);
    void Pop();
    T&Front()可以合并
    {
        if (st2.empty())
        {
            while (!st1.empty())
            {
                st2.push(st1.top());
                st1.pop();
            }
        }
        return st2.top();
    }
    T&Back()
    {
        if (st1.empty())
        {
            while (!st2.empty())
            {
                st1.push(st2.top());
                st2.pop();
            }
        }
        return st1.top();
    }
private:
    stack<T>st1;
    stack<T>st2;
};

template<typename T>
void QueueOfTwoStack<T>::Push(const T&data)
{
    st1.push(data);
}

template<typename T>
void QueueOfTwoStack<T>::Pop()
{
    if (st2.size() == 0)
    {
        int count = st1.size();
        for (size_t i = 0; i < count; i++)
        {
            st2.push(st1.top());
            st1.pop();
        }
        st2.pop();
    }
    else
        st2.pop();
}

3.利用两个队列实现栈

具体要求：实现栈的Push，pop，top操作
思路：队列的数据是满足先进先出，栈上的数据满足先进后出。可以用一个队列来接收数据，当要出数据的时候，把前面的数据都放到另一个队列上去，留下最后一个。然后交换两个队列，进行下一波操作。
实现：

template<typename T>
class StackWithTwoQueue
{
public:
    void Push(const T&data);
    void Pop();
    T&Top()
    {
        assert(!qu1.empty());
        return qu1.back();
    }
private:
    queue<T>qu1;
    queue<T>qu2;
};


template<typename T>
void StackWithTwoQueue<T>::Push(const T&data)
{
    qu1.push(data);
}

template<typename T>
void StackWithTwoQueue<T>::Pop()
{
    if (0 == qu1.size())
        return;
    int count = qu1.size();
    for (int i = 0; i < count - 1; i++)
    {
        qu2.push(qu1.front());
        qu1.pop();
    }
    qu1.pop();
    swap(qu1, qu2);//交换
}

4.数组判断是否为出栈顺序

具体要求：如果是对的顺序就返回true，否则返回false
思路：借助一个栈来实现，将Push的值挨个入栈，同时进行判断栈顶的值是否与pop的第一个值相等，如果相同就出栈。最后如果栈为空，并且pop的也走到了最后，就说明是出栈顺序。
实现：

bool IsPopOrder(const int*pPush, const int*pPop, int length)
{
    bool ret = false;
    if (NULL == pPush || NULL == pPop || length <= 0)
        return ret;
    const int*pNextPush = pPush;
    const int*pNextPop = pPop;
    stack<int>s;
    while (pNextPop - pPop < length)
    {
        while (s.size() == 0 || *pNextPop != s.top())
        {
            if (pNextPush - pPush == length)
                break;
            s.push(*pNextPush);
            pNextPush++;
        }
        if (s.top() != *pNextPop)
            break;
        s.pop();
        pNextPop++;
    }
    if (s.empty() && pNextPop - pPop == length)
        ret = true;
    return ret;
}

5.背包问题
具体要求：背包的承重固定，从一系列物品中挑出刚好能放满背包的所有物品。
思路：借助一个栈来实现，栈中放的是物品数组的下标。依次往栈中放元素，如果超过了承重，就将其pop，放入一个元素来比较。
实现：

void backpack(int *arr, int size, int weight)
{
    assert(arr);
    int begin = 0;
    int sum = 0;
    stack<int> s;
    int pos = 0;
    while (begin < size)
    {
        if (pos < size)
        {
            s.push(pos);
            sum += arr[pos];
            if (sum == weight)
            {
                Print(arr, s);

            }
            if (sum > weight)
            {
                sum -= arr[s.top()];
                s.pop();
            }
            pos++;
        }
        else
        {
            sum -= arr[s.top()];
            pos = s.top() + 1;
            s.pop();
        }

        if (s.empty())
        {
            begin++;
            pos = begin;
            sum = 0;
        }
    }
}