Publish the C codes to the docs. (#469)

codes/c/chapter_stack_and_queue/array_deque.c

@@ -6,19 +6,19 @@
 
 #include "../include/include.h"
 
-/* 基于环形数组形成的双向队列 */
-struct ArrayDeque {
+/* 基于环形数组实现的双向队列 */
+struct arrayDeque {
     int *nums;       // 用于存储队列元素的数组
     int front;       // 队首指针，指向队首元素
     int queSize;     // 尾指针，指向队尾 + 1
     int queCapacity; // 队列容量
 };
 
-typedef struct ArrayDeque ArrayDeque;
+typedef struct 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);
@@ -26,28 +26,28 @@ ArrayDeque *newArrayDeque(int capacity) {
     return deque;
 }
 
-/* 析构方法 */
-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 越过数组头部后，回到尾部
@@ -55,7 +55,7 @@ int dequeIndex(ArrayDeque *deque, int i) {
 }
 
 /* 队首入队 */
-void pushFirst(ArrayDeque *deque, int num) {
+void pushFirst(arrayDeque *deque, int num) {
     if (deque->queSize == capacity(deque)) {
         printf("双向队列已满\r\n");
         return;
@@ -69,7 +69,7 @@ void pushFirst(ArrayDeque *deque, int num) {
 }
 
 /* 队尾入队 */
-void pushLast(ArrayDeque *deque, int num) {
+void pushLast(arrayDeque *deque, int num) {
     if (deque->queSize == capacity(deque)) {
         printf("双向队列已满\r\n");
         return;
@@ -82,14 +82,14 @@ void pushLast(ArrayDeque *deque, int num) {
 }
 
 /* 访问队首元素 */
-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);
@@ -97,7 +97,7 @@ int peekLast(ArrayDeque *deque) {
 }
 
 /* 队首出队 */
-int popFirst(ArrayDeque *deque) {
+int popFirst(arrayDeque *deque) {
     int num = peekFirst(deque);
     // 队首指针向后移动一位
     deque->front = dequeIndex(deque, deque->front + 1);
@@ -106,14 +106,14 @@ int popFirst(ArrayDeque *deque) {
 }
 
 /* 队尾出队 */
-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++) {
@@ -126,7 +126,7 @@ void printArrayDeque(ArrayDeque *deque) {
 int main() {
     /* 初始化队列 */
     int capacity = 10;
-    ArrayDeque *deque = newArrayDeque(capacity);
+    arrayDeque *deque = newArrayDeque(capacity);
     pushLast(deque, 3);
     pushLast(deque, 2);
     pushLast(deque, 5);

codes/c/chapter_stack_and_queue/array_queue.c

@@ -6,19 +6,19 @@
 
 #include "../include/include.h"
 
-/* 基于环形数组形成的队列 */
-struct ArrayQueue {
+/* 基于环形数组实现的队列 */
+struct arrayQueue {
     int *nums;       // 用于存储队列元素的数组
     int front;       // 队首指针，指向队首元素
     int queSize;     // 尾指针，指向队尾 + 1
     int queCapacity; // 队列容量
 };
 
-typedef struct ArrayQueue ArrayQueue;
+typedef struct 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);
@@ -26,35 +26,35 @@ ArrayQueue *newArrayQueue(int capacity) {
     return queue;
 }
 
-/* 析构方法 */
-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;
@@ -68,15 +68,15 @@ void push(ArrayQueue *queue, int num) {
 }
 
 /* 出队 */
-void pop(ArrayQueue *queue) {
+void pop(arrayQueue *queue) {
     int num = peek(queue);
     // 队首指针向后移动一位，若越过尾部则返回到数组头部
     queue->front = (queue->front + 1) % queue->queCapacity;
     queue->queSize--;
 }
 
-/* 打印基于环形数组形成的队列 */
-void printArrayQueue(ArrayQueue *queue) {
+/* 打印队列 */
+void printArrayQueue(arrayQueue *queue) {
     int arr[queue->queSize];
     // 拷贝
     for (int i = 0, j = queue->front; i < queue->queSize; i++, j++) {
@@ -89,7 +89,7 @@ void printArrayQueue(ArrayQueue *queue) {
 int main() {
     /* 初始化队列 */
     int capacity = 10;
-    ArrayQueue *queue = newArrayQueue(capacity);
+    arrayQueue *queue = newArrayQueue(capacity);
 
     /* 元素入队 */
     push(queue, 1);

codes/c/chapter_stack_and_queue/array_stack.c

@@ -16,6 +16,7 @@ struct arrayStack {
 
 typedef struct arrayStack arrayStack;
 
+/* 构造函数 */
 arrayStack *newArrayStack() {
     arrayStack *s = malloc(sizeof(arrayStack));
     // 初始化一个大容量，避免扩容

codes/c/chapter_stack_and_queue/linkedlist_deque.c

@@ -7,50 +7,50 @@
 #include "../include/include.h"
 
 /* 双向链表节点 */
-struct DoublyListNode {
+struct doublyListNode {
     int val;                     // 节点值
-    struct DoublyListNode *next; // 后继节点
-    struct DoublyListNode *prev; // 前驱节点
+    struct doublyListNode *next; // 后继节点
+    struct doublyListNode *prev; // 前驱节点
 };
 
-typedef struct DoublyListNode DoublyListNode;
+typedef struct doublyListNode 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;
     return new;
 }
 
-/* 双向链表节点析构方法 */
-void delDoublyListNode(DoublyListNode *node) {
+/* 析构函数 */
+void delDoublyListNode(doublyListNode *node) {
     free(node);
 }
 
 /* 基于双向链表实现的双向队列 */
-struct LinkedListDeque {
-    DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
+struct linkedListDeque {
+    doublyListNode *front, *rear; // 头节点 front ，尾节点 rear
     int queSize;                  // 双向队列的长度
 };
 
-typedef struct LinkedListDeque LinkedListDeque;
+typedef struct linkedListDeque linkedListDeque;
 
-/* 构造方法 */
-LinkedListDeque *newLinkedListDeque() {
-    LinkedListDeque *deque = (LinkedListDeque *)malloc(sizeof(LinkedListDeque));
+/* 构造j */
+linkedListDeque *newLinkedListDeque() {
+    linkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));
     deque->front = NULL;
     deque->rear = NULL;
     deque->queSize = 0;
     return deque;
 }
 
-/* 析构方法 */
-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);
     }
@@ -59,18 +59,18 @@ void delLinkedListdeque(LinkedListDeque *deque) {
 }
 
 /* 获取队列的长度 */
-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;
@@ -93,36 +93,36 @@ void push(LinkedListDeque *deque, int num, bool isFront) {
 }
 
 /* 队首入队 */
-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;
@@ -133,7 +133,7 @@ int pop(LinkedListDeque *deque, bool isFront) {
     // 队尾出队操作
     else {
         val = peekLast(deque); // 暂存尾节点值
-        DoublyListNode *rPrev = deque->rear->prev;
+        doublyListNode *rPrev = deque->rear->prev;
         if (rPrev) {
             rPrev->next = NULL;
             deque->rear->prev = NULL;
@@ -146,21 +146,21 @@ int pop(LinkedListDeque *deque, bool isFront) {
 }
 
 /* 队首出队 */
-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;
@@ -171,7 +171,7 @@ void printLinkedListDeque(LinkedListDeque *deque) {
 /* Driver Code */
 int main() {
     /* 初始化双向队列 */
-    LinkedListDeque *deque = newLinkedListDeque();
+    linkedListDeque *deque = newLinkedListDeque();
     pushLast(deque, 3);
     pushLast(deque, 2);
     pushLast(deque, 5);

codes/c/chapter_stack_and_queue/linkedlist_queue.c

@@ -7,24 +7,24 @@
 #include "../include/include.h"
 
 /* 基于链表实现的队列 */
-struct LinkedListQueue {
+struct linkedListQueue {
     ListNode *front, *rear;
     int queSize;
 };
 
-typedef struct LinkedListQueue LinkedListQueue;
+typedef struct 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;
     return queue;
 }
 
-/* 析构方法 */
-void delLinkedListQueue(LinkedListQueue *queue) {
+/* 析构函数 */
+void delLinkedListQueue(linkedListQueue *queue) {
     // 释放所有节点
     for (int i = 0; i < queue->queSize && queue->front != NULL; i++) {
         ListNode *tmp = queue->front;
@@ -36,17 +36,17 @@ void delLinkedListQueue(LinkedListQueue *queue) {
 }
 
 /* 获取队列的长度 */
-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);
     // 如果队列为空，则令头、尾节点都指向该节点
@@ -63,13 +63,13 @@ void push(LinkedListQueue *queue, int num) {
 }
 
 /* 访问队首元素 */
-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;
@@ -78,7 +78,7 @@ void pop(LinkedListQueue *queue) {
 }
 
 /* 打印队列 */
-void printLinkedListQueue(LinkedListQueue *queue) {
+void printLinkedListQueue(linkedListQueue *queue) {
     int arr[queue->queSize];
     // 拷贝链表中的数据到数组
     int i;
@@ -93,7 +93,7 @@ void printLinkedListQueue(LinkedListQueue *queue) {
 /* Driver Code */
 int main() {
     /* 初始化队列 */
-    LinkedListQueue *queue = newLinkedListQueue();
+    linkedListQueue *queue = newLinkedListQueue();
 
     /* 元素入队 */
     push(queue, 1);

codes/c/chapter_stack_and_queue/linkedlist_stack.c

@@ -14,7 +14,7 @@ struct linkedListStack {
 
 typedef struct linkedListStack linkedListStack;
 
-/* 构造方法 */
+/* 构造函数 */
 linkedListStack *newLinkedListStack() {
     linkedListStack *s = malloc(sizeof(linkedListStack));
     s->top = NULL;
@@ -22,7 +22,7 @@ linkedListStack *newLinkedListStack() {
     return s;
 }
 
-/* 析构方法 */
+/* 析构函数 */
 void delLinkedListStack(linkedListStack *s) {
     while (s->top) {
         ListNode *n = s->top->next;
@@ -80,7 +80,6 @@ int pop(linkedListStack *s) {
 /* Driver Code */
 int main() {
     /* 初始化栈 */
-    // 构造方法
     linkedListStack *stack = newLinkedListStack();
 
     /* 元素入栈 */