面试复习-------算法与数据结构------栈&队列

STL栈：<stack>

入栈：s.push(x); 出栈：s.pop()无返回值； 返回栈顶s.top()s.empty(),s.size()....

STL队列：<queue>

入队：q.push(x)放到队列的末端；出队：q.pop()弹出队首无返回值

q.front()返回队首；q.back()返回队尾q.empty(),q.size().....

（1）队列 <----->栈

两个栈实现一个队列（剑指offer7）：

------栈A负责输入，栈B负责输出，输入时直接放入栈A，输出时先从栈B输出，若栈B为空，将栈A全部放入栈B再输出

template <typename T>
class myQueue
{
public:
    myQueue();
    ~myQueue();

    void append(const T& node);
    T deleteHead();

private:
    stack<T> s1;
    stack<T> s2;
};

template <typename T>
myQueue<T>::myQueue()
{
}

template <typename T>
myQueue<T>::~myQueue()
{
}

template <typename T>
void myQueue<T>::append(const T& node)
{

    s1.push(node);
}

template <typename T>
T myQueue<T>::deleteHead()
{
    if(s2.empty())
        while(!s1.empty()){
            s2.push(s1.top());
            s1.pop();
        }
    if(s2.empty()){
        cout<<"empty";
        return (T)0;
    }
    T tmp = s2.top();
    s2.pop();
    return tmp;
}

两个队列实现一个栈：
每次插入的时候，将元素插入到空队列中，然后将另一个队列元素转移进来；输出时直接从非空输出。
这样所有的元素都在一个队列中以栈的顺序存在

template <typename T>
class myStack
{
public:
    myStack();
    ~myStack();
    void push(const T& node);
    T top();
    void pop();
    bool empty();
private:
    queue<T> q1;
    queue<T> q2;
};

template <typename T>
myStack<T>::myStack()
{
}

template <typename T>
myStack<T>::~myStack()
{
}

template <typename T>
void myStack<T>::push(const T& node)
{
    if(q1.empty()){
        q1.push(node);
        while(!q2.empty()){
            q1.push(q2.front());
            q2.pop();
        }
    }else{
        q2.push(node);
        while(!q1.empty()){
            q2.push(q1.front());
            q1.pop();
        }
    }
}

template <typename T>
T myStack<T>::top()
{
    if(q1.empty() && q2.empty()){
        cout << "empty";
        return (T)0;
    }
    if(q1.empty())
        return q2.front();
    else
        return q1.front();
}

template <typename T>
void myStack<T>::pop()
{
    if(q1.empty() && q2.empty()){
        cout << "empty";
        return ;
    }
    if(q1.empty())
        q2.pop();
    else
        q1.pop();
}

template <typename T>
bool myStack<T>::empty()
{
    return (q1.empty() && q2.empty());
}

（2）用栈进行逆序
如果想要的结果与当前已经有的结果顺序刚好相反，应该立刻想到利用栈的后进先特性
如：从尾到头打印链表（剑指offer5）
（3）栈的压入、弹出序列判断（剑指offer22）
给定压栈顺序序列，判断一个序列是否可能是出栈序列
解题思路：分别用两个index遍历两个序列，如果stack.top()== a[index2],则index2++,否则不断往stack压入；

bool isPopOrder(const int* push,const int* pop,int length)
{
    if(push == NULL || pop == NULL || length <= 0)
        return false;

    stack<int> s;

    const int* index1 = push;
    const int* index2 = pop;
    while(index1 - push < length){
        s.push(*index1);
        index1++;
        while(!s.empty() && *index2 == s.top())
        {
            s.pop();
            ++index2;
        }
    }
    if(s.empty() && index2 - pop == length)
        return true;

    return false;
}

（4）包含min方法的栈,用以获取最小值（剑指offer21）
解题思路：利用一个数据栈+辅助栈，每次数据栈弹入数据，辅助栈弹入到目前为止的最小值，即：min(s.top(),date)

当数据栈弹出一个数据时，辅助栈也弹出一个数据

（5）栈的逆序

给定一个栈，将栈逆序原地翻转，不能使用其他的辅助数据结构

解题思路：利用递归的思想，实现一个获取并弹出栈底元素的函数

void reverseStack(stack<int>& s)
{
    if(s.empty())
        return;

    int base = getBase(s);

    reverseStack(s);    //对剩下的元素进行递归

    s.push(base);

}
//获取并弹出栈底元素
int getBase(stack<int>&s)
{
    int base = s.top();
    s.pop();
    if(s.empty()){
        return base;
    }else{
        int last = getBase(s);

        s.push(base);   // 把之前弹出的元素放回

        return last;
    }

}

实际上使用了栈内存将数据以参数的形式保存了起来，和用辅助空间没什么区别。

注意：int getBase(stack<int>&s)要使用引用传参，不然有可能会出错（拷贝份数太多）

（6）双栈排序

借助辅助栈，每次将顶元素正确“插入”到栈中

void SortStack(stack<int>& st)  
{  
    if(st.empty())return;  
  
    int topNum = st.top();  
    st.pop();  
    SortStack(st);//顶元素弹出，将下面的排好  
    stack<int> tempSt;  
    while(!st.empty() && st.top()>topNum){  
        tempSt.push(st.top());  
        st.pop();  
    }  
    st.push(topNum);  
    while(!tempSt.empty()){  
        st.push(tempSt.top());  
        tempSt.pop();  
    }  
}  

（7）滑动窗口的最大值（剑指offer65）

解题思路：使用双端队列保存最大值的坐标，并且按情况进行更新

vector<int> maxInWindows(const vector<int>& nums, unsigned int size)
{
    vector<int> result;
    if(nums.size() < size || size <= 0)
        return result;
    //使用双端队列保存当前可能成为最大值的点的下标,并且队头元素为当前最大值下标
    deque<int> index;

    //处理窗口还没有满的情况
    for(int i = 0; i < size; ++i){

        //发现一个比之前下标大的点，那么前面的点全部出队
        while(!index.empty() && nums.at(i) >= nums.at(index.back()))
            index.pop_back();

        index.push_back(i);
    }

    for(int i = size; i < nums.size() ;++i){
        result.push_back(nums.at(index.front())); //首先保存当前结果

        //同上，先将队尾不可能成为最大值的下标删除
        while(!index.empty() && nums.at(i) >= nums.at(index.back()))
            index.pop_back();

        //当前front元素已经不再区间里面，则队头删除
        if(!index.empty() && index.front() <= (i-size))
            index.pop_front();

        index.push_back(i);
    }
    result.push_back(nums.at(index.front()));

    return result;
}

（8）遇到计算表达式（leetcode150）["2", "1", "+", "3", "*"] -> ((2 + 1) * 3) -> 9

简化路径（leetcode71）"/a/./b/../../c/", => "/c"

这种遇到一个数据需要取出前面的数据进行计算的情况，都应该利用栈的后入先出特性

（9）递归和栈可以进行相互转换，有时候用递归可以优化代码结构，如逆序打印链表可以这么写：

void reversePrint(ListNode* head)
{
    if(head == NULL)
        return;
    reversePrint(head->next);
    cout<<head->val;
}