【代码随想录】刷题笔记Day15

前言

今天把科目一给考掉了，两千多道题目太折磨了，感觉也不难就是太零碎了，anyway完成了一件大事！过几天要开学了，这几天再刷刷题吧

栈与队列理论基础

• 栈先进后出，队列先进先出
• 

栈的用法

• // stack 定义
  stack name;
  
  // stack 元素的访问
  stack st;
  for(int i = 1; i <= 5; i++){
      st.push(i);  // push(i)用以把i压入栈，故此处依次入栈12345
  }
  printf("%d\n",st.top());  // top()取栈顶元素，输出结果5
  
  // stack 常用函数
  push(x)  // 将x入栈，O(1)
  pop()  // 弹出栈顶元素，O(1)
  top()  // 获得栈顶元素，O(1)
  empty()  // 检测stack是否为空，tue空，false非空，O(1)
  size()  // 返回stack内元素的个数，O(1)
  
  // 使用top()和pop()函数前，必须用empty()判断栈，否则会因为栈空出现错误

队列的用法

• // queue 定义
  queue name
  
  // queue 元素的访问
  queue q;
  for(int i = 1; i <= 5; i++){
      q.push(i);  // push(i)用以将i压入队列，因此依次入队12345
  }
  printf("%d %d\n", q.front(), q.back());  // 输出结果是1 5
  
  //queue 常用函数
  push(x)  // 将x进行入队，O(1)
  pop()  // 令队首元素出队，O(1)
  front()  // 获得队首元素，O(1)
  back()  // 获得队尾元素，O(1)
  empty()  // 检测queue是否为空，true空，false非空，O(1)
  size()  // 返回queue内元素的个数，O(1)
  
  // 使用front()和pop()函数前，必须用empty()判断队列，否则会因为队空出现错误

双端队列的用法

• // deque 定义
  deque name;
  
  // deque 元素的访问
  deque dq;
  for (int i = 1; i <= 5; i++) {
      dq.push_back(i);  // 将i压入deque的末尾，依次入队1 2 3 4 5
  }
  printf("%d %d\n", dq.front(), dq.back());  // 输出结果为1 5
  
  // deque 常用函数
  push_back(x)  // 将x插入到deque的末尾，O(1)
  push_front(x)  // 将x插入到deque的开头，O(1)
  pop_back()  // 删除deque末尾的元素，O(1)
  pop_front()  // 删除deque开头的元素，O(1)
  front()  // 获得队首元素，O(1)
  back()  // 获得队尾元素，O(1)
  empty()  // 检测deque是否为空，true为空，false非空，O(1)
  size()  // 返回deque中元素的个数，O(1)
  
  // 使用前四个函数前，必须用empty()判断deque是否为空，否则会因为空队列出现错误

优先队列的用法

• 底层用堆实现，队首元素是队列优先级最高的一个（自动调整排序）

• // priority_queue 定义
  priority_queue name;
  
  // priority_queue 常用函数
  push(x)  // 令x入队，O(logN)
  top()  // 获得队首元素（即堆顶元素），O(1)
  pop()  // 令队首元素（即堆顶元素）出队，O(logN)
  empty()  // 检测是否为空，O(1)
  size()  // 返回大小，O(1)
  
  // priority_queue 优先级设置
  // 基本数据结构的优先级设置
  // 第二个参数是容器类型，第三个参数less大的优先级大，greater小的优先级大
  priority queue q;
  priority_queue,less> q;
  // 结构体的优先级设置（里）
  struct fruit{
      string name;
      int price;
      friend bool operator < (const fruit &f1, const fruit &f2){  // 友元重载小于号
          return f1.price > f2.price;  // 按价格从低到高排（和cmp反过来）
      }
  };
  priority_queue q;  // 就可以直接定义
  
  // 结构体的优先级设置（外）
  struct cmp {
      bool operator () (const fruit &f1, const fruit &f2){
      return fl.price > f2.price;
  };
  priority_queue, cmp> q;
  

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

• 用两个栈（stIn和stOut）模拟队列，push就是塞入stIn，pop就全部转移到stOut再弹出，peek可以直接复用pop（记得弹出来读的要压回去），empty就是两个都空
•  

  class MyQueue {
  public:
      stack stIn;
      stack stOut;
      /** Initialize your data structure here. */
      MyQueue() {
  
      }
      /** Push element x to the back of queue. */
      void push(int x) {
          stIn.push(x);
      }
  
      /** Removes the element from in front of queue and returns that element. */
      int pop() {
          // 只有当stOut为空的时候，再从stIn里导入数据（导入stIn全部数据）
          if (stOut.empty()) {
              // 从stIn导入数据直到stIn为空
              while(!stIn.empty()) {
                  stOut.push(stIn.top());
                  stIn.pop();
              }
          }
          int result = stOut.top();
          stOut.pop();
          return result;
      }
  
      /** Get the front element. */
      int peek() {
          int res = this->pop(); // 直接复用已有的pop函数
          stOut.push(res); // 因为pop函数弹出了元素res，所以再添加回去
          return res;
      }
  
      /** Returns whether the queue is empty. */
      bool empty() {
          return stIn.empty() && stOut.empty();
      }
  };
  

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

• 一个队列que1即可模仿（另一个que2暂存），push就直接存入，pop就把除了最后一个的其它存到que2后弹出再存回que1，top用队尾，空就是que1空
• 也可以一个队列搞定（弹出去的那些重新加到队尾）

• class MyStack {
  public:
      queue que1;
      queue que2; // 辅助队列，用来备份
      /** Initialize your data structure here. */
      MyStack() {
  
      }
  
      /** Push element x onto stack. */
      void push(int x) {
          que1.push(x);
      }
  
      /** Removes the element on top of the stack and returns that element. */
      int pop() {
          int size = que1.size();
          size--;
          while (size--) { // 将que1 导入que2，但要留下最后一个元素
              que2.push(que1.front());
              que1.pop();
          }
  
          int result = que1.front(); // 留下的最后一个元素就是要返回的值
          que1.pop();
          que1 = que2;            // 再将que2赋值给que1
          while (!que2.empty()) { // 清空que2
              que2.pop();
          }
          return result;
      }
  
      /** Get the top element. */
      int top() {
          return que1.back();
      }
  
      /** Returns whether the stack is empty. */
      bool empty() {
          return que1.empty();
      }
  };

• int pop() {
      int size = que.size();
      size--;
      while (size--) { // 将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部
              que.push(que.front());
              que.pop();
      }
      int result = que.front(); // 此时弹出的元素顺序就是栈的顺序了
      que.pop();
      return result;
  }

后言

先写两道感受一下，其实感觉栈和队列的这些操作相比于其他容器害挺简单的，今天把所有题刷完吧！加油！！！