Hanlen520
diff --git a/‎leetcode_stack/main.md‎
Lines changed: 15 additions & 1 deletion b/‎leetcode_stack/main.md‎
Lines changed: 15 additions & 1 deletion
diff --git a/‎leetcode_stack/用栈实现队列.md‎
Lines changed: 12 additions & 19 deletions b/‎leetcode_stack/用栈实现队列.md‎
Lines changed: 12 additions & 19 deletions
diff --git a/‎leetcode_stack/用队列实现栈.md‎
Lines changed: 9 additions & 18 deletions b/‎leetcode_stack/用队列实现栈.md‎
Lines changed: 9 additions & 18 deletions
diff --git a/‎pic/leetcode_stack/225_1.gif‎
22.1 MB b/‎pic/leetcode_stack/225_1.gif‎
22.1 MB
diff --git a/‎pic/leetcode_stack/232_1.gif‎
194 KB b/‎pic/leetcode_stack/232_1.gif‎
194 KB
diff --git a/‎pic/leetcode_stack/duilie.png‎
30.5 KB b/‎pic/leetcode_stack/duilie.png‎
30.5 KB
diff --git a/‎pic/leetcode_stack/stack.png‎
4.75 KB b/‎pic/leetcode_stack/stack.png‎
4.75 KB
@@ -1,5 +1,19 @@
-## LeetCode栈
+# LeetCode栈与队列
+## 1.定义
+#### 队列
+队列是一种先进先出的线性表（FIFO：First In First Out），它只允许在表的前端进行删除操作，在表的后端进行插入操作。
+
+![](../pic/leetcode_stack/duilie.png)
+
+#### 栈
+栈是一种后进先出的线性表（LIFO：Last In First Out），它只允许在表尾部进行插入和删除操作。
+
+![](../pic/leetcode_stack/stack.png)
+
+## 2.题目
 * [有效的括号](有效的括号.md)
+* [用栈实现队列](用栈实现队列.md)
+* [用队列实现栈](用队列实现栈.md)
 
 <!--
 2. [最小栈](最小栈.md)
 
@@ -1,4 +1,5 @@
-## 用栈实现队列
+# 232.用栈实现队列
+## 题目
 请你仅使用两个栈实现先入先出队列。队列应当支持一般队列的支持的所有操作（push、pop、peek、empty）：
 
 实现 MyQueue 类：
@@ -16,44 +17,36 @@
 * 出栈，入栈顺序，4,3,2,1，  出栈顺序1,2,3,4,
 * 正好两个栈的顺序结合效果等于队列的顺序
 
+![](../pic/leetcode_stack/232_1.gif)
+
 ```python
 class MyQueue:
 
     def __init__(self):
-        """
-        Initialize your data structure here.
-        """
         self.stack_in = []  # 入栈
         self.stack_out = []  # 出栈
 
     def push(self, x: int) -> None:
-        """
-        Push element x to the back of queue.
-        """
+        # 往队列中添加元素
         self.stack_in.append(x)
 
     def pop(self) -> int:
-        """
-        Removes the element from in front of queue and returns that element.
-        """
-        self.peek()
+        # 从队列中取出一个元素
+        if not self.stack_out:
+            self.stack_out = self.stack_in[::-1]
+            self.stack_in = []
         return self.stack_out.pop()
 
     def peek(self) -> int:
-        """
-        Get the front element.
-        """
+        # 获取队列的头部
         if not self.stack_out:
             self.stack_out = self.stack_in[::-1]
             self.stack_in = []
         return self.stack_out[-1]
 
     def empty(self) -> bool:
-        """
-        Returns whether the queue is empty.
-        """
-        if self.stack_in or self.stack_out:
+        # 判断队列是否为空
+        if self.stack_out or self.stack_in:
             return False
         return True
-
 ```
@@ -1,4 +1,5 @@
-## 用队列实现栈
+# 225.用队列实现栈
+## 题目
 使用队列实现栈的下列操作：
 * push(x) -- 元素 x 入栈
 * pop() -- 移除栈顶元素
@@ -8,33 +9,28 @@
 ## 代码
 * 队列先进先出
 * 栈后进先出
-* 一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时在去弹出元素就是栈的顺序了。
+* 一个队列在模拟栈弹出元素的时候只要将队列头部的元素（除了最后一个元素外） 重新添加到队列尾部，此时在去弹出元素就是栈的顺序了
+
+![](../pic/leetcode_stack/225_1.gif)
 
 ```python
 from queue import Queue
 
 class MyStack:
 
     def __init__(self):
-        """
-        Initialize your data structure here.
-        """
         self.stack = Queue()
         self.top_ele = None
 
 
     def push(self, x: int) -> None:
-        """
-        Push element x onto stack.
-        """
+        # 入栈
         self.stack.put(x)
         self.top_ele = x
 
 
     def pop(self) -> int:
-        """
-        Removes the element on top of the stack and returns that element.
-        """
+        # 弹栈
         size = self.stack.qsize()
         while size > 1:
             ele = self.stack.get()
@@ -46,18 +42,13 @@ class MyStack:
 
 
     def top(self) -> int:
-        """
-        Get the top element.
-        """
+        # 获取栈顶元素
         return self.top_ele
 
 
     def empty(self) -> bool:
-        """
-        Returns whether the stack is empty.
-        """
+        # 栈是否为空
         if self.stack.qsize():
             return False
         return True
-
 ```