translation: Update the figures for the chapter of stack and queue (#1084)

* Update the figures for the chapter of stack and queue

* Bug fixes and reducing file size

docs-en/chapter_stack_and_queue/deque.md

@@ -347,19 +347,19 @@ For a double-ended queue, both the head and the tail can perform enqueue and deq
 As shown in the figure below, we treat the head and tail nodes of the doubly linked list as the front and rear of the double-ended queue, respectively, and implement the functionality to add and remove nodes at both ends.
 
 === "LinkedListDeque"
-    ![Implementing Double-Ended Queue with Doubly Linked List for Enqueue and Dequeue Operations](deque.assets/linkedlist_deque.png)
+    ![Implementing Double-Ended Queue with Doubly Linked List for Enqueue and Dequeue Operations](deque.assets/linkedlist_deque_step1.png)
 
 === "pushLast()"
-    ![linkedlist_deque_push_last](deque.assets/linkedlist_deque_push_last.png)
+    ![linkedlist_deque_push_last](deque.assets/linkedlist_deque_step2_push_last.png)
 
 === "pushFirst()"
-    ![linkedlist_deque_push_first](deque.assets/linkedlist_deque_push_first.png)
+    ![linkedlist_deque_push_first](deque.assets/linkedlist_deque_step3_push_first.png)
 
 === "popLast()"
-    ![linkedlist_deque_pop_last](deque.assets/linkedlist_deque_pop_last.png)
+    ![linkedlist_deque_pop_last](deque.assets/linkedlist_deque_step4_pop_last.png)
 
 === "popFirst()"
-    ![linkedlist_deque_pop_first](deque.assets/linkedlist_deque_pop_first.png)
+    ![linkedlist_deque_pop_first](deque.assets/linkedlist_deque_step5_pop_first.png)
 
 The implementation code is as follows:
 
@@ -372,19 +372,19 @@ The implementation code is as follows:
 As shown in the figure below, similar to implementing a queue with an array, we can also use a circular array to implement a double-ended queue.
 
 === "ArrayDeque"
-    ![Implementing Double-Ended Queue with Array for Enqueue and Dequeue Operations](deque.assets/array_deque.png)
+    ![Implementing Double-Ended Queue with Array for Enqueue and Dequeue Operations](deque.assets/array_deque_step1.png)
 
 === "pushLast()"
-    ![array_deque_push_last](deque.assets/array_deque_push_last.png)
+    ![array_deque_push_last](deque.assets/array_deque_step2_push_last.png)
 
 === "pushFirst()"
-    ![array_deque_push_first](deque.assets/array_deque_push_first.png)
+    ![array_deque_push_first](deque.assets/array_deque_step3_push_first.png)
 
 === "popLast()"
-    ![array_deque_pop_last](deque.assets/array_deque_pop_last.png)
+    ![array_deque_pop_last](deque.assets/array_deque_step4_pop_last.png)
 
 === "popFirst()"
-    ![array_deque_pop_first](deque.assets/array_deque_pop_first.png)
+    ![array_deque_pop_first](deque.assets/array_deque_step5_pop_first.png)
 
 The implementation only needs to add methods for "front enqueue" and "rear dequeue":
 

docs-en/chapter_stack_and_queue/queue.md

@@ -321,13 +321,13 @@ To implement a queue, we need a data structure that allows adding elements at on
 As shown in the figure below, we can consider the "head node" and "tail node" of a linked list as the "head" and "tail" of the queue, respectively. We restrict the operations so that nodes can only be added at the tail and removed at the head.
 
 === "LinkedListQueue"
-    ![Implementing Queue with Linked List for Enqueue and Dequeue Operations](queue.assets/linkedlist_queue.png)
+    ![Implementing Queue with Linked List for Enqueue and Dequeue Operations](queue.assets/linkedlist_queue_step1.png)
 
 === "push()"
-    ![linkedlist_queue_push](queue.assets/linkedlist_queue_push.png)
+    ![linkedlist_queue_push](queue.assets/linkedlist_queue_step2_push.png)
 
 === "pop()"
-    ![linkedlist_queue_pop](queue.assets/linkedlist_queue_pop.png)
+    ![linkedlist_queue_pop](queue.assets/linkedlist_queue_step3_pop.png)
 
 Below is the code for implementing a queue using a linked list:
 
@@ -349,13 +349,13 @@ With this design, **the effective interval of elements in the array is `[front,
 Both enqueue and dequeue operations only require a single operation, each with a time complexity of $O(1)$.
 
 === "ArrayQueue"
-    ![Implementing Queue with Array for Enqueue and Dequeue Operations](queue.assets/array_queue.png)
+    ![Implementing Queue with Array for Enqueue and Dequeue Operations](queue.assets/array_queue_step1.png)
 
 === "push()"
-    ![array_queue_push](queue.assets/array_queue_push.png)
+    ![array_queue_push](queue.assets/array_queue_step2_push.png)
 
 === "pop()"
-    ![array_queue_pop](queue.assets/array_queue_pop.png)
+    ![array_queue_pop](queue.assets/array_queue_step3_pop.png)
 
 You might notice a problem: as enqueue and dequeue operations are continuously performed, both `front` and `rear` move to the right and **will eventually reach the end of the array and can't move further**. To resolve this issue, we can treat the array as a "circular array."
 

docs-en/chapter_stack_and_queue/stack.md

@@ -319,13 +319,13 @@ When implementing a stack using a linked list, we can consider the head node of
 As shown in the figure below, for the push operation, we simply insert elements at the head of the linked list. This method of node insertion is known as "head insertion." For the pop operation, we just need to remove the head node from the list.
 
 === "LinkedListStack"
-    ![Implementing Stack with Linked List for Push and Pop Operations](stack.assets/linkedlist_stack.png)
+    ![Implementing Stack with Linked List for Push and Pop Operations](stack.assets/linkedlist_stack_step1.png)
 
 === "push()"
-    ![linkedlist_stack_push](stack.assets/linkedlist_stack_push.png)
+    ![linkedlist_stack_push](stack.assets/linkedlist_stack_step2_push.png)
 
 === "pop()"
-    ![linkedlist_stack_pop](stack.assets/linkedlist_stack_pop.png)
+    ![linkedlist_stack_pop](stack.assets/linkedlist_stack_step3_pop.png)
 
 Below is an example code for implementing a stack based on a linked list:
 
@@ -338,13 +338,13 @@ Below is an example code for implementing a stack based on a linked list:
 When implementing a stack using an array, we can consider the end of the array as the top of the stack. As shown in the figure below, push and pop operations correspond to adding and removing elements at the end of the array, respectively, both with a time complexity of $O(1)$.
 
 === "ArrayStack"
-    ![Implementing Stack with Array for Push and Pop Operations](stack.assets/array_stack.png)
+    ![Implementing Stack with Array for Push and Pop Operations](stack.assets/array_stack_step1.png)
 
 === "push()"
-    ![array_stack_push](stack.assets/array_stack_push.png)
+    ![array_stack_push](stack.assets/array_stack_step2_push.png)
 
 === "pop()"
-    ![array_stack_pop](stack.assets/array_stack_pop.png)
+    ![array_stack_pop](stack.assets/array_stack_step3_pop.png)
 
 Since the elements to be pushed onto the stack may continuously increase, we can use a dynamic array, thus avoiding the need to handle array expansion ourselves. Here is an example code: