day10|232.用栈实现队列● 225. 用队列实现栈

1. C++中stack 是容器么？

2. 我们使用的stack是属于哪个版本的STL？

3. 我们使用的STL中stack是如何实现的？

4. stack 提供迭代器来遍历stack空间么？

栈和队列是STL（C++标准库）里面的两个数据结构。

三个最为普遍的STL版本：

栈—先进后出

栈提供push 和 pop 等等接口，所有元素必须符合先进后出规则，所以栈不提供走访功能，也不提供迭代器(iterator)。 不像是set 或者map 提供迭代器iterator来遍历所有元素。

栈是以底层容器完成其所有的工作，对外提供统一的接口，底层容器是可插拔的（也就是说我们可以控制使用哪种容器来实现栈的功能）。

所以STL中栈往往不被归类为容器，而被归类为container adapter（容器适配器）。栈的内部结构，栈的底层实现可以是vector，deque，list 都可以的， 主要就是数组和链表的底层实现。

我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。

deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。

SGI STL中 队列底层实现缺省情况下一样使用deque实现的。

我们也可以指定vector为栈的底层实现，初始化语句如下：

232.用栈实现队列

232.用栈实现队列

介绍

使用栈实现队列的下列操作：

push(x) -- 将一个元素放入队列的尾部。

pop() -- 从队列首部移除元素。

peek() -- 返回队列首部的元素。

empty() -- 返回队列是否为空。

思路

可以使用两个栈来模拟队列的出栈。

定义入栈 stackin
定义出栈 stackout

//入队列
void push(int x){
    stackIn.push(x)
}
//出队列
int pop(){
   if(stackout.empt()) { //如果出栈不为空
        while(stackIn.empty()){ //当入栈不为空
              //
              stackOut.push(stackIn.top);
              StackIn.pop()
        }
    }
    result = stackOut.top();
    stackOut.pop()
    return result
}

代码

class MyQueue {
public:
    stack<int> stIn;
    stack<int> stOut;
    MyQueue() {

    }
    
    void push(int x) {
        stIn.push(x);
    }
    
    int pop() {
        if(stOut.empty()){
            while(!stIn.empty()){
                stOut.push(stIn.top());
                stIn.pop();
            }
        }
        int result = stOut.top();
        stOut.pop();
        return result;
    }
    
    int peek() {
      int res = this->pop(); // 直接使用已有的pop函数
        stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
        return res;
    }
    
    bool empty() {
        return stIn.empty()&&stOut.empty();
    }
};

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue* obj = new MyQueue();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->peek();
 * bool param_4 = obj->empty();
 */

225.用队列实现栈

225.用队列实现栈

介绍

请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（push、top、pop 和 empty）。

思路

出栈的顺序是3---2---1

那么可以把元素1出队后，再加入队列里。再把元素2出队后，再加入队列里。

即若队列中有size个元素，那么就把size-1个元素弹出来重复加入。

// que队列结构
void push(int x){
    que.push(x);
}
int pop(){
//获取队列的size
    size = que.size();
    size--;
    while(size--){
        que.push(que.front())//把出队的第一个元素重新加入到队列中
        que.pop();
    }
    result = que.front();
    que.pop()
    return result;
}
//获取栈中的第一个元素，也就是队列中的最后一个元素
int top(){
    return que.back();
}

代码

class MyStack {
public:
    queue<int> que;
    MyStack() {

    }
    
    void push(int x) {
        que.push(x);
    }
    
    int pop() {
        int size = que.size()-1;
        while(size--){
            que.push(que.front());
            que.pop();
        }
        int result = que.front();
        que.pop();
        return result;
    }
    
    int top() {
        return que.back();
    }
    
    bool empty() {
        return que.empty();

    }
};

/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack* obj = new MyStack();
 * obj->push(x);
 * int param_2 = obj->pop();
 * int param_3 = obj->top();
 * bool param_4 = obj->empty();
 */