Simplify struct declarations of C.

Use PascalCase for all structs in C.
SImplify n_queens.c
Format C code for chapter of graph.

codes/c/chapter_stack_and_queue/array_deque.c

@@ -7,18 +7,16 @@
 #include "../utils/common.h"
 
 /* 基于环形数组实现的双向队列 */
-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);
@@ -27,28 +25,28 @@ arrayDeque *newArrayDeque(int capacity) {
 }
 
 /* 析构函数 */
-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 越过数组头部后，回到尾部
@@ -56,7 +54,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;
@@ -70,7 +68,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;
@@ -83,14 +81,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);
@@ -98,7 +96,7 @@ int peekLast(arrayDeque *deque) {
 }
 
 /* 队首出队 */
-int popFirst(arrayDeque *deque) {
+int popFirst(ArrayDeque *deque) {
     int num = peekFirst(deque);
     // 队首指针向后移动一位
     deque->front = dequeIndex(deque, deque->front + 1);
@@ -107,14 +105,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++) {
@@ -127,7 +125,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

@@ -7,18 +7,16 @@
 #include "../utils/common.h"
 
 /* 基于环形数组实现的队列 */
-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);
@@ -27,34 +25,34 @@ arrayQueue *newArrayQueue(int capacity) {
 }
 
 /* 析构函数 */
-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,7 +66,7 @@ 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;
@@ -76,7 +74,7 @@ void pop(arrayQueue *queue) {
 }
 
 /* 打印队列 */
-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 +87,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

@@ -9,16 +9,14 @@
 #define MAX_SIZE 5000
 
 /* 基于数组实现的栈 */
-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;
@@ -26,17 +24,17 @@ arrayStack *newArrayStack() {
 }
 
 /* 获取栈的长度 */
-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;
@@ -46,7 +44,7 @@ void push(arrayStack *s, int num) {
 }
 
 /* 访问栈顶元素 */
-int peek(arrayStack *s) {
+int peek(ArrayStack *s) {
     if (s->size == 0) {
         printf("stack is empty.\n");
         return INT_MAX;
@@ -55,7 +53,7 @@ int peek(arrayStack *s) {
 }
 
 /* 出栈 */
-int pop(arrayStack *s) {
+int pop(ArrayStack *s) {
     if (s->size == 0) {
         printf("stack is empty.\n");
         return INT_MAX;
@@ -68,7 +66,7 @@ int pop(arrayStack *s) {
 /* Driver Code */
 int main() {
     /* 初始化栈 */
-    arrayStack *stack = newArrayStack();
+    ArrayStack *stack = newArrayStack();
 
     /* 元素入栈 */
     push(stack, 1);

codes/c/chapter_stack_and_queue/linkedlist_deque.c

@@ -7,17 +7,15 @@
 #include "../utils/common.h"
 
 /* 双向链表节点 */
-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;
@@ -25,21 +23,19 @@ doublyListNode *newDoublyListNode(int num) {
 }
 
 /* 析构函数 */
-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;
@@ -47,10 +43,10 @@ linkedListDeque *newLinkedListDeque() {
 }
 
 /* 析构函数 */
-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 +55,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 +89,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 +129,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 +142,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 +167,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,16 +7,14 @@
 #include "../utils/common.h"
 
 /* 基于链表实现的队列 */
-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;
@@ -24,7 +22,7 @@ linkedListQueue *newLinkedListQueue() {
 }
 
 /* 析构函数 */
-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 +34,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 +61,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 +76,7 @@ void pop(linkedListQueue *queue) {
 }
 
 /* 打印队列 */
-void printLinkedListQueue(linkedListQueue *queue) {
+void printLinkedListQueue(LinkedListQueue *queue) {
     int arr[queue->queSize];
     // 拷贝链表中的数据到数组
     int i;
@@ -93,7 +91,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

@@ -7,23 +7,21 @@
 #include "../utils/common.h"
 
 /* 基于链表实现的栈 */
-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);
@@ -33,26 +31,26 @@ void delLinkedListStack(linkedListStack *s) {
 }
 
 /* 获取栈的长度 */
-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; // 更新新加节点指针域
@@ -62,7 +60,7 @@ void push(linkedListStack *s, int num) {
 }
 
 /* 出栈 */
-int pop(linkedListStack *s) {
+int pop(LinkedListStack *s) {
     if (s->size == 0) {
         printf("stack is empty.\n");
         return INT_MAX;
@@ -80,7 +78,7 @@ int pop(linkedListStack *s) {
 /* Driver Code */
 int main() {
     /* 初始化栈 */
-    linkedListStack *stack = newLinkedListStack();
+    LinkedListStack *stack = newLinkedListStack();
 
     /* 元素入栈 */
     push(stack, 1);