feat: add solutions to lc problem: No.0225

No.0225.Implement Stack using Queues

Author: yanglbme

solution/0200-0299/0223.Rectangle Area/README.md

@@ -47,7 +47,7 @@
 
 **方法一：计算重叠面积**
 
-我们先计算出两个矩形各自的面积，记为 $a$ 和 $b$，然后计算重叠的宽度 $width$ 和高度 $height$，那么重叠的面积为 $max(width, 0) \times max(height, 0)$，最后将 $a$、$b$ 和重叠面积相减即可。
+我们先计算出两个矩形各自的面积，记为 $a$ 和 $b$，然后计算重叠的宽度 $width$ 和高度 $height$，那么重叠的面积为 $max(width, 0) \times max(height, 0)$，最后将 $a$, $b$ 和重叠面积相减即可。
 
 时间复杂度 $O(1)$，空间复杂度 $O(1)$。
 

solution/0200-0299/0225.Implement Stack using Queues/README.md

@@ -64,6 +64,17 @@ myStack.empty(); // 返回 False
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：两个队列**
+
+我们使用两个队列 $q_1$ 和 $q_2$，其中 $q_1$ 用于存储栈中的元素，而 $q_2$ 用于辅助实现栈的操作。
+
+-   `push` 操作：将元素压入 $q_2$，然后将 $q_1$ 中的元素依次弹出并压入 $q_2$，最后交换 $q_1$ 和 $q_2$ 的引用。时间复杂度 $O(n)$。
+-   `pop` 操作：直接弹出 $q_1$ 的队首元素。时间复杂度 $O(1)$。
+-   `top` 操作：直接返回 $q_1$ 的队首元素。时间复杂度 $O(1)$。
+-   `empty` 操作：判断 $q_1$ 是否为空。时间复杂度 $O(1)$。
+
+空间复杂度 $O(n)$，其中 $n$ 是栈中元素的个数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -72,38 +83,25 @@ myStack.empty(); // 返回 False
 
 ```python
 class MyStack:
+
     def __init__(self):
-        """
-        Initialize your data structure here.
-        """
-        self.q = []
+        self.q1 = deque()
+        self.q2 = deque()
 
     def push(self, x: int) -> None:
-        """
-        Push element x onto stack.
-        """
-        self.q.append(x)
-        n = len(self.q)
-        for i in range(1, n):
-            self.q.append(self.q.pop(0))
+        self.q2.append(x)
+        while self.q1:
+            self.q2.append(self.q1.popleft())
+        self.q1, self.q2 = self.q2, self.q1
 
     def pop(self) -> int:
-        """
-        Removes the element on top of the stack and returns that element.
-        """
-        return self.q.pop(0)
+        return self.q1.popleft()
 
     def top(self) -> int:
-        """
-        Get the top element.
-        """
-        return self.q[0]
+        return self.q1[0]
 
     def empty(self) -> bool:
-        """
-        Returns whether the stack is empty.
-        """
-        return len(self.q) == 0
+        return len(self.q1) == 0
 
 
 # Your MyStack object will be instantiated and called as such:
@@ -119,37 +117,36 @@ class MyStack:
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-class MyStack {
+import java.util.Deque;
 
-    private Deque<Integer> q;
+class MyStack {
+    private Deque<Integer> q1 = new ArrayDeque<>();
+    private Deque<Integer> q2 = new ArrayDeque<>();
 
-    /** Initialize your data structure here. */
     public MyStack() {
-        q = new ArrayDeque<>();
+
     }
 
-    /** Push element x onto stack. */
     public void push(int x) {
-        q.offerLast(x);
-        int n = q.size();
-        while (n-- > 1) {
-            q.offerLast(q.pollFirst());
+        q2.offer(x);
+        while (!q1.isEmpty()) {
+            q2.offer(q1.poll());
         }
+        Deque<Integer> q = q1;
+        q1 = q2;
+        q2 = q;
     }
 
-    /** Removes the element on top of the stack and returns that element. */
     public int pop() {
-        return q.pollFirst();
+        return q1.poll();
     }
 
-    /** Get the top element. */
     public int top() {
-        return q.peekFirst();
+        return q1.peek();
     }
 
-    /** Returns whether the stack is empty. */
     public boolean empty() {
-        return q.isEmpty();
+        return q1.isEmpty();
     }
 }
 
@@ -163,6 +160,138 @@ class MyStack {
  */
 ```
 
+### **C++**
+
+```cpp
+class MyStack {
+public:
+    MyStack() {
+
+    }
+
+    void push(int x) {
+        q2.push(x);
+        while (!q1.empty()) {
+            q2.push(q1.front());
+            q1.pop();
+        }
+        swap(q1, q2);
+    }
+
+    int pop() {
+        int x = q1.front();
+        q1.pop();
+        return x;
+    }
+
+    int top() {
+        return q1.front();
+    }
+
+    bool empty() {
+        return q1.empty();
+    }
+
+private:
+    queue<int> q1;
+    queue<int> q2;
+};
+
+/**
+ * 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();
+ */
+```
+
+### **Go**
+
+```go
+type MyStack struct {
+	q1 []int
+	q2 []int
+}
+
+func Constructor() MyStack {
+	return MyStack{}
+}
+
+func (this *MyStack) Push(x int) {
+	this.q2 = append(this.q2, x)
+	for len(this.q1) > 0 {
+		this.q2 = append(this.q2, this.q1[0])
+		this.q1 = this.q1[1:]
+	}
+	this.q1, this.q2 = this.q2, this.q1
+}
+
+func (this *MyStack) Pop() int {
+	x := this.q1[0]
+	this.q1 = this.q1[1:]
+	return x
+}
+
+func (this *MyStack) Top() int {
+	return this.q1[0]
+}
+
+func (this *MyStack) Empty() bool {
+	return len(this.q1) == 0
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * obj := Constructor();
+ * obj.Push(x);
+ * param_2 := obj.Pop();
+ * param_3 := obj.Top();
+ * param_4 := obj.Empty();
+ */
+```
+
+### **TypeScript**
+
+```ts
+class MyStack {
+    q1: number[] = [];
+    q2: number[] = [];
+
+    constructor() {}
+
+    push(x: number): void {
+        this.q2.push(x);
+        while (this.q1.length) {
+            this.q2.push(this.q1.shift()!);
+        }
+        [this.q1, this.q2] = [this.q2, this.q1];
+    }
+
+    pop(): number {
+        return this.q1.shift()!;
+    }
+
+    top(): number {
+        return this.q1[0];
+    }
+
+    empty(): boolean {
+        return this.q1.length === 0;
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * var obj = new MyStack()
+ * obj.push(x)
+ * var param_2 = obj.pop()
+ * var param_3 = obj.top()
+ * var param_4 = obj.empty()
+ */
+```
+
 ### **...**
 
 ```