From b1fb5acddd7317b9afe7d0e06af4e68ae790f277 Mon Sep 17 00:00:00 2001
From: juan <juancloudcomputing@protonmail.com>
Date: Mon, 4 Jul 2022 14:51:13 +0800
Subject: [PATCH] vault backup: 2022-07-04 14:51:13

---
 .../Leetcode Implement-Queue-Using-Stacks.md  | 81 ++++++++++++++++++-
 1 file changed, 79 insertions(+), 2 deletions(-)

diff --git a/CS notes/pages/Leetcode Implement-Queue-Using-Stacks.md b/CS notes/pages/Leetcode Implement-Queue-Using-Stacks.md
index b1eaedf..52a57ef 100644
--- a/CS notes/pages/Leetcode Implement-Queue-Using-Stacks.md	
+++ b/CS notes/pages/Leetcode Implement-Queue-Using-Stacks.md	
@@ -19,17 +19,94 @@ tag:#stack tag:#queue
  
 
 ##### Links:
-- [Link to problem]()
+- [Link to problem](https://leetcode.com/problems/implement-queue-using-stacks/submissions/)
 ___
 ### Problem
+Implement a first in first out (FIFO) queue using only two stacks. The implemented queue should support all the functions of a normal queue (`push`, `peek`, `pop`, and `empty`).
+
+Implement the `MyQueue` class:
+
+-   `void push(int x)` Pushes element x to the back of the queue.
+-   `int pop()` Removes the element from the front of the queue and returns it.
+-   `int peek()` Returns the element at the front of the queue.
+-   `boolean empty()` Returns `true` if the queue is empty, `false` otherwise.
+
+**Notes:**
+
+-   You must use **only** standard operations of a stack, which means only `push to top`, `peek/pop from top`, `size`, and `is empty` operations are valid.
+-   Depending on your language, the stack may not be supported natively. You may simulate a stack using a list or deque (double-ended queue) as long as you use only a stack's standard operations.
 
 #### Examples
+**Input**
+["MyQueue", "push", "push", "peek", "pop", "empty"]
+[[], [1], [2], [], [], []]
+**Output**
+[null, null, null, 1, 1, false]
+
+**Explanation**
+MyQueue myQueue = new MyQueue();
+myQueue.push(1); // queue is: [1]
+myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
+myQueue.peek(); // return 1
+myQueue.pop(); // return 1, queue is [2]
+myQueue.empty(); // return false
 
 #### Constraints
+**Constraints:**
+
+-   `1 <= x <= 9`
+-   At most `100` calls will be made to `push`, `pop`, `peek`, and `empty`.
+-   All the calls to `pop` and `peek` are valid.
 
 ### Thoughts
 
 > [!summary]
-> This is a #template_remove_me
+> Use two stacks to implement a queue.
+
+One stack reverse the FIFO order, but two stack can reverse back.
+
+In real life, this can improve speed as you only lock one stack because of thread safety.
 
 ### Solution
+
+```cpp
+class MyQueue {
+  stack<int> input;
+  stack<int> out;
+
+public:
+  void push(int x) { input.push(x); }
+
+  int pop() {
+    move();
+    int top = out.top();
+    out.pop();
+    return top;
+  }
+
+  int peek() {
+    move();
+    return out.top();
+  }
+
+  void move() {
+    if (out.empty()) {
+      while (!input.empty()) {
+        out.push(input.top());
+        input.pop();
+      }
+    }
+  }
+
+  bool empty() { return input.empty() && out.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();
+ */
+```
\ No newline at end of file