力扣打卡Day10 栈与队列Part01 栈与队列的相互实现

Lumory

已于 2024-06-05 22:43:25 修改

阅读量810

点赞数 3

文章标签： leetcode

于 2024-05-31 22:40:51 首次发布

本文链接：https://blog.youkuaiyun.com/Lumory/article/details/139362724

版权

来补啦！

首先是学了一下栈与队列的理论基础。

栈的原理：栈是先进后出。

队列的原理：队列是先进先出。

STL：标准模板库，主要出现在C++中。广义分为容器、算法、迭代器。

STL提供了六大组件，彼此之间可以组合套用，这六大组件分别是:容器、算法、迭代器、仿函数、适配器（配接器）、空间配置器。
容器：各种数据结构，如vector、list、deque、set、map等,用来存放数据，从实现角度来看，STL容器是一种class
template。
算法：各种常用的算法，如sort、find、copy、for_each。从实现的角度来看，STL算法是一种function
tempalte.
迭代器：扮演了容器与算法之间的胶合剂，共有五种类型，从实现角度来看，迭代器是一种将operator* , operator-> ,operator++,operator--等指针相关操作予以重载的class template.所有STL容器都附带有自己专属的迭代器，只有容器的设计者才知道如何遍历自己的元素。原生指针(native pointer)也是一种迭代器。
仿函数：行为类似函数，可作为算法的某种策略。从实现角度来看，仿函数是一种重载了operator()的class 或者class
template
适配器：一种用来修饰容器或者仿函数或迭代器接口的东西。
空间配置器：负责空间的配置与管理。从实现角度看，配置器是一个实现了动态空间配置、空间管理、空间释放的class tempalte.
STL六大组件的交互关系，容器通过空间配置器取得数据存储空间，算法通过迭代器存储容器中的内容，仿函数可以协助算法完成不同的策略的变化，适配器可以修饰仿函数。
————————————————

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

原文链接：https://blog.youkuaiyun.com/weixin_41969690/article/details/106648441

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

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

所以STL中栈和队列往往不被归类为容器，而被归类为container adapter（容器适配器）。

栈和队列的内部结构，栈的底层实现可以是vector，deque，list 都是可以的，主要就是数组和链表的底层实现。没有指定底层实现的时候，默认是以deque来实现的（SGI STL）。

232. 用栈实现队列 - 力扣（LeetCode）

用一个进栈、一个出栈来实现队列，要注意就是pop()时，如果出栈为空，要将所有元素都放入出栈里。进栈和出栈的所有元素之和就是整个队列的元素。

这里主要是在peek()返回顶层值时，调用到了pop()函数，因为只对同一个数进行操作，没有造成更大的时间复杂度。但是有点疑惑的是，pop()和peek()好像都是一个意思。

另外还有学到了用this->来调用本身的函数。

class MyQueue {
private:
    stack<int> stIn;
    stack<int> stOut;
public:
    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();
        stOut.push(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. 用队列实现栈 - 力扣（LeetCode）

用一个（单向）队列就可以实现栈。

最复杂的pop()函数，就是要把除了最后一个元素全都重新push到队列后面，然后原来的最后一个元素就到了队列的开头，再用队列的pop()方法就ok。

class MyStack {
private:
    queue<int> que;
public:
    MyStack() {
        
    }
    
    void push(int x) {
        que.push(x);
    }
    
    int pop() {
        int size=que.size();
        size--;
        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();
 */

这个还挺简单的（欣慰