build

docs/chapter_stack_and_queue/deque.md

@@ -1685,17 +1685,15 @@ comments: true
 
     ```c title="linkedlist_deque.c"
     /* 双向链表节点 */
-    struct doublyListNode {
+    typedef struct DoublyListNode {
         int val;                     // 节点值
-        struct doublyListNode *next; // 后继节点
-        struct doublyListNode *prev; // 前驱节点
-    };
-
-    typedef struct doublyListNode doublyListNode;
+        struct DoublyListNode *next; // 后继节点
+        struct DoublyListNode *prev; // 前驱节点
+    } DoublyListNode;
 
     /* 构造函数 */
-    doublyListNode *newDoublyListNode(int num) {
-        doublyListNode *new = (doublyListNode *)malloc(sizeof(doublyListNode));
+    DoublyListNode *newDoublyListNode(int num) {
+        DoublyListNode *new = (DoublyListNode *)malloc(sizeof(DoublyListNode));
         new->val = num;
         new->next = NULL;
         new->prev = NULL;
@@ -1703,21 +1701,19 @@ comments: true
     }
 
     /* 析构函数 */
-    void delDoublyListNode(doublyListNode *node) {
+    void delDoublyListNode(DoublyListNode *node) {
         free(node);
     }
 
     /* 基于双向链表实现的双向队列 */
-    struct linkedListDeque {
-        doublyListNode *front, *rear; // 头节点 front ，尾节点 rear
+    typedef struct {
+        DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
         int queSize;                  // 双向队列的长度
-    };
-
-    typedef struct linkedListDeque linkedListDeque;
+    } LinkedListDeque;
 
     /* 构造函数 */
-    linkedListDeque *newLinkedListDeque() {
-        linkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));
+    LinkedListDeque *newLinkedListDeque() {
+        LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));
         deque->front = NULL;
         deque->rear = NULL;
         deque->queSize = 0;
@@ -1725,10 +1721,10 @@ comments: true
     }
 
     /* 析构函数 */
-    void delLinkedListdeque(linkedListDeque *deque) {
+    void delLinkedListdeque(LinkedListDeque *deque) {
         // 释放所有节点
         for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {
-            doublyListNode *tmp = deque->front;
+            DoublyListNode *tmp = deque->front;
             deque->front = deque->front->next;
             free(tmp);
         }
@@ -1737,18 +1733,18 @@ comments: true
     }
 
     /* 获取队列的长度 */
-    int size(linkedListDeque *deque) {
+    int size(LinkedListDeque *deque) {
         return deque->queSize;
     }
 
     /* 判断队列是否为空 */
-    bool empty(linkedListDeque *deque) {
+    bool empty(LinkedListDeque *deque) {
         return (size(deque) == 0);
     }
 
     /* 入队 */
-    void push(linkedListDeque *deque, int num, bool isFront) {
-        doublyListNode *node = newDoublyListNode(num);
+    void push(LinkedListDeque *deque, int num, bool isFront) {
+        DoublyListNode *node = newDoublyListNode(num);
         // 若链表为空，则令 front, rear 都指向node
         if (empty(deque)) {
             deque->front = deque->rear = node;
@@ -1771,36 +1767,36 @@ comments: true
     }
 
     /* 队首入队 */
-    void pushFirst(linkedListDeque *deque, int num) {
+    void pushFirst(LinkedListDeque *deque, int num) {
         push(deque, num, true);
     }
 
     /* 队尾入队 */
-    void pushLast(linkedListDeque *deque, int num) {
+    void pushLast(LinkedListDeque *deque, int num) {
         push(deque, num, false);
     }
 
     /* 访问队首元素 */
-    int peekFirst(linkedListDeque *deque) {
+    int peekFirst(LinkedListDeque *deque) {
         assert(size(deque) && deque->front);
         return deque->front->val;
     }
 
     /* 访问队尾元素 */
-    int peekLast(linkedListDeque *deque) {
+    int peekLast(LinkedListDeque *deque) {
         assert(size(deque) && deque->rear);
         return deque->rear->val;
     }
 
     /* 出队 */
-    int pop(linkedListDeque *deque, bool isFront) {
+    int pop(LinkedListDeque *deque, bool isFront) {
         if (empty(deque))
             return -1;
         int val;
         // 队首出队操作
         if (isFront) {
             val = peekFirst(deque); // 暂存头节点值
-            doublyListNode *fNext = deque->front->next;
+            DoublyListNode *fNext = deque->front->next;
             if (fNext) {
                 fNext->prev = NULL;
                 deque->front->next = NULL;
@@ -1811,7 +1807,7 @@ comments: true
         // 队尾出队操作
         else {
             val = peekLast(deque); // 暂存尾节点值
-            doublyListNode *rPrev = deque->rear->prev;
+            DoublyListNode *rPrev = deque->rear->prev;
             if (rPrev) {
                 rPrev->next = NULL;
                 deque->rear->prev = NULL;
@@ -1824,21 +1820,21 @@ comments: true
     }
 
     /* 队首出队 */
-    int popFirst(linkedListDeque *deque) {
+    int popFirst(LinkedListDeque *deque) {
         return pop(deque, true);
     }
 
     /* 队尾出队 */
-    int popLast(linkedListDeque *deque) {
+    int popLast(LinkedListDeque *deque) {
         return pop(deque, false);
     }
 
     /* 打印队列 */
-    void printLinkedListDeque(linkedListDeque *deque) {
+    void printLinkedListDeque(LinkedListDeque *deque) {
         int arr[deque->queSize];
         // 拷贝链表中的数据到数组
         int i;
-        doublyListNode *node;
+        DoublyListNode *node;
         for (i = 0, node = deque->front; i < deque->queSize; i++) {
             arr[i] = node->val;
             node = node->next;
@@ -3119,18 +3115,16 @@ comments: true
 
     ```c title="array_deque.c"
     /* 基于环形数组实现的双向队列 */
-    struct arrayDeque {
+    typedef struct {
         int *nums;       // 用于存储队列元素的数组
         int front;       // 队首指针，指向队首元素
         int queSize;     // 尾指针，指向队尾 + 1
         int queCapacity; // 队列容量
-    };
-
-    typedef struct arrayDeque arrayDeque;
+    } ArrayDeque;
 
     /* 构造函数 */
-    arrayDeque *newArrayDeque(int capacity) {
-        arrayDeque *deque = (arrayDeque *)malloc(sizeof(arrayDeque));
+    ArrayDeque *newArrayDeque(int capacity) {
+        ArrayDeque *deque = (ArrayDeque *)malloc(sizeof(ArrayDeque));
         // 初始化数组
         deque->queCapacity = capacity;
         deque->nums = (int *)malloc(sizeof(int) * deque->queCapacity);
@@ -3139,28 +3133,28 @@ comments: true
     }
 
     /* 析构函数 */
-    void delArrayDeque(arrayDeque *deque) {
+    void delArrayDeque(ArrayDeque *deque) {
         free(deque->nums);
         deque->queCapacity = 0;
     }
 
     /* 获取双向队列的容量 */
-    int capacity(arrayDeque *deque) {
+    int capacity(ArrayDeque *deque) {
         return deque->queCapacity;
     }
 
     /* 获取双向队列的长度 */
-    int size(arrayDeque *deque) {
+    int size(ArrayDeque *deque) {
         return deque->queSize;
     }
 
     /* 判断双向队列是否为空 */
-    bool empty(arrayDeque *deque) {
+    bool empty(ArrayDeque *deque) {
         return deque->queSize == 0;
     }
 
     /* 计算环形数组索引 */
-    int dequeIndex(arrayDeque *deque, int i) {
+    int dequeIndex(ArrayDeque *deque, int i) {
         // 通过取余操作实现数组首尾相连
         // 当 i 越过数组尾部时，回到头部
         // 当 i 越过数组头部后，回到尾部
@@ -3168,7 +3162,7 @@ comments: true
     }
 
     /* 队首入队 */
-    void pushFirst(arrayDeque *deque, int num) {
+    void pushFirst(ArrayDeque *deque, int num) {
         if (deque->queSize == capacity(deque)) {
             printf("双向队列已满\r\n");
             return;
@@ -3182,7 +3176,7 @@ comments: true
     }
 
     /* 队尾入队 */
-    void pushLast(arrayDeque *deque, int num) {
+    void pushLast(ArrayDeque *deque, int num) {
         if (deque->queSize == capacity(deque)) {
             printf("双向队列已满\r\n");
             return;
@@ -3195,14 +3189,14 @@ comments: true
     }
 
     /* 访问队首元素 */
-    int peekFirst(arrayDeque *deque) {
+    int peekFirst(ArrayDeque *deque) {
         // 访问异常：双向队列为空
         assert(empty(deque) == 0);
         return deque->nums[deque->front];
     }
 
     /* 访问队尾元素 */
-    int peekLast(arrayDeque *deque) {
+    int peekLast(ArrayDeque *deque) {
         // 访问异常：双向队列为空
         assert(empty(deque) == 0);
         int last = dequeIndex(deque, deque->front + deque->queSize - 1);
@@ -3210,7 +3204,7 @@ comments: true
     }
 
     /* 队首出队 */
-    int popFirst(arrayDeque *deque) {
+    int popFirst(ArrayDeque *deque) {
         int num = peekFirst(deque);
         // 队首指针向后移动一位
         deque->front = dequeIndex(deque, deque->front + 1);
@@ -3219,14 +3213,14 @@ comments: true
     }
 
     /* 队尾出队 */
-    int popLast(arrayDeque *deque) {
+    int popLast(ArrayDeque *deque) {
         int num = peekLast(deque);
         deque->queSize--;
         return num;
     }
 
     /* 打印队列 */
-    void printArrayDeque(arrayDeque *deque) {
+    void printArrayDeque(ArrayDeque *deque) {
         int arr[deque->queSize];
         // 拷贝
         for (int i = 0, j = deque->front; i < deque->queSize; i++, j++) {

docs/chapter_stack_and_queue/queue.md

@@ -1031,16 +1031,14 @@ comments: true
 
     ```c title="linkedlist_queue.c"
     /* 基于链表实现的队列 */
-    struct linkedListQueue {
+    typedef struct {
         ListNode *front, *rear;
         int queSize;
-    };
-
-    typedef struct linkedListQueue linkedListQueue;
+    } LinkedListQueue;
 
     /* 构造函数 */
-    linkedListQueue *newLinkedListQueue() {
-        linkedListQueue *queue = (linkedListQueue *)malloc(sizeof(linkedListQueue));
+    LinkedListQueue *newLinkedListQueue() {
+        LinkedListQueue *queue = (LinkedListQueue *)malloc(sizeof(LinkedListQueue));
         queue->front = NULL;
         queue->rear = NULL;
         queue->queSize = 0;
@@ -1048,7 +1046,7 @@ comments: true
     }
 
     /* 析构函数 */
-    void delLinkedListQueue(linkedListQueue *queue) {
+    void delLinkedListQueue(LinkedListQueue *queue) {
         // 释放所有节点
         for (int i = 0; i < queue->queSize && queue->front != NULL; i++) {
             ListNode *tmp = queue->front;
@@ -1060,17 +1058,17 @@ comments: true
     }
 
     /* 获取队列的长度 */
-    int size(linkedListQueue *queue) {
+    int size(LinkedListQueue *queue) {
         return queue->queSize;
     }
 
     /* 判断队列是否为空 */
-    bool empty(linkedListQueue *queue) {
+    bool empty(LinkedListQueue *queue) {
         return (size(queue) == 0);
     }
 
     /* 入队 */
-    void push(linkedListQueue *queue, int num) {
+    void push(LinkedListQueue *queue, int num) {
         // 尾节点处添加 node
         ListNode *node = newListNode(num);
         // 如果队列为空，则令头、尾节点都指向该节点
@@ -1087,13 +1085,13 @@ comments: true
     }
 
     /* 访问队首元素 */
-    int peek(linkedListQueue *queue) {
+    int peek(LinkedListQueue *queue) {
         assert(size(queue) && queue->front);
         return queue->front->val;
     }
 
     /* 出队 */
-    void pop(linkedListQueue *queue) {
+    void pop(LinkedListQueue *queue) {
         int num = peek(queue);
         ListNode *tmp = queue->front;
         queue->front = queue->front->next;
@@ -1102,7 +1100,7 @@ comments: true
     }
 
     /* 打印队列 */
-    void printLinkedListQueue(linkedListQueue *queue) {
+    void printLinkedListQueue(LinkedListQueue *queue) {
         int arr[queue->queSize];
         // 拷贝链表中的数据到数组
         int i;
@@ -1954,18 +1952,16 @@ comments: true
 
     ```c title="array_queue.c"
     /* 基于环形数组实现的队列 */
-    struct arrayQueue {
+    typedef struct {
         int *nums;       // 用于存储队列元素的数组
         int front;       // 队首指针，指向队首元素
         int queSize;     // 尾指针，指向队尾 + 1
         int queCapacity; // 队列容量
-    };
-
-    typedef struct arrayQueue arrayQueue;
+    } ArrayQueue;
 
     /* 构造函数 */
-    arrayQueue *newArrayQueue(int capacity) {
-        arrayQueue *queue = (arrayQueue *)malloc(sizeof(arrayQueue));
+    ArrayQueue *newArrayQueue(int capacity) {
+        ArrayQueue *queue = (ArrayQueue *)malloc(sizeof(ArrayQueue));
         // 初始化数组
         queue->queCapacity = capacity;
         queue->nums = (int *)malloc(sizeof(int) * queue->queCapacity);
@@ -1974,34 +1970,34 @@ comments: true
     }
 
     /* 析构函数 */
-    void delArrayQueue(arrayQueue *queue) {
+    void delArrayQueue(ArrayQueue *queue) {
         free(queue->nums);
         queue->queCapacity = 0;
     }
 
     /* 获取队列的容量 */
-    int capacity(arrayQueue *queue) {
+    int capacity(ArrayQueue *queue) {
         return queue->queCapacity;
     }
 
     /* 获取队列的长度 */
-    int size(arrayQueue *queue) {
+    int size(ArrayQueue *queue) {
         return queue->queSize;
     }
 
     /* 判断队列是否为空 */
-    bool empty(arrayQueue *queue) {
+    bool empty(ArrayQueue *queue) {
         return queue->queSize == 0;
     }
 
     /* 访问队首元素 */
-    int peek(arrayQueue *queue) {
+    int peek(ArrayQueue *queue) {
         assert(size(queue) != 0);
         return queue->nums[queue->front];
     }
 
     /* 入队 */
-    void push(arrayQueue *queue, int num) {
+    void push(ArrayQueue *queue, int num) {
         if (size(queue) == capacity(queue)) {
             printf("队列已满\r\n");
             return;
@@ -2015,7 +2011,7 @@ comments: true
     }
 
     /* 出队 */
-    void pop(arrayQueue *queue) {
+    void pop(ArrayQueue *queue) {
         int num = peek(queue);
         // 队首指针向后移动一位，若越过尾部则返回到数组头部
         queue->front = (queue->front + 1) % queue->queCapacity;
@@ -2023,7 +2019,7 @@ comments: true
     }
 
     /* 打印队列 */
-    void printArrayQueue(arrayQueue *queue) {
+    void printArrayQueue(ArrayQueue *queue) {
         int arr[queue->queSize];
         // 拷贝
         for (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {

docs/chapter_stack_and_queue/stack.md

@@ -937,23 +937,21 @@ comments: true
 
     ```c title="linkedlist_stack.c"
     /* 基于链表实现的栈 */
-    struct linkedListStack {
+    typedef struct {
         ListNode *top; // 将头节点作为栈顶
         int size;      // 栈的长度
-    };
-
-    typedef struct linkedListStack linkedListStack;
+    } LinkedListStack;
 
     /* 构造函数 */
-    linkedListStack *newLinkedListStack() {
-        linkedListStack *s = malloc(sizeof(linkedListStack));
+    LinkedListStack *newLinkedListStack() {
+        LinkedListStack *s = malloc(sizeof(LinkedListStack));
         s->top = NULL;
         s->size = 0;
         return s;
     }
 
     /* 析构函数 */
-    void delLinkedListStack(linkedListStack *s) {
+    void delLinkedListStack(LinkedListStack *s) {
         while (s->top) {
             ListNode *n = s->top->next;
             free(s->top);
@@ -963,26 +961,26 @@ comments: true
     }
 
     /* 获取栈的长度 */
-    int size(linkedListStack *s) {
+    int size(LinkedListStack *s) {
         assert(s);
         return s->size;
     }
 
     /* 判断栈是否为空 */
-    bool isEmpty(linkedListStack *s) {
+    bool isEmpty(LinkedListStack *s) {
         assert(s);
         return size(s) == 0;
     }
 
     /* 访问栈顶元素 */
-    int peek(linkedListStack *s) {
+    int peek(LinkedListStack *s) {
         assert(s);
         assert(size(s) != 0);
         return s->top->val;
     }
 
     /* 入栈 */
-    void push(linkedListStack *s, int num) {
+    void push(LinkedListStack *s, int num) {
         assert(s);
         ListNode *node = (ListNode *)malloc(sizeof(ListNode));
         node->next = s->top; // 更新新加节点指针域
@@ -992,7 +990,7 @@ comments: true
     }
 
     /* 出栈 */
-    int pop(linkedListStack *s) {
+    int pop(LinkedListStack *s) {
         if (s->size == 0) {
             printf("stack is empty.\n");
             return INT_MAX;
@@ -1576,16 +1574,14 @@ comments: true
 
     ```c title="array_stack.c"
     /* 基于数组实现的栈 */
-    struct arrayStack {
+    typedef struct {
         int *data;
         int size;
-    };
-
-    typedef struct arrayStack arrayStack;
+    } ArrayStack;
 
     /* 构造函数 */
-    arrayStack *newArrayStack() {
-        arrayStack *s = malloc(sizeof(arrayStack));
+    ArrayStack *newArrayStack() {
+        ArrayStack *s = malloc(sizeof(ArrayStack));
         // 初始化一个大容量，避免扩容
         s->data = malloc(sizeof(int) * MAX_SIZE);
         s->size = 0;
@@ -1593,17 +1589,17 @@ comments: true
     }
 
     /* 获取栈的长度 */
-    int size(arrayStack *s) {
+    int size(ArrayStack *s) {
         return s->size;
     }
 
     /* 判断栈是否为空 */
-    bool isEmpty(arrayStack *s) {
+    bool isEmpty(ArrayStack *s) {
         return s->size == 0;
     }
 
     /* 入栈 */
-    void push(arrayStack *s, int num) {
+    void push(ArrayStack *s, int num) {
         if (s->size == MAX_SIZE) {
             printf("stack is full.\n");
             return;
@@ -1613,7 +1609,7 @@ comments: true
     }
 
     /* 访问栈顶元素 */
-    int peek(arrayStack *s) {
+    int peek(ArrayStack *s) {
         if (s->size == 0) {
             printf("stack is empty.\n");
             return INT_MAX;
@@ -1622,7 +1618,7 @@ comments: true
     }
 
     /* 出栈 */
-    int pop(arrayStack *s) {
+    int pop(ArrayStack *s) {
         if (s->size == 0) {
             printf("stack is empty.\n");
             return INT_MAX;