225-implement-stack-using-queues.md Added follow-up solution in JavaScript.

gazeldx · gazeldx · commit e0b9b63da256 · 2025-01-19T16:17:22.000+08:00
diff --git a/README.md b/README.md
@@ -51,7 +51,7 @@ You can skip the more difficult problems and do them later.
 - [232. Implement Queue using Stacks](en/1-1000/232-implement-queue-using-stacks.md) was solved in _Python, JavaScript_.
 
 # Queue
-- [225. Implement Stack using Queues](en/1-1000/225-implement-stack-using-queues.md) was solved in _Python, JavaScript_ and 2 ways.
+- [225. Implement Stack using Queues](en/1-1000/225-implement-stack-using-queues.md) was solved in _Python, JavaScript_ and 3 ways.
 
 # Dynamic Programming
 ## Basics
diff --git a/en/1-1000/225-implement-stack-using-queues.md b/en/1-1000/225-implement-stack-using-queues.md
@@ -53,13 +53,18 @@ Can you implement the stack using only one queue?
     1. Option 1: Simplify the `push(x)` operation and complicate the `pop()` and `top()` operations. When `pop()` or `top()`, you need to find the last data with effort.
     2. Option 2: Simplify the `pop()` and `top()` operations and complicate the `push(x)` operation. When `push(x)`, you need to insert `x` into the front of the queue with effort.
 3. Advantages of Option 2: Less code; easier to understand logically because it sorts the data in the queue according to the `last in, first out` rule.
-4. This article mainly introduces `Option 2`, and the code of `Option 1` is attached in `Python` to facilitate readers to compare the two solutions.
+4. This article mainly introduces `Option 2`, and the code of `Option 1` is attached in `Python` section to facilitate readers to compare the two solutions.
 
 ## Complexity
 * Time: `push O(n)`, `pop O(1)`, `top O(1)`, `empty O(1)`.
 * Space: `O(n)`.
 
+## Follow-up
+- You can use only one queue to make it. The only change is in the `push` method. Just find a way to insert `x` to the front of the queue without using another `queue_temp`.
+- When implementing the `push` method, first `queue.push(x)`, then execute `queue.length - 1` times `queue.push(queue.pop())`. The complete code is attached in `JavaScript` section.
+
 ## JavaScript
+### Solution for option 2
 ```javascript
 var MyStack = function () {
   this.queue = []
@@ -95,8 +100,36 @@ MyStack.prototype.empty = function () {
 };
 ```
 
+### Follow-up solution: use only one queue
+```javascript
+var MyStack = function () {
+  this.queue = []
+};
+
+MyStack.prototype.push = function (x) {
+  this.queue.push(x)
+
+  _.times(
+    this.queue.length - 1,
+    () => this.queue.push(this.queue.shift())
+  )
+};
+
+MyStack.prototype.pop = function () {
+  return this.queue.shift()
+};
+
+MyStack.prototype.top = function () {
+  return this.queue[0]
+};
+
+MyStack.prototype.empty = function () {
+  return this.queue.length === 0
+};
+```
+
 ## Python
-### Solution 1: Not recommended, for comparison only.
+### Solution for option 1: Not recommended, for comparison only.
 ```python
 class MyStack:
     def __init__(self):
@@ -139,7 +172,7 @@ class MyStack:
         return len(self.queue) == 0
 ```
 
-### Solution 2: The recommended solution. It is short and easy to understand.
+### Solution for option 2: It is short and easy to understand (recommended).
 ```python
 class MyStack:
     def __init__(self):
diff --git a/zh/1-1000/225-implement-stack-using-queues.md b/zh/1-1000/225-implement-stack-using-queues.md
@@ -1,5 +1,5 @@
 # 225. 用队列实现栈 - 力扣题解最佳实践
-力扣问题链接：[225. 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues), 难度: **简单**。
+力扣链接：[225. 用队列实现栈](https://leetcode.cn/problems/implement-stack-using-queues), 难度: **简单**。
 
 ## 力扣“225. 用队列实现栈”问题描述
 请你仅使用两个队列实现一个后入先出（LIFO）的栈，并支持普通栈的全部四种操作（`push`、`top`、`pop` 和 `empty`）。
@@ -46,29 +46,25 @@ myStack.empty(); // 返回 False
 ### [进阶]
 你能否仅用一个队列来实现栈？
 
-<details>
-   <summary>解法提示</summary>
-可以只用一个队列。
-<br>
-改动只在`push`方法。只需要想办法不借助另一个`queue_temp`，把`x`插入到队列的头部。
-<br>
-在实现`push`方法时，先`queue.push(x)`，然后，执行`queue.length - 1`次`value = queue.pop(); queue.push(value)`即可。
-</details>
-
 # 中文题解
 ## 思路
 1. 使用的两个队列，一个队列用于输入和输出，另一个队列用于临时存储。
 2. 用队列模拟栈的功能，有两种方案可供选择：
     1. 方案一：简化`push(x)`操作，复杂化`pop()`和`top()`操作。`pop()`或`top()`时，需要费力找到最后一个数据。
     2. 方案二：简化`pop()`和`top()`操作，复杂化`push(x)`操作。`push(x)`时，需要费力地把`x`插入到队列头部。
 3. 方案二优点：代码量更少；从逻辑上更容易理解，因为它把队列中的数据按`后入先出`的规则排好序了。
-4. 本文主要介绍`方案二`，`方案一`的代码附在`Python`中，方便读者对比这两个方案。
+4. 本文主要介绍`方案二`，`方案一`的代码附在`Python`章节中，方便读者对比这两个方案。
 
 ## 复杂度
 * 时间：`push O(n)`, `pop O(1)`, `top O(1)`, `empty O(1)`。
 * 空间：`O(n)`。
 
+## 进阶
+- 可以只用一个队列实现栈。改动只在`push`方法。只需要想办法不借助另一个`queue_temp`，把`x`插入到队列的头部。
+- 在实现`push`方法时，先`queue.push(x)`，然后，执行`queue.length - 1`次`queue.push(queue.pop())`即可。完整代码附在`JavaScript`章节中。
+
 ## JavaScript
+### 方案二
 ```javascript
 var MyStack = function () {
   this.queue = []
@@ -104,6 +100,34 @@ MyStack.prototype.empty = function () {
 };
 ```
 
+### 进阶方案：只使用一个队列
+```javascript
+var MyStack = function () {
+  this.queue = []
+};
+
+MyStack.prototype.push = function (x) {
+  this.queue.push(x)
+
+  _.times(
+    this.queue.length - 1,
+    () => this.queue.push(this.queue.shift())
+  )
+};
+
+MyStack.prototype.pop = function () {
+  return this.queue.shift()
+};
+
+MyStack.prototype.top = function () {
+  return this.queue[0]
+};
+
+MyStack.prototype.empty = function () {
+  return this.queue.length === 0
+};
+```
+
 ## Python
 ### 方案一：不推荐，仅用于对比。
 ```python
