Bug fixes and improvements (#1348)

* Add "reference" for EN version. Bug fixes.

* Unify the figure reference as "the figure below" and "the figure above".
Bug fixes.

* Format the EN markdown files.

* Replace "" with <u></u> for EN version and bug fixes

* Fix biary_tree_dfs.png

* Fix biary_tree_dfs.png

* Fix zh-hant/biary_tree_dfs.png

* Fix heap_sort_step1.png

* Sync zh and zh-hant versions.

* Bug fixes

* Fix EN figures

* Bug fixes

* Fix the figure labels for EN version

en/docs/chapter_stack_and_queue/deque.md

@@ -1,6 +1,6 @@
 # Double-ended queue
 
-In a queue, we can only delete elements from the head or add elements to the tail. As shown in the following diagram, a "double-ended queue (deque)" offers more flexibility, allowing the addition or removal of elements at both the head and the tail.
+In a queue, we can only delete elements from the head or add elements to the tail. As shown in the figure below, a <u>double-ended queue (deque)</u> offers more flexibility, allowing the addition or removal of elements at both the head and the tail.
 
 ![Operations in double-ended queue](deque.assets/deque_operations.png)
 
@@ -10,14 +10,14 @@ The common operations in a double-ended queue are listed below, and the names of
 
 <p align="center"> Table <id> &nbsp; Efficiency of double-ended queue operations </p>
 
-| Method Name   | Description                 | Time Complexity |
-| ------------- | --------------------------- | --------------- |
+| Method Name   | Description                | Time Complexity |
+| ------------- | -------------------------- | --------------- |
 | `pushFirst()` | Add an element to the head | $O(1)$          |
-| `pushLast()`  | Add an element to the tail  | $O(1)$          |
-| `popFirst()`  | Remove the first element    | $O(1)$          |
-| `popLast()`   | Remove the last element     | $O(1)$          |
-| `peekFirst()` | Access the first element    | $O(1)$          |
-| `peekLast()`  | Access the last element     | $O(1)$          |
+| `pushLast()`  | Add an element to the tail | $O(1)$          |
+| `popFirst()`  | Remove the first element   | $O(1)$          |
+| `popLast()`   | Remove the last element    | $O(1)$          |
+| `peekFirst()` | Access the first element   | $O(1)$          |
+| `peekLast()`  | Access the last element    | $O(1)$          |
 
 Similarly, we can directly use the double-ended queue classes implemented in programming languages:
 

en/docs/chapter_stack_and_queue/queue.md

@@ -1,6 +1,6 @@
 # Queue
 
-"Queue" is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.
+A <u>queue</u> is a linear data structure that follows the First-In-First-Out (FIFO) rule. As the name suggests, a queue simulates the phenomenon of lining up, where newcomers join the queue at the rear, and the person at the front leaves the queue first.
 
 As shown in the figure below, we call the front of the queue the "head" and the back the "tail." The operation of adding elements to the rear of the queue is termed "enqueue," and the operation of removing elements from the front is termed "dequeue."
 

en/docs/chapter_stack_and_queue/stack.md

@@ -1,6 +1,6 @@
 # Stack
 
-A "Stack" is a linear data structure that follows the principle of Last-In-First-Out (LIFO).
+A <u>stack</u> is a linear data structure that follows the principle of Last-In-First-Out (LIFO).
 
 We can compare a stack to a pile of plates on a table. To access the bottom plate, one must first remove the plates on top. By replacing the plates with various types of elements (such as integers, characters, objects, etc.), we obtain the data structure known as a stack.
 

en/docs/chapter_stack_and_queue/summary.md

@@ -24,8 +24,8 @@ A double-ended queue, which is a combination of a stack and a queue or two stack
 
 **Q**: How exactly are undo and redo implemented?
 
-Undo and redo operations are implemented using two stacks: Stack A for undo and Stack B for redo.
+Undo and redo operations are implemented using two stacks: Stack `A` for undo and Stack `B` for redo.
 
-1. Each time a user performs an operation, it is pushed onto Stack A, and Stack B is cleared.
-2. When the user executes an "undo", the most recent operation is popped from Stack A and pushed onto Stack B.
-3. When the user executes a "redo", the most recent operation is popped from Stack B and pushed back onto Stack A.
+1. Each time a user performs an operation, it is pushed onto Stack `A`, and Stack `B` is cleared.
+2. When the user executes an "undo", the most recent operation is popped from Stack `A` and pushed onto Stack `B`.
+3. When the user executes a "redo", the most recent operation is popped from Stack `B` and pushed back onto Stack `A`.