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_array_and_linkedlist/my_list.c

@@ -7,20 +7,18 @@
 #include "../utils/common.h"
 
 /* 列表类简易实现 */
-struct myList {
+typedef struct {
     int *arr;        // 数组（存储列表元素）
     int capacity;    // 列表容量
     int size;        // 列表大小
     int extendRatio; // 列表每次扩容的倍数
-};
+} MyList;
 
-typedef struct myList myList;
+void extendCapacity(MyList *nums);
-
-void extendCapacity(myList *nums);
 
 /* 构造函数 */
-myList *newMyList() {
+MyList *newMyList() {
-    myList *nums = malloc(sizeof(myList));
+    MyList *nums = malloc(sizeof(MyList));
     nums->capacity = 10;
     nums->arr = malloc(sizeof(int) * nums->capacity);
     nums->size = 0;
@@ -29,35 +27,35 @@ myList *newMyList() {
 }
 
 /* 析构函数 */
-void delMyList(myList *nums) {
+void delMyList(MyList *nums) {
     free(nums->arr);
     free(nums);
 }
 
 /* 获取列表长度 */
-int size(myList *nums) {
+int size(MyList *nums) {
     return nums->size;
 }
 
 /* 获取列表容量 */
-int capacity(myList *nums) {
+int capacity(MyList *nums) {
     return nums->capacity;
 }
 
 /* 访问元素 */
-int get(myList *nums, int index) {
+int get(MyList *nums, int index) {
     assert(index >= 0 && index < nums->size);
     return nums->arr[index];
 }
 
 /* 更新元素 */
-void set(myList *nums, int index, int num) {
+void set(MyList *nums, int index, int num) {
     assert(index >= 0 && index < nums->size);
     nums->arr[index] = num;
 }
 
 /* 尾部添加元素 */
-void add(myList *nums, int num) {
+void add(MyList *nums, int num) {
     if (size(nums) == capacity(nums)) {
         extendCapacity(nums); // 扩容
     }
@@ -66,7 +64,7 @@ void add(myList *nums, int num) {
 }
 
 /* 中间插入元素 */
-void insert(myList *nums, int index, int num) {
+void insert(MyList *nums, int index, int num) {
     assert(index >= 0 && index < size(nums));
     // 元素数量超出容量时，触发扩容机制
     if (size(nums) == capacity(nums)) {
@@ -81,7 +79,7 @@ void insert(myList *nums, int index, int num) {
 
 /* 删除元素 */
 // 注意：stdio.h 占用了 remove 关键词
-int removeNum(myList *nums, int index) {
+int removeNum(MyList *nums, int index) {
     assert(index >= 0 && index < size(nums));
     int num = nums->arr[index];
     for (int i = index; i < size(nums) - 1; i++) {
@@ -92,7 +90,7 @@ int removeNum(myList *nums, int index) {
 }
 
 /* 列表扩容 */
-void extendCapacity(myList *nums) {
+void extendCapacity(MyList *nums) {
     // 先分配空间
     int newCapacity = capacity(nums) * nums->extendRatio;
     int *extend = (int *)malloc(sizeof(int) * newCapacity);
@@ -111,14 +109,14 @@ void extendCapacity(myList *nums) {
 }
 
 /* 将列表转换为 Array 用于打印 */
-int *toArray(myList *nums) {
+int *toArray(MyList *nums) {
     return nums->arr;
 }
 
 /* Driver Code */
 int main() {
     /* 初始化列表 */
-    myList *nums = newMyList();
+    MyList *nums = newMyList();
     /* 尾部添加元素 */
     add(nums, 1);
     add(nums, 3);

codes/c/chapter_backtracking/n_queens.c

@@ -9,25 +9,17 @@
 #define MAX_N 100
 #define MAX_RES 1000
 
-/* 放置结果 */
-struct result {
-    char ***data;
-    int size;
-};
-
-typedef struct result Result;
-
 /* 回溯算法：N 皇后 */
-void backtrack(int row, int n, char state[MAX_N][MAX_N], Result *res, 
+void backtrack(int row, int n, char state[MAX_N][MAX_N], char ***res, int *resSize, bool cols[MAX_N],
-        bool cols[MAX_N], bool diags1[2 * MAX_N - 1], bool diags2[2 * MAX_N - 1]) {
+               bool diags1[2 * MAX_N - 1], bool diags2[2 * MAX_N - 1]) {
     // 当放置完所有行时，记录解
     if (row == n) {
-        res->data[res->size] = (char **)malloc(sizeof(char *) * n);
+        res[*resSize] = (char **)malloc(sizeof(char *) * n);
         for (int i = 0; i < n; ++i) {
-            res->data[res->size][i] = (char *)malloc(sizeof(char) * (n + 1));
+            res[*resSize][i] = (char *)malloc(sizeof(char) * (n + 1));
-            strcpy(res->data[res->size][i], state[i]);
+            strcpy(res[*resSize][i], state[i]);
         }
-        res->size++;
+        (*resSize)++;
         return;
     }
     // 遍历所有列
@@ -41,7 +33,7 @@ void backtrack(int row, int n, char state[MAX_N][MAX_N], Result *res,
             state[row][col] = 'Q';
             cols[col] = diags1[diag1] = diags2[diag2] = true;
             // 放置下一行
-            backtrack(row + 1, n, state, res, cols, diags1, diags2);
+            backtrack(row + 1, n, state, res, resSize, cols, diags1, diags2);
             // 回退：将该格子恢复为空位
             state[row][col] = '#';
             cols[col] = diags1[diag1] = diags2[diag2] = false;
@@ -50,7 +42,7 @@ void backtrack(int row, int n, char state[MAX_N][MAX_N], Result *res,
 }
 
 /* 求解 N 皇后 */
-Result *nQueens(int n) {
+char ***nQueens(int n, int *returnSize) {
     char state[MAX_N][MAX_N];
     // 初始化 n*n 大小的棋盘，其中 'Q' 代表皇后，'#' 代表空位
     for (int i = 0; i < n; ++i) {
@@ -63,26 +55,26 @@ Result *nQueens(int n) {
     bool diags1[2 * MAX_N - 1] = {false}; // 记录主对角线是否有皇后
     bool diags2[2 * MAX_N - 1] = {false}; // 记录副对角线是否有皇后
 
-    Result *res = malloc(sizeof(Result));
+    char ***res = (char ***)malloc(sizeof(char **) * MAX_RES);
-    res->data = (char ***)malloc(sizeof(char **) * MAX_RES);
+    *returnSize = 0;
-    res->size = 0;
+    backtrack(0, n, state, res, returnSize, cols, diags1, diags2);
-    backtrack(0, n, state, res, cols, diags1, diags2);
     return res;
 }
 
 /* Driver Code */
 int main() {
     int n = 4;
-    Result *res = nQueens(n);
+    int returnSize;
+    char ***res = nQueens(n, &returnSize);
 
     printf("输入棋盘长宽为%d\n", n);
-    printf("皇后放置方案共有 %d 种\n", res->size);
+    printf("皇后放置方案共有 %d 种\n", returnSize);
-    for (int i = 0; i < res->size; ++i) {
+    for (int i = 0; i < returnSize; ++i) {
         for (int j = 0; j < n; ++j) {
             printf("[");
-            for (int k = 0; res->data[i][j][k] != '\0'; ++k) {
+            for (int k = 0; res[i][j][k] != '\0'; ++k) {
-                printf("%c", res->data[i][j][k]);
+                printf("%c", res[i][j][k]);
-                if (res->data[i][j][k + 1] != '\0') {
+                if (res[i][j][k + 1] != '\0') {
                     printf(", ");
                 }
             }
@@ -92,13 +84,13 @@ int main() {
     }
 
     // 释放内存
-    for (int i = 0; i < res->size; ++i) {
+    for (int i = 0; i < returnSize; ++i) {
         for (int j = 0; j < n; ++j) {
-            free(res->data[i][j]);
+            free(res[i][j]);
         }
-        free(res->data[i]);
+        free(res[i]);
     }
-    free(res->data);
+    free(res);
 
     return 0;
 }

codes/c/chapter_computational_complexity/space_complexity.c

@@ -31,13 +31,11 @@ void constant(int n) {
 }
 
 /* 哈希表 */
-struct hashTable {
+typedef struct {
     int key;
     int val;
     UT_hash_handle hh; // 基于 uthash.h 实现
-};
+} HashTable;
-
-typedef struct hashTable hashTable;
 
 /* 线性阶 */
 void linear(int n) {
@@ -57,16 +55,16 @@ void linear(int n) {
     free(nodes);
 
     // 长度为 n 的哈希表占用 O(n) 空间
-    hashTable *h = NULL;
+    HashTable *h = NULL;
     for (int i = 0; i < n; i++) {
-        hashTable *tmp = malloc(sizeof(hashTable));
+        HashTable *tmp = malloc(sizeof(HashTable));
         tmp->key = i;
         tmp->val = i;
         HASH_ADD_INT(h, key, tmp);
     }
 
     // 内存释放
-    hashTable *curr, *tmp;
+    HashTable *curr, *tmp;
     HASH_ITER(hh, h, curr, tmp) {
         HASH_DEL(h, curr);
         free(curr);

codes/c/chapter_divide_and_conquer/binary_search_recur.c

@@ -42,6 +42,6 @@ int main() {
     // 二分查找（双闭区间）
     int index = binarySearch(nums, target, numsSize);
     printf("目标元素 6 的索引 = %d\n", index);
-    
+
     return 0;
 }

codes/c/chapter_divide_and_conquer/build_tree.c

@@ -1,8 +1,8 @@
 /**
-  * File : build_tree.c
+ * File : build_tree.c
-  * Created Time: 2023-10-16
+ * Created Time: 2023-10-16
-  * Author : lucas (superrat6@gmail.com)
+ * Author : lucas (superrat6@gmail.com)
-  */
+ */
 
 #include "../utils/common.h"
 
@@ -10,12 +10,12 @@
 #define MAX_N 1000
 
 /* 构建二叉树：分治 */
-TreeNode* dfs(int* preorder, int* inorderMap, int i, int l, int r, int size) {
+TreeNode *dfs(int *preorder, int *inorderMap, int i, int l, int r, int size) {
     // 子树区间为空时终止
     if (r - l < 0)
         return NULL;
     // 初始化根节点
-    TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
+    TreeNode *root = (TreeNode *)malloc(sizeof(TreeNode));
     root->val = preorder[i];
     root->left = NULL;
     root->right = NULL;
@@ -30,13 +30,13 @@ TreeNode* dfs(int* preorder, int* inorderMap, int i, int l, int r, int size) {
 }
 
 /* 构建二叉树 */
-TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize) {
+TreeNode *buildTree(int *preorder, int preorderSize, int *inorder, int inorderSize) {
     // 初始化哈希表，存储 inorder 元素到索引的映射
-    int* inorderMap = (int*)malloc(sizeof(int) * MAX_N);
+    int *inorderMap = (int *)malloc(sizeof(int) * MAX_N);
     for (int i = 0; i < inorderSize; i++) {
         inorderMap[inorder[i]] = i;
     }
-    TreeNode* root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);
+    TreeNode *root = dfs(preorder, inorderMap, 0, 0, inorderSize - 1, inorderSize);
     free(inorderMap);
     return root;
 }
@@ -52,7 +52,7 @@ int main() {
     printf("中序遍历 = ");
     printArray(inorder, inorderSize);
 
-    TreeNode* root = buildTree(preorder, preorderSize, inorder, inorderSize);
+    TreeNode *root = buildTree(preorder, preorderSize, inorder, inorderSize);
     printf("构建的二叉树为：\n");
     printTree(root);
 

codes/c/chapter_dynamic_programming/climbing_stairs_backtrack.c

@@ -28,7 +28,7 @@ int climbingStairsBacktrack(int n) {
     int choices[2] = {1, 2}; // 可选择向上爬 1 或 2 阶
     int state = 0;           // 从第 0 阶开始爬
     int *res = (int *)malloc(sizeof(int));
-    *res = 0;                // 使用 res[0] 记录方案数量
+    *res = 0; // 使用 res[0] 记录方案数量
     int len = sizeof(choices) / sizeof(int);
     backtrack(choices, state, n, res, len);
     int result = *res;

codes/c/chapter_dynamic_programming/climbing_stairs_dfs_mem.c

@@ -36,7 +36,7 @@ int climbingStairsDFSMem(int n) {
 /* Driver Code */
 int main() {
     int n = 9;
-    
+
     int res = climbingStairsDFSMem(n);
     printf("爬 %d 阶楼梯共有 %d 种方案\n", n, res);
 

codes/c/chapter_dynamic_programming/min_cost_climbing_stairs_dp.c

@@ -48,8 +48,10 @@ int main() {
     int costSize = sizeof(cost) / sizeof(cost[0]);
     printf("输入楼梯的代价列表为 [");
     for (int i = 0; i < costSize; i++) {
-        if (i != costSize - 1) printf("%d, ", cost[i]);
+        if (i != costSize - 1)
-        else printf("%d", cost[i]);
+            printf("%d, ", cost[i]);
+        else
+            printf("%d", cost[i]);
     }
     printf("]\n");
 

codes/c/chapter_graph/graph_adjacency_list.c

@@ -8,11 +8,11 @@
 
 typedef struct Vertex Vertex;
 typedef struct Node Node;
-typedef struct linkList linkList;
+typedef struct LinkedList LinkedList;
 
 void freeVertex(Vertex *);
-void freeLinklist(linkList *);
+void freeLinklist(LinkedList *);
-linkList *newLinklist(Vertex *);
+LinkedList *newLinklist(Vertex *);
 
 /* 链表节点 */
 struct Node {
@@ -34,7 +34,7 @@ struct Vertex {
     // 节点值
     int val;
     // 与其它节点相连接的边的链表
-    linkList *linked;
+    LinkedList *list;
     // 索引位，标记该顶点在顶点列表中的索引
     unsigned int pos;
 };
@@ -44,52 +44,52 @@ Vertex *newVertex(int val) {
     Vertex *vet = (Vertex *)malloc(sizeof(Vertex));
     // 为新节点赋值并建立该节点的链表
     vet->val = val;
-    vet->linked = newLinklist(vet);
+    vet->list = newLinklist(vet);
     return vet;
 }
 
 /* 顶点内存释放函数 */
 void freeVertex(Vertex *val) {
     // 释放该顶点和该顶点的链表的内存
-    freeLinklist(val->linked);
+    freeLinklist(val->list);
     free(val);
 }
 
 /* 链表 */
-struct linkList {
+struct LinkedList {
     Node *head;
     Node *tail;
 };
 
 /* 链表头插法 */
-void pushFront(linkList *l, Vertex *val) {
+void pushFront(LinkedList *list, Vertex *val) {
     Node *temp = newNode();
     temp->val = val;
-    temp->next = l->head->next;
+    temp->next = list->head->next;
-    l->head->next = temp;
+    list->head->next = temp;
-    if (l->tail == l->head) {
+    if (list->tail == list->head) {
-        l->tail = temp;
+        list->tail = temp;
     }
 }
 
 /* 链表尾插法 */
-void pushBack(linkList *l, Vertex *val) {
+void pushBack(LinkedList *list, Vertex *val) {
     Node *temp = newNode();
     temp->val = val;
     temp->next = 0;
-    l->tail->next = temp;
+    list->tail->next = temp;
-    l->tail = temp;
+    list->tail = temp;
 }
 
 /* 根据顶点地址与该顶点连接的删除边 */
-void removeLink(linkList *l, Vertex *val) {
+void removeLink(LinkedList *list, Vertex *val) {
-    Node *temp = l->head->next;
+    Node *temp = list->head->next;
-    Node *front = l->head;
+    Node *front = list->head;
     while (temp != 0) {
         if (temp->val == val) {
             front->next = temp->next;
-            if (l->tail == temp) {
+            if (list->tail == temp) {
-                l->tail = front;
+                list->tail = front;
             }
             free(temp);
             return;
@@ -97,21 +97,20 @@ void removeLink(linkList *l, Vertex *val) {
         front = temp;
         temp = temp->next;
     }
-
     if (temp->next == 0) {
         printf("vertex not found!\n");
     }
 }
 
 /* 根据顶点地址删除顶点 */
-void removeItem(linkList *l, Vertex *val) {
+void removeItem(LinkedList *list, Vertex *val) {
-    Node *temp = l->head->next;
+    Node *temp = list->head->next;
-    Node *front = l->head;
+    Node *front = list->head;
     while (temp != 0) {
         if (temp->val == val) {
             front->next = temp->next;
-            if (l->tail == temp) {
+            if (list->tail == temp) {
-                l->tail = front;
+                list->tail = front;
             }
             freeVertex(val);
             free(temp);
@@ -120,137 +119,125 @@ void removeItem(linkList *l, Vertex *val) {
         front = temp;
         temp = temp->next;
     }
-
     if (temp->next == 0) {
         printf("vertex not found!\n");
     }
 }
 
 /* 释放链表内存 */
-void freeLinklist(linkList *l) {
+void freeLinklist(LinkedList *list) {
-    Node *temp = l->head->next;
+    Node *temp = list->head->next;
     while (temp != 0) {
-        free(l->head);
+        free(list->head);
-        l->head = temp;
+        list->head = temp;
         temp = temp->next;
     }
-    free(l->head);
+    free(list->head);
-    l->head = 0;
+    list->head = 0;
-    free(l);
+    free(list);
 }
 
 /* 链表构造函数 */
-linkList *newLinklist(Vertex *val) {
+LinkedList *newLinklist(Vertex *val) {
-    linkList *newLinklist = (linkList *)malloc(sizeof(linkList));
+    LinkedList *newLinklist = (LinkedList *)malloc(sizeof(LinkedList));
-
     newLinklist->head = newNode();
     newLinklist->head->val = val;
     newLinklist->tail = newLinklist->head;
     newLinklist->head->next = 0;
-
     return newLinklist;
 }
 
 /* 基于邻接链表实现的无向图类结构 */
-struct graphAdjList {
+typedef struct {
-    Vertex **verticesList; // 邻接表
+    Vertex **vertices;     // 邻接表
     unsigned int size;     // 顶点数量
     unsigned int capacity; // 顶点容量
-};
+} GraphAdjList;
-
-typedef struct graphAdjList graphAdjList;
 
 /* 添加边 */
-void addEdge(graphAdjList *t, int i, int j) {
+void addEdge(GraphAdjList *graph, int i, int j) {
     // 越界检查
-    if (i < 0 || j < 0 || i == j || i >= t->size || j >= t->size) {
+    if (i < 0 || j < 0 || i == j || i >= graph->size || j >= graph->size) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         return;
     }
     // 查找欲添加边的顶点 vet1 - vet2
-    Vertex *vet1 = t->verticesList[i];
+    Vertex *vet1 = graph->vertices[i];
-    Vertex *vet2 = t->verticesList[j];
+    Vertex *vet2 = graph->vertices[j];
-
     // 连接顶点 vet1 - vet2
-    pushBack(vet1->linked, vet2);
+    pushBack(vet1->list, vet2);
-    pushBack(vet2->linked, vet1);
+    pushBack(vet2->list, vet1);
 }
 
 /* 删除边 */
-void removeEdge(graphAdjList *t, int i, int j) {
+void removeEdge(GraphAdjList *graph, int i, int j) {
     // 越界检查
-    if (i < 0 || j < 0 || i == j || i >= t->size || j >= t->size) {
+    if (i < 0 || j < 0 || i == j || i >= graph->size || j >= graph->size) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         return;
     }
-
     // 查找欲删除边的顶点 vet1 - vet2
-    Vertex *vet1 = t->verticesList[i];
+    Vertex *vet1 = graph->vertices[i];
-    Vertex *vet2 = t->verticesList[j];
+    Vertex *vet2 = graph->vertices[j];
-
     // 移除待删除边 vet1 - vet2
-    removeLink(vet1->linked, vet2);
+    removeLink(vet1->list, vet2);
-    removeLink(vet2->linked, vet1);
+    removeLink(vet2->list, vet1);
 }
 
 /* 添加顶点 */
-void addVertex(graphAdjList *t, int val) {
+void addVertex(GraphAdjList *graph, int val) {
     // 若大小超过容量，则扩容
-    if (t->size >= t->capacity) {
+    if (graph->size >= graph->capacity) {
-        Vertex **tempList = (Vertex **)malloc(sizeof(Vertex *) * 2 * t->capacity);
+        Vertex **tempList = (Vertex **)malloc(sizeof(Vertex *) * 2 * graph->capacity);
-        memcpy(tempList, t->verticesList, sizeof(Vertex *) * t->size);
+        memcpy(tempList, graph->vertices, sizeof(Vertex *) * graph->size);
-        free(t->verticesList);         // 释放原邻接表内存
+        free(graph->vertices);                 // 释放原邻接表内存
-        t->verticesList = tempList;    // 指向新邻接表
+        graph->vertices = tempList;            // 指向新邻接表
-        t->capacity = t->capacity * 2; // 容量扩大至2倍
+        graph->capacity = graph->capacity * 2; // 容量扩大至2倍
     }
     // 申请新顶点内存并将新顶点地址存入顶点列表
-    Vertex *newV = newVertex(val);    // 建立新顶点
+    Vertex *newV = newVertex(val);       // 建立新顶点
-    newV->pos = t->size;              // 为新顶点标记下标
+    newV->pos = graph->size;             // 为新顶点标记下标
-    newV->linked = newLinklist(newV); // 为新顶点建立链表
+    newV->list = newLinklist(newV);      // 为新顶点建立链表
-    t->verticesList[t->size] = newV;  // 将新顶点加入邻接表
+    graph->vertices[graph->size] = newV; // 将新顶点加入邻接表
-    t->size++;
+    graph->size++;
 }
 
 /* 删除顶点 */
-void removeVertex(graphAdjList *t, unsigned int index) {
+void removeVertex(GraphAdjList *graph, unsigned int index) {
     // 越界检查
-    if (index < 0 || index >= t->size) {
+    if (index < 0 || index >= graph->size) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         exit(1);
     }
-
+    Vertex *vet = graph->vertices[index]; // 查找待删节点
-    Vertex *vet = t->verticesList[index]; // 查找待删节点
     if (vet == 0) {                       // 若不存在该节点，则返回
         printf("index is:%d\n", index);
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         return;
     }
-
     // 遍历待删除顶点的链表，将所有与待删除结点有关的边删除
-    Node *temp = vet->linked->head->next;
+    Node *temp = vet->list->head->next;
     while (temp != 0) {
-        removeLink(temp->val->linked, vet); // 删除与该顶点有关的边
+        removeLink(temp->val->list, vet); // 删除与该顶点有关的边
         temp = temp->next;
     }
-
     // 将顶点前移
-    for (int i = index; i < t->size - 1; i++) {
+    for (int i = index; i < graph->size - 1; i++) {
-        t->verticesList[i] = t->verticesList[i + 1]; // 顶点前移
+        graph->vertices[i] = graph->vertices[i + 1]; // 顶点前移
-        t->verticesList[i]->pos--;                   // 所有前移的顶点索引值减1
+        graph->vertices[i]->pos--;                   // 所有前移的顶点索引值减1
     }
-    t->verticesList[t->size - 1] = 0; // 将被删除顶点的位置置 0
+    graph->vertices[graph->size - 1] = 0; // 将被删除顶点的位置置 0
-    t->size--;
+    graph->size--;
-
     // 释放内存
     freeVertex(vet);
 }
 
 /* 打印顶点与邻接矩阵 */
-void printGraph(graphAdjList *t) {
+void printGraph(GraphAdjList *graph) {
     printf("邻接表  =\n");
-    for (int i = 0; i < t->size; i++) {
+    for (int i = 0; i < graph->size; i++) {
-        Node *n = t->verticesList[i]->linked->head->next;
+        Node *n = graph->vertices[i]->list->head->next;
-        printf("%d: [", t->verticesList[i]->val);
+        printf("%d: [", graph->vertices[i]->val);
         while (n != 0) {
             if (n->next != 0) {
                 printf("%d, ", n->val->val);
@@ -264,14 +251,14 @@ void printGraph(graphAdjList *t) {
 }
 
 /* 构造函数 */
-graphAdjList *newGraphAdjList(unsigned int verticesCapacity) {
+GraphAdjList *newGraphAdjList(unsigned int verticesCapacity) {
     // 申请内存
-    graphAdjList *newGraph = (graphAdjList *)malloc(sizeof(graphAdjList));
+    GraphAdjList *newGraph = (GraphAdjList *)malloc(sizeof(GraphAdjList));
     // 建立顶点表并分配内存
-    newGraph->verticesList = (Vertex **)malloc(sizeof(Vertex *) * verticesCapacity); // 为顶点列表分配内存
+    newGraph->vertices = (Vertex **)malloc(sizeof(Vertex *) * verticesCapacity); // 为顶点列表分配内存
-    memset(newGraph->verticesList, 0, sizeof(Vertex *) * verticesCapacity);          // 顶点列表置 0
+    memset(newGraph->vertices, 0, sizeof(Vertex *) * verticesCapacity);          // 顶点列表置 0
-    newGraph->size = 0;                                                              // 初始化顶点数量
+    newGraph->size = 0;                                                          // 初始化顶点数量
-    newGraph->capacity = verticesCapacity;                                           // 初始化顶点容量
+    newGraph->capacity = verticesCapacity;                                       // 初始化顶点容量
     // 返回图指针
     return newGraph;
 }

codes/c/chapter_graph/graph_adjacency_list_test.c

@@ -9,7 +9,7 @@
 /* Driver Code */
 int main() {
     /* 初始化无向图 */
-    graphAdjList *graph = newGraphAdjList(5);
+    GraphAdjList *graph = newGraphAdjList(5);
     // 初始化顶点
     addVertex(graph, 1);
     addVertex(graph, 3);

codes/c/chapter_graph/graph_adjacency_matrix.c

@@ -7,143 +7,133 @@
 #include "../utils/common.h"
 
 /* 基于邻接矩阵实现的无向图类结构 */
-struct graphAdjMat {
+typedef struct {
-    int *vertices;         // 顶点列表
+    int *vertices; // 顶点列表
-    unsigned int **adjMat; // 邻接矩阵，元素代表“边”，索引代表“顶点索引”
+    int **adjMat;  // 邻接矩阵，元素代表“边”，索引代表“顶点索引”
-    unsigned int size;     // 顶点数量
+    int size;      // 顶点数量
-    unsigned int capacity; // 图容量
+    int capacity;  // 图容量
-};
+} GraphAdjMat;
-
-typedef struct graphAdjMat graphAdjMat;
 
 /* 添加边 */
 // 参数 i, j 对应 vertices 元素索引
-void addEdge(graphAdjMat *t, int i, int j) {
+void addEdge(GraphAdjMat *graph, int i, int j) {
     // 越界检查
-    if (i < 0 || j < 0 || i >= t->size || j >= t->size || i == j) {
+    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         exit(1);
     }
     // 添加边
     // 参数 i, j 对应 vertices 元素索引
-    t->adjMat[i][j] = 1;
+    graph->adjMat[i][j] = 1;
-    t->adjMat[j][i] = 1;
+    graph->adjMat[j][i] = 1;
 }
 
 /* 删除边 */
 // 参数 i, j 对应 vertices 元素索引
-void removeEdge(graphAdjMat *t, int i, int j) {
+void removeEdge(GraphAdjMat *graph, int i, int j) {
     // 越界检查
-    if (i < 0 || j < 0 || i >= t->size || j >= t->size || i == j) {
+    if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         exit(1);
     }
     // 删除边
     // 参数 i, j 对应 vertices 元素索引
-    t->adjMat[i][j] = 0;
+    graph->adjMat[i][j] = 0;
-    t->adjMat[j][i] = 0;
+    graph->adjMat[j][i] = 0;
 }
 
 /* 添加顶点 */
-void addVertex(graphAdjMat *t, int val) {
+void addVertex(GraphAdjMat *graph, int val) {
     // 如果实际使用不大于预设空间，则直接初始化新空间
-    if (t->size < t->capacity) {
+    if (graph->size < graph->capacity) {
-        t->vertices[t->size] = val; // 初始化新顶点值
+        graph->vertices[graph->size] = val; // 初始化新顶点值
-        for (int i = 0; i < t->size; i++) {
+        for (int i = 0; i < graph->size; i++) {
-            t->adjMat[i][t->size] = 0; // 邻接矩新列阵置0
+            graph->adjMat[i][graph->size] = 0; // 邻接矩新列阵置0
         }
-        memset(t->adjMat[t->size], 0, sizeof(unsigned int) * (t->size + 1)); // 将新增行置 0
+        memset(graph->adjMat[graph->size], 0, sizeof(int) * (graph->size + 1)); // 将新增行置 0
-        t->size++;
+        graph->size++;
         return;
     }
-
     // 扩容，申请新的顶点数组
-    int *temp = (int *)malloc(sizeof(int) * (t->size * 2));
+    int *temp = (int *)malloc(sizeof(int) * (graph->size * 2));
-    memcpy(temp, t->vertices, sizeof(int) * t->size);
+    memcpy(temp, graph->vertices, sizeof(int) * graph->size);
-    temp[t->size] = val;
+    temp[graph->size] = val;
-
     // 释放原数组
-    free(t->vertices);
+    free(graph->vertices);
-    t->vertices = temp;
+    graph->vertices = temp;
-
     // 扩容，申请新的二维数组
-    unsigned int **tempMat = (unsigned int **)malloc(sizeof(unsigned int *) * t->size * 2);
+    int **tempMat = (int **)malloc(sizeof(int *) * graph->size * 2);
-    unsigned int *tempMatLine = (unsigned int *)malloc(sizeof(unsigned int) * (t->size * 2) * (t->size * 2));
+    int *tempMatLine = (int *)malloc(sizeof(int) * (graph->size * 2) * (graph->size * 2));
-    memset(tempMatLine, 0, sizeof(unsigned int) * (t->size * 2) * (t->size * 2));
+    memset(tempMatLine, 0, sizeof(int) * (graph->size * 2) * (graph->size * 2));
-    for (int k = 0; k < t->size * 2; k++) {
+    for (int k = 0; k < graph->size * 2; k++) {
-        tempMat[k] = tempMatLine + k * (t->size * 2);
+        tempMat[k] = tempMatLine + k * (graph->size * 2);
     }
-
+    for (int i = 0; i < graph->size; i++) {
-    for (int i = 0; i < t->size; i++) {
+        memcpy(tempMat[i], graph->adjMat[i], sizeof(int) * graph->size); // 原数据复制到新数组
-        memcpy(tempMat[i], t->adjMat[i], sizeof(unsigned int) * t->size); // 原数据复制到新数组
     }
-
+    for (int i = 0; i < graph->size; i++) {
-    for (int i = 0; i < t->size; i++) {
+        tempMat[i][graph->size] = 0; // 将新增列置 0
-        tempMat[i][t->size] = 0; // 将新增列置 0
     }
-    memset(tempMat[t->size], 0, sizeof(unsigned int) * (t->size + 1)); // 将新增行置 0
+    memset(tempMat[graph->size], 0, sizeof(int) * (graph->size + 1)); // 将新增行置 0
-
     // 释放原数组
-    free(t->adjMat[0]);
+    free(graph->adjMat[0]);
-    free(t->adjMat);
+    free(graph->adjMat);
-
     // 扩容后，指向新地址
-    t->adjMat = tempMat; // 指向新的邻接矩阵地址
+    graph->adjMat = tempMat; // 指向新的邻接矩阵地址
-    t->capacity = t->size * 2;
+    graph->capacity = graph->size * 2;
-    t->size++;
+    graph->size++;
 }
 
 /* 删除顶点 */
-void removeVertex(graphAdjMat *t, unsigned int index) {
+void removeVertex(GraphAdjMat *graph, int index) {
     // 越界检查
-    if (index < 0 || index >= t->size) {
+    if (index < 0 || index >= graph->size) {
         printf("Out of range in %s:%d\n", __FILE__, __LINE__);
         exit(1);
     }
-    for (int i = index; i < t->size - 1; i++) {
+    for (int i = index; i < graph->size - 1; i++) {
-        t->vertices[i] = t->vertices[i + 1]; // 清除删除的顶点，并将其后所有顶点前移
+        graph->vertices[i] = graph->vertices[i + 1]; // 清除删除的顶点，并将其后所有顶点前移
     }
-    t->vertices[t->size - 1] = 0; // 将被前移的最后一个顶点置 0
+    graph->vertices[graph->size - 1] = 0; // 将被前移的最后一个顶点置 0
-
     // 清除邻接矩阵中删除的列
-    for (int i = 0; i < t->size - 1; i++) {
+    for (int i = 0; i < graph->size - 1; i++) {
         if (i < index) {
-            for (int j = index; j < t->size - 1; j++) {
+            for (int j = index; j < graph->size - 1; j++) {
-                t->adjMat[i][j] = t->adjMat[i][j + 1]; // 被删除列后的所有列前移
+                graph->adjMat[i][j] = graph->adjMat[i][j + 1]; // 被删除列后的所有列前移
             }
         } else {
-            memcpy(t->adjMat[i], t->adjMat[i + 1], sizeof(unsigned int) * t->size); // 被删除行的下方所有行上移
+            memcpy(graph->adjMat[i], graph->adjMat[i + 1], sizeof(int) * graph->size); // 被删除行的下方所有行上移
-            for (int j = index; j < t->size; j++) {
+            for (int j = index; j < graph->size; j++) {
-                t->adjMat[i][j] = t->adjMat[i][j + 1]; // 被删除列后的所有列前移
+                graph->adjMat[i][j] = graph->adjMat[i][j + 1]; // 被删除列后的所有列前移
             }
         }
     }
-    t->size--;
+    graph->size--;
 }
 
 /* 打印顶点与邻接矩阵 */
-void printGraph(graphAdjMat *t) {
+void printGraph(GraphAdjMat *graph) {
-    if (t->size == 0) {
+    if (graph->size == 0) {
         printf("graph is empty\n");
         return;
     }
     printf("顶点列表 = [");
-    for (int i = 0; i < t->size; i++) {
+    for (int i = 0; i < graph->size; i++) {
-        if (i != t->size - 1) {
+        if (i != graph->size - 1) {
-            printf("%d, ", t->vertices[i]);
+            printf("%d, ", graph->vertices[i]);
         } else {
-            printf("%d", t->vertices[i]);
+            printf("%d", graph->vertices[i]);
         }
     }
     printf("]\n");
     printf("邻接矩阵 =\n[\n");
-    for (int i = 0; i < t->size; i++) {
+    for (int i = 0; i < graph->size; i++) {
         printf("  [");
-        for (int j = 0; j < t->size; j++) {
+        for (int j = 0; j < graph->size; j++) {
-            if (j != t->size - 1) {
+            if (j != graph->size - 1) {
-                printf("%u, ", t->adjMat[i][j]);
+                printf("%u, ", graph->adjMat[i][j]);
             } else {
-                printf("%u", t->adjMat[i][j]);
+                printf("%u", graph->adjMat[i][j]);
             }
         }
         printf("],\n");
@@ -152,26 +142,24 @@ void printGraph(graphAdjMat *t) {
 }
 
 /* 构造函数 */
-graphAdjMat *newGraphAjdMat(unsigned int numberVertices, int *vertices, unsigned int **adjMat) {
+GraphAdjMat *newGraphAjdMat(int numberVertices, int *vertices, int **adjMat) {
     // 申请内存
-    graphAdjMat *newGraph = (graphAdjMat *)malloc(sizeof(graphAdjMat));   // 为图分配内存
+    GraphAdjMat *newGraph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));    // 为图分配内存
-    newGraph->vertices = (int *)malloc(sizeof(int) * numberVertices * 2); // 为顶点列表分配内存
+    newGraph->vertices = (int *)malloc(sizeof(int) * numberVertices * 2);  // 为顶点列表分配内存
-    newGraph->adjMat = (unsigned int **)malloc(sizeof(unsigned int *) * numberVertices * 2); // 为邻接矩阵分配二维内存
+    newGraph->adjMat = (int **)malloc(sizeof(int *) * numberVertices * 2); // 为邻接矩阵分配二维内存
-    unsigned int *temp = (unsigned int *)malloc(sizeof(unsigned int) * numberVertices * 2 * numberVertices * 2); // 为邻接矩阵分配一维内存
+    int *temp = (int *)malloc(sizeof(int) * numberVertices * 2 * numberVertices * 2); // 为邻接矩阵分配一维内存
-    newGraph->size = numberVertices;                // 初始化顶点数量
+    newGraph->size = numberVertices;                                                  // 初始化顶点数量
-    newGraph->capacity = numberVertices * 2;        // 初始化图容量
+    newGraph->capacity = numberVertices * 2;                                          // 初始化图容量
-
     // 配置二维数组
     for (int i = 0; i < numberVertices * 2; i++) {
         newGraph->adjMat[i] = temp + i * numberVertices * 2; // 将二维指针指向一维数组
     }
-
     // 赋值
     memcpy(newGraph->vertices, vertices, sizeof(int) * numberVertices);
     for (int i = 0; i < numberVertices; i++) {
-        memcpy(newGraph->adjMat[i], adjMat[i], sizeof(unsigned int) * numberVertices); // 将传入的邻接矩阵赋值给结构体内邻接矩阵
+        memcpy(newGraph->adjMat[i], adjMat[i],
+               sizeof(int) * numberVertices); // 将传入的邻接矩阵赋值给结构体内邻接矩阵
     }
-
     // 返回结构体指针
     return newGraph;
 }
@@ -180,10 +168,10 @@ graphAdjMat *newGraphAjdMat(unsigned int numberVertices, int *vertices, unsigned
 int main() {
     /* 初始化无向图 */
     int vertices[5] = {1, 3, 2, 5, 4};
-    unsigned int **edge = (unsigned int **)malloc(sizeof(unsigned int *) * 5);
+    int **edge = (int **)malloc(sizeof(int *) * 5);
     // 用于构建二维数组的一维指针
-    unsigned int *temp = (unsigned int *)malloc(sizeof(unsigned int) * 25);
+    int *temp = (int *)malloc(sizeof(int) * 25);
-    memset(temp, 0, sizeof(unsigned int) * 25);
+    memset(temp, 0, sizeof(int) * 25);
     for (int k = 0; k < 5; k++) {
         edge[k] = temp + k * 5;
     }
@@ -195,7 +183,7 @@ int main() {
     edge[2][4] = edge[4][2] = 1;
     edge[3][4] = edge[4][3] = 1;
     // 建立无向图
-    graphAdjMat *graph = newGraphAjdMat(5, vertices, edge);
+    GraphAdjMat *graph = newGraphAjdMat(5, vertices, edge);
     free(edge);
     free(temp);
     printf("\n初始化后，图为:\n");

codes/c/chapter_graph/graph_bfs.c

@@ -7,16 +7,14 @@
 #include "graph_adjacency_list.c"
 
 /* 哈希表 */
-struct hashTable {
+typedef struct {
     unsigned int size;
     unsigned int *array;
-};
+} HashTable;
-
-typedef struct hashTable hashTable;
 
 /* 初始化哈希表 */
-hashTable *newHash(unsigned int size) {
+HashTable *newHash(unsigned int size) {
-    hashTable *h = (hashTable *)malloc(sizeof(hashTable));
+    HashTable *h = (HashTable *)malloc(sizeof(HashTable));
     h->array = (unsigned int *)malloc(sizeof(unsigned int) * size);
     memset(h->array, 0, sizeof(unsigned int) * size);
     h->size = size;
@@ -24,12 +22,12 @@ hashTable *newHash(unsigned int size) {
 }
 
 /* 标记索引过的顶点 */
-void hashMark(hashTable *h, int index) {
+void hashMark(HashTable *h, int index) {
     h->array[index % h->size] = 1;
 }
 
 /* 查询顶点是否已被标记 */
-int hashQuery(hashTable *h, int index) {
+int hashQuery(HashTable *h, int index) {
     // 若顶点已被标记，则返回 1
     if (h->array[index % h->size] == 1) {
         return 1;
@@ -39,24 +37,22 @@ int hashQuery(hashTable *h, int index) {
 }
 
 /* 释放哈希表内存 */
-void freeHash(hashTable *h) {
+void freeHash(HashTable *h) {
     free(h->array);
     free(h);
 }
 
 /* 队列 */
-struct queue {
+typedef struct {
     Vertex **list;
     unsigned int size;
     int head;
     int tail;
-};
+} Queue;
-
-typedef struct queue queue;
 
 /* 初始化队列 */
-queue *newQueue(unsigned int size) {
+Queue *newQueue(unsigned int size) {
-    queue *q = (queue *)malloc(sizeof(queue));
+    Queue *q = (Queue *)malloc(sizeof(Queue));
     q->size = size;
     q->list = (Vertex **)malloc(sizeof(Vertex *) * size);
     q->head = 0;
@@ -66,44 +62,44 @@ queue *newQueue(unsigned int size) {
 }
 
 /* 入队 */
-void queuePush(queue *q, Vertex *vet) {
+void queuePush(Queue *q, Vertex *vet) {
     q->list[q->tail] = vet;
     q->tail++;
 }
 
 /* 出队 */
-void queuePop(queue *q) {
+void queuePop(Queue *q) {
     q->head++;
 }
 
 /* 队首元素 */
-Vertex *queueTop(queue *q) {
+Vertex *queueTop(Queue *q) {
     return q->list[q->head];
 }
 
 /* 释放队列内存 */
-void freeQueue(queue *q) {
+void freeQueue(Queue *q) {
     free(q->list);
     free(q);
 }
 
 /* 广度优先遍历 */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
-Vertex **graphBFS(graphAdjList *t, Vertex *startVet) {
+Vertex **graphBFS(GraphAdjList *t, Vertex *startVet) {
     // 顶点遍历序列
     Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * t->size);
     memset(res, 0, sizeof(Vertex *) * t->size);
     // 队列用于实现 BFS
-    queue *que = newQueue(t->size);
+    Queue *que = newQueue(t->size);
     // 哈希表，用于记录已被访问过的顶点
-    hashTable *visited = newHash(t->size);
+    HashTable *visited = newHash(t->size);
     int resIndex = 0;
     queuePush(que, startVet);         // 将第一个元素入队
     hashMark(visited, startVet->pos); // 标记第一个入队的顶点
     // 以顶点 vet 为起点，循环直至访问完所有顶点
     while (que->head < que->tail) {
         // 遍历该顶点的边链表，将所有与该顶点有连接的，并且未被标记的顶点入队
-        Node *n = queueTop(que)->linked->head->next;
+        Node *n = queueTop(que)->list->head->next;
         while (n != 0) {
             // 查询哈希表，若该索引的顶点已入队，则跳过，否则入队并标记
             if (hashQuery(visited, n->val->pos) == 1) {
@@ -129,7 +125,7 @@ Vertex **graphBFS(graphAdjList *t, Vertex *startVet) {
 /* Driver Code */
 int main() {
     /* 初始化无向图 */
-    graphAdjList *graph = newGraphAdjList(3);
+    GraphAdjList *graph = newGraphAdjList(3);
     // 初始化顶点
     for (int i = 0; i < 10; i++) {
         addVertex(graph, i);
@@ -150,7 +146,7 @@ int main() {
     printf("\n初始化后，图为:\n");
     printGraph(graph);
     printf("\n广度优先遍历（BFS）顶点序列为\n");
-    Vertex **vets = graphBFS(graph, graph->verticesList[0]);
+    Vertex **vets = graphBFS(graph, graph->vertices[0]);
 
     // 打印广度优先遍历数组
     printf("[");

codes/c/chapter_graph/graph_dfs.c

@@ -7,16 +7,14 @@
 #include "graph_adjacency_list.c"
 
 /* 哈希表 */
-struct hashTable {
+typedef struct {
     unsigned int size;
     unsigned int *array;
-};
+} HashTable;
-
-typedef struct hashTable hashTable;
 
 /* 初始化哈希表 */
-hashTable *newHash(unsigned int size) {
+HashTable *newHash(unsigned int size) {
-    hashTable *h = (hashTable *)malloc(sizeof(hashTable));
+    HashTable *h = (HashTable *)malloc(sizeof(HashTable));
     h->array = (unsigned int *)malloc(sizeof(unsigned int) * size);
     memset(h->array, 0, sizeof(unsigned int) * size);
     h->size = size;
@@ -24,12 +22,12 @@ hashTable *newHash(unsigned int size) {
 }
 
 /* 标记索引过的顶点 */
-void hashMark(hashTable *h, int index) {
+void hashMark(HashTable *h, int index) {
     h->array[index % h->size] = 1;
 }
 
 /* 查询顶点是否已被标记 */
-int hashQuery(hashTable *h, int index) {
+int hashQuery(HashTable *h, int index) {
     // 若顶点已被标记，则返回 1
     if (h->array[index % h->size] == 1) {
         return 1;
@@ -39,14 +37,14 @@ int hashQuery(hashTable *h, int index) {
 }
 
 /* 释放哈希表内存 */
-void freeHash(hashTable *h) {
+void freeHash(HashTable *h) {
     free(h->array);
     free(h);
 }
 
 /* 深度优先遍历 DFS 辅助函数 */
 int resIndex = 0;
-void dfs(graphAdjList *graph, hashTable *visited, Vertex *vet, Vertex **res) {
+void dfs(GraphAdjList *graph, HashTable *visited, Vertex *vet, Vertex **res) {
     if (hashQuery(visited, vet->pos) == 1) {
         return; // 跳过已被访问过的顶点
     }
@@ -54,7 +52,7 @@ void dfs(graphAdjList *graph, hashTable *visited, Vertex *vet, Vertex **res) {
     res[resIndex] = vet;         // 将顶点存入数组
     resIndex++;
     // 遍历该顶点链表
-    Node *n = vet->linked->head->next;
+    Node *n = vet->list->head->next;
     while (n != 0) {
         // 递归访问邻接顶点
         dfs(graph, visited, n->val, res);
@@ -65,12 +63,12 @@ void dfs(graphAdjList *graph, hashTable *visited, Vertex *vet, Vertex **res) {
 
 /* 深度优先遍历 DFS */
 // 使用邻接表来表示图，以便获取指定顶点的所有邻接顶点
-Vertex **graphDFS(graphAdjList *graph, Vertex *startVet) {
+Vertex **graphDFS(GraphAdjList *graph, Vertex *startVet) {
     // 顶点遍历序列
     Vertex **res = (Vertex **)malloc(sizeof(Vertex *) * graph->size);
     memset(res, 0, sizeof(Vertex *) * graph->size);
     // 哈希表，用于记录已被访问过的顶点
-    hashTable *visited = newHash(graph->size);
+    HashTable *visited = newHash(graph->size);
     dfs(graph, visited, startVet, res);
     // 释放哈希表内存并将数组索引归零
     freeHash(visited);
@@ -81,7 +79,7 @@ Vertex **graphDFS(graphAdjList *graph, Vertex *startVet) {
 
 /* Driver Code */
 int main() {
-    graphAdjList *graph = newGraphAdjList(10);
+    GraphAdjList *graph = newGraphAdjList(10);
     for (int i = 0; i < 7; i++) {
         addVertex(graph, i);
     }
@@ -95,7 +93,7 @@ int main() {
     printGraph(graph);
 
     // 深度优先遍历 DFS
-    Vertex **vet = graphDFS(graph, graph->verticesList[0]);
+    Vertex **vet = graphDFS(graph, graph->vertices[0]);
 
     // 输出遍历结果
     printf("\n深度优先遍历（DFS）顶点序列为\n");

codes/c/chapter_greedy/coin_change_greedy.c

@@ -7,7 +7,7 @@
 #include "../utils/common.h"
 
 /* 零钱兑换：贪心 */
-int coinChangeGreedy(int* coins, int size, int amt) {
+int coinChangeGreedy(int *coins, int size, int amt) {
     // 假设 coins 列表有序
     int i = size - 1;
     int count = 0;

codes/c/chapter_greedy/fractional_knapsack.c

@@ -7,12 +7,10 @@
 #include "../utils/common.h"
 
 /* 物品 */
-struct Item {
+typedef struct {
     int w; // 物品重量
     int v; // 物品价值
-};
+} Item;
-
-typedef struct Item Item;
 
 /* 按照价值密度排序 */
 int sortByValueDensity(const void *a, const void *b) {

codes/c/chapter_hashing/array_hash_map.c

@@ -6,35 +6,29 @@
 
 #include "../utils/common.h"
 
-/* 哈希表默认数组大小 */
+/* 哈希表默认大小 */
 #define HASH_MAP_DEFAULT_SIZE 100
 
 /* 键值对 int->string */
-struct pair {
+typedef struct {
     int key;
     char *val;
-};
+} Pair;
 
-typedef struct pair pair;
+/* 键值对的集合 */
-
+typedef struct {
-/* 用于表示键值对、键、值的集合 */
-struct mapSet {
     void *set;
     int len;
-};
+} MapSet;
-
-typedef struct mapSet mapSet;
 
 /* 基于数组简易实现的哈希表 */
-struct arrayHashMap {
+typedef struct {
-    pair *buckets[HASH_MAP_DEFAULT_SIZE];
+    Pair *buckets[HASH_MAP_DEFAULT_SIZE];
-};
+} ArrayHashMap;
-
-typedef struct arrayHashMap arrayHashMap;
 
 /* 哈希表初始化函数 */
-arrayHashMap *newArrayHashMap() {
+ArrayHashMap *newArrayHashMap() {
-    arrayHashMap *map = malloc(sizeof(arrayHashMap));
+    ArrayHashMap *map = malloc(sizeof(ArrayHashMap));
     return map;
 }
 
@@ -45,27 +39,27 @@ int hashFunc(int key) {
 }
 
 /* 查询操作 */
-const char *get(const arrayHashMap *d, const int key) {
+const char *get(const ArrayHashMap *d, const int key) {
     int index = hashFunc(key);
-    const pair *pair = d->buckets[index];
+    const Pair *Pair = d->buckets[index];
-    if (pair == NULL)
+    if (Pair == NULL)
         return NULL;
-    return pair->val;
+    return Pair->val;
 }
 
 /* 添加操作 */
-void put(arrayHashMap *d, const int key, const char *val) {
+void put(ArrayHashMap *d, const int key, const char *val) {
-    pair *pair = malloc(sizeof(pair));
+    Pair *Pair = malloc(sizeof(Pair));
-    pair->key = key;
+    Pair->key = key;
-    pair->val = malloc(strlen(val) + 1);
+    Pair->val = malloc(strlen(val) + 1);
-    strcpy(pair->val, val);
+    strcpy(Pair->val, val);
 
     int index = hashFunc(key);
-    d->buckets[index] = pair;
+    d->buckets[index] = Pair;
 }
 
 /* 删除操作 */
-void removeItem(arrayHashMap *d, const int key) {
+void removeItem(ArrayHashMap *d, const int key) {
     int index = hashFunc(key);
     free(d->buckets[index]->val);
     free(d->buckets[index]);
@@ -73,8 +67,8 @@ void removeItem(arrayHashMap *d, const int key) {
 }
 
 /* 获取所有键值对 */
-void pairSet(arrayHashMap *d, mapSet *set) {
+void pairSet(ArrayHashMap *d, MapSet *set) {
-    pair *entries;
+    Pair *entries;
     int i = 0, index = 0;
     int total = 0;
 
@@ -85,7 +79,7 @@ void pairSet(arrayHashMap *d, mapSet *set) {
         }
     }
 
-    entries = malloc(sizeof(pair) * total);
+    entries = malloc(sizeof(Pair) * total);
     for (i = 0; i < HASH_MAP_DEFAULT_SIZE; i++) {
         if (d->buckets[i] != NULL) {
             entries[index].key = d->buckets[i]->key;
@@ -100,7 +94,7 @@ void pairSet(arrayHashMap *d, mapSet *set) {
 }
 
 /* 获取所有键 */
-void keySet(arrayHashMap *d, mapSet *set) {
+void keySet(ArrayHashMap *d, MapSet *set) {
     int *keys;
     int i = 0, index = 0;
     int total = 0;
@@ -125,7 +119,7 @@ void keySet(arrayHashMap *d, mapSet *set) {
 }
 
 /* 获取所有值 */
-void valueSet(arrayHashMap *d, mapSet *set) {
+void valueSet(ArrayHashMap *d, MapSet *set) {
     char **vals;
     int i = 0, index = 0;
     int total = 0;
@@ -150,11 +144,11 @@ void valueSet(arrayHashMap *d, mapSet *set) {
 }
 
 /* 打印哈希表 */
-void print(arrayHashMap *d) {
+void print(ArrayHashMap *d) {
     int i;
-    mapSet set;
+    MapSet set;
     pairSet(d, &set);
-    pair *entries = (pair *)set.set;
+    Pair *entries = (Pair *)set.set;
     for (i = 0; i < set.len; i++) {
         printf("%d -> %s\n", entries[i].key, entries[i].val);
     }
@@ -164,7 +158,7 @@ void print(arrayHashMap *d) {
 /* Driver Code */
 int main() {
     /* 初始化哈希表 */
-    arrayHashMap *map = newArrayHashMap();
+    ArrayHashMap *map = newArrayHashMap();
 
     /* 添加操作 */
     // 在哈希表中添加键值对 (key, value)
@@ -193,7 +187,7 @@ int main() {
     printf("\n遍历键值对 Key->Value\n");
     print(map);
 
-    mapSet set;
+    MapSet set;
 
     keySet(map, &set);
     int *keys = (int *)set.set;

codes/c/chapter_hashing/hash_map_chaining.c

@@ -8,36 +8,33 @@
 #include <stdlib.h>
 #include <string.h>
 
-/* 键值对 */
+// 假设 val 最大长度为 100
-struct pair {
+#define MAX_SIZE 100
-    int key;
-    char val[100]; // 假设 val 最大长度为 100
-};
 
-typedef struct pair Pair;
+/* 键值对 */
+typedef struct {
+    int key;
+    char val[MAX_SIZE];
+} Pair;
 
 /* 链表节点 */
-struct node {
+typedef struct Node {
     Pair *pair;
-    struct node *next;
+    struct Node *next;
-};
+} Node;
-
-typedef struct node Node;
 
 /* 链式地址哈希表 */
-struct hashMapChaining {
+typedef struct {
     int size;         // 键值对数量
     int capacity;     // 哈希表容量
     double loadThres; // 触发扩容的负载因子阈值
     int extendRatio;  // 扩容倍数
     Node **buckets;   // 桶数组
-};
+} HashMapChaining;
-
-typedef struct hashMapChaining hashMapChaining;
 
 /* 构造方法 */
-hashMapChaining *initHashMapChaining() {
+HashMapChaining *initHashMapChaining() {
-    hashMapChaining *hashMap = (hashMapChaining *)malloc(sizeof(hashMapChaining));
+    HashMapChaining *hashMap = (HashMapChaining *)malloc(sizeof(HashMapChaining));
     hashMap->size = 0;
     hashMap->capacity = 4;
     hashMap->loadThres = 2.0 / 3.0;
@@ -50,7 +47,7 @@ hashMapChaining *initHashMapChaining() {
 }
 
 /* 析构方法 */
-void freeHashMapChaining(hashMapChaining *hashMap) {
+void freeHashMapChaining(HashMapChaining *hashMap) {
     for (int i = 0; i < hashMap->capacity; i++) {
         Node *cur = hashMap->buckets[i];
         while (cur) {
@@ -65,17 +62,17 @@ void freeHashMapChaining(hashMapChaining *hashMap) {
 }
 
 /* 哈希函数 */
-int hashFunc(hashMapChaining *hashMap, int key) {
+int hashFunc(HashMapChaining *hashMap, int key) {
     return key % hashMap->capacity;
 }
 
 /* 负载因子 */
-double loadFactor(hashMapChaining *hashMap) {
+double loadFactor(HashMapChaining *hashMap) {
     return (double)hashMap->size / (double)hashMap->capacity;
 }
 
 /* 查询操作 */
-char *get(hashMapChaining *hashMap, int key) {
+char *get(HashMapChaining *hashMap, int key) {
     int index = hashFunc(hashMap, key);
     // 遍历桶，若找到 key 则返回对应 val
     Node *cur = hashMap->buckets[index];
@@ -89,10 +86,10 @@ char *get(hashMapChaining *hashMap, int key) {
 }
 
 /* 添加操作 */
-void put(hashMapChaining *hashMap, int key, const char *val);
+void put(HashMapChaining *hashMap, int key, const char *val);
 
 /* 扩容哈希表 */
-void extend(hashMapChaining *hashMap) {
+void extend(HashMapChaining *hashMap) {
     // 暂存原哈希表
     int oldCapacity = hashMap->capacity;
     Node **oldBuckets = hashMap->buckets;
@@ -120,7 +117,7 @@ void extend(hashMapChaining *hashMap) {
 }
 
 /* 添加操作 */
-void put(hashMapChaining *hashMap, int key, const char *val) {
+void put(HashMapChaining *hashMap, int key, const char *val) {
     // 当负载因子超过阈值时，执行扩容
     if (loadFactor(hashMap) > hashMap->loadThres) {
         extend(hashMap);
@@ -147,7 +144,7 @@ void put(hashMapChaining *hashMap, int key, const char *val) {
 }
 
 /* 删除操作 */
-void removeKey(hashMapChaining *hashMap, int key) {
+void removeKey(HashMapChaining *hashMap, int key) {
     int index = hashFunc(hashMap, key);
     Node *cur = hashMap->buckets[index];
     Node *pre = NULL;
@@ -171,7 +168,7 @@ void removeKey(hashMapChaining *hashMap, int key) {
 }
 
 /* 打印哈希表 */
-void print(hashMapChaining *hashMap) {
+void print(HashMapChaining *hashMap) {
     for (int i = 0; i < hashMap->capacity; i++) {
         Node *cur = hashMap->buckets[i];
         printf("[");
@@ -186,7 +183,7 @@ void print(hashMapChaining *hashMap) {
 /* Driver Code */
 int main() {
     /* 初始化哈希表 */
-    hashMapChaining *hashMap = initHashMapChaining();
+    HashMapChaining *hashMap = initHashMapChaining();
 
     /* 添加操作 */
     // 在哈希表中添加键值对 (key, value)

codes/c/chapter_hashing/hash_map_open_addressing.c

@@ -7,31 +7,27 @@
 #include "../utils/common.h"
 
 /* 开放寻址哈希表 */
-struct pair {
+typedef struct {
     int key;
     char *val;
-};
+} Pair;
-
-typedef struct pair Pair;
 
 /* 开放寻址哈希表 */
-struct hashMapOpenAddressing {
+typedef struct {
     int size;         // 键值对数量
     int capacity;     // 哈希表容量
     double loadThres; // 触发扩容的负载因子阈值
     int extendRatio;  // 扩容倍数
     Pair **buckets;   // 桶数组
     Pair *TOMBSTONE;  // 删除标记
-};
+} HashMapOpenAddressing;
-
-typedef struct hashMapOpenAddressing hashMapOpenAddressing;
 
 // 函数声明
-void extend(hashMapOpenAddressing *hashMap);
+void extend(HashMapOpenAddressing *hashMap);
 
 /* 构造方法 */
-hashMapOpenAddressing *newHashMapOpenAddressing() {
+HashMapOpenAddressing *newHashMapOpenAddressing() {
-    hashMapOpenAddressing *hashMap = (hashMapOpenAddressing *)malloc(sizeof(hashMapOpenAddressing));
+    HashMapOpenAddressing *hashMap = (HashMapOpenAddressing *)malloc(sizeof(HashMapOpenAddressing));
     hashMap->size = 0;
     hashMap->capacity = 4;
     hashMap->loadThres = 2.0 / 3.0;
@@ -45,7 +41,7 @@ hashMapOpenAddressing *newHashMapOpenAddressing() {
 }
 
 /* 析构方法 */
-void delHashMapOpenAddressing(hashMapOpenAddressing *hashMap) {
+void delHashMapOpenAddressing(HashMapOpenAddressing *hashMap) {
     for (int i = 0; i < hashMap->capacity; i++) {
         Pair *pair = hashMap->buckets[i];
         if (pair != NULL && pair != hashMap->TOMBSTONE) {
@@ -56,17 +52,17 @@ void delHashMapOpenAddressing(hashMapOpenAddressing *hashMap) {
 }
 
 /* 哈希函数 */
-int hashFunc(hashMapOpenAddressing *hashMap, int key) {
+int hashFunc(HashMapOpenAddressing *hashMap, int key) {
     return key % hashMap->capacity;
 }
 
 /* 负载因子 */
-double loadFactor(hashMapOpenAddressing *hashMap) {
+double loadFactor(HashMapOpenAddressing *hashMap) {
     return (double)hashMap->size / (double)hashMap->capacity;
 }
 
 /* 搜索 key 对应的桶索引 */
-int findBucket(hashMapOpenAddressing *hashMap, int key) {
+int findBucket(HashMapOpenAddressing *hashMap, int key) {
     int index = hashFunc(hashMap, key);
     int firstTombstone = -1;
     // 线性探测，当遇到空桶时跳出
@@ -93,7 +89,7 @@ int findBucket(hashMapOpenAddressing *hashMap, int key) {
 }
 
 /* 查询操作 */
-char *get(hashMapOpenAddressing *hashMap, int key) {
+char *get(HashMapOpenAddressing *hashMap, int key) {
     // 搜索 key 对应的桶索引
     int index = findBucket(hashMap, key);
     // 若找到键值对，则返回对应 val
@@ -105,7 +101,7 @@ char *get(hashMapOpenAddressing *hashMap, int key) {
 }
 
 /* 添加操作 */
-void put(hashMapOpenAddressing *hashMap, int key, char *val) {
+void put(HashMapOpenAddressing *hashMap, int key, char *val) {
     // 当负载因子超过阈值时，执行扩容
     if (loadFactor(hashMap) > hashMap->loadThres) {
         extend(hashMap);
@@ -132,7 +128,7 @@ void put(hashMapOpenAddressing *hashMap, int key, char *val) {
 }
 
 /* 删除操作 */
-void removeItem(hashMapOpenAddressing *hashMap, int key) {
+void removeItem(HashMapOpenAddressing *hashMap, int key) {
     // 搜索 key 对应的桶索引
     int index = findBucket(hashMap, key);
     // 若找到键值对，则用删除标记覆盖它
@@ -146,7 +142,7 @@ void removeItem(hashMapOpenAddressing *hashMap, int key) {
 }
 
 /* 扩容哈希表 */
-void extend(hashMapOpenAddressing *hashMap) {
+void extend(HashMapOpenAddressing *hashMap) {
     // 暂存原哈希表
     Pair **bucketsTmp = hashMap->buckets;
     int oldCapacity = hashMap->capacity;
@@ -167,7 +163,7 @@ void extend(hashMapOpenAddressing *hashMap) {
 }
 
 /* 打印哈希表 */
-void print(hashMapOpenAddressing *hashMap) {
+void print(HashMapOpenAddressing *hashMap) {
     for (int i = 0; i < hashMap->capacity; i++) {
         Pair *pair = hashMap->buckets[i];
         if (pair == NULL) {
@@ -183,7 +179,7 @@ void print(hashMapOpenAddressing *hashMap) {
 /* Driver Code */
 int main() {
     // 初始化哈希表
-    hashMapOpenAddressing *hashmap = newHashMapOpenAddressing();
+    HashMapOpenAddressing *hashmap = newHashMapOpenAddressing();
 
     // 添加操作
     // 在哈希表中添加键值对 (key, val)

codes/c/chapter_heap/my_heap.c

@@ -9,25 +9,22 @@
 #define MAX_SIZE 5000
 
 /* 大顶堆 */
-struct maxHeap {
+typedef struct {
     // size 代表的是实际元素的个数
     int size;
     // 使用预先分配内存的数组，避免扩容
     int data[MAX_SIZE];
-};
+} MaxHeap;
 
-typedef struct maxHeap maxHeap;
+// 函数声明
-
+void siftDown(MaxHeap *h, int i);
-void siftDown(maxHeap *h, int i);
+void siftUp(MaxHeap *h, int i);
-
+int parent(MaxHeap *h, int i);
-void siftUp(maxHeap *h, int i);
-
-int parent(maxHeap *h, int i);
 
 /* 构造函数，根据切片建堆 */
-maxHeap *newMaxHeap(int nums[], int size) {
+MaxHeap *newMaxHeap(int nums[], int size) {
     // 所有元素入堆
-    maxHeap *h = (maxHeap *)malloc(sizeof(maxHeap));
+    MaxHeap *h = (MaxHeap *)malloc(sizeof(MaxHeap));
     h->size = size;
     memcpy(h->data, nums, size * sizeof(int));
     for (int i = parent(h, size - 1); i >= 0; i--) {
@@ -38,44 +35,44 @@ maxHeap *newMaxHeap(int nums[], int size) {
 }
 
 /* 获取左子节点索引 */
-int left(maxHeap *h, int i) {
+int left(MaxHeap *h, int i) {
     return 2 * i + 1;
 }
 
 /* 获取右子节点索引 */
-int right(maxHeap *h, int i) {
+int right(MaxHeap *h, int i) {
     return 2 * i + 2;
 }
 
 /* 获取父节点索引 */
-int parent(maxHeap *h, int i) {
+int parent(MaxHeap *h, int i) {
     return (i - 1) / 2;
 }
 
 /* 交换元素 */
-void swap(maxHeap *h, int i, int j) {
+void swap(MaxHeap *h, int i, int j) {
     int temp = h->data[i];
     h->data[i] = h->data[j];
     h->data[j] = temp;
 }
 
 /* 获取堆大小 */
-int size(maxHeap *h) {
+int size(MaxHeap *h) {
     return h->size;
 }
 
 /* 判断堆是否为空 */
-int isEmpty(maxHeap *h) {
+int isEmpty(MaxHeap *h) {
     return h->size == 0;
 }
 
 /* 访问堆顶元素 */
-int peek(maxHeap *h) {
+int peek(MaxHeap *h) {
     return h->data[0];
 }
 
 /* 元素入堆 */
-void push(maxHeap *h, int val) {
+void push(MaxHeap *h, int val) {
     // 默认情况下，不应该添加这么多节点
     if (h->size == MAX_SIZE) {
         printf("heap is full!");
@@ -90,7 +87,7 @@ void push(maxHeap *h, int val) {
 }
 
 /* 元素出堆 */
-int pop(maxHeap *h) {
+int pop(MaxHeap *h) {
     // 判空处理
     if (isEmpty(h)) {
         printf("heap is empty!");
@@ -109,7 +106,7 @@ int pop(maxHeap *h) {
 }
 
 /* 从节点 i 开始，从顶至底堆化 */
-void siftDown(maxHeap *h, int i) {
+void siftDown(MaxHeap *h, int i) {
     while (true) {
         // 判断节点 i, l, r 中值最大的节点，记为 max
         int l = left(h, i);
@@ -133,7 +130,7 @@ void siftDown(maxHeap *h, int i) {
 }
 
 /* 从节点 i 开始，从底至顶堆化 */
-void siftUp(maxHeap *h, int i) {
+void siftUp(MaxHeap *h, int i) {
     while (true) {
         // 获取节点 i 的父节点
         int p = parent(h, i);
@@ -153,7 +150,7 @@ int main() {
     /* 初始化堆 */
     // 初始化大顶堆
     int nums[] = {9, 8, 6, 6, 7, 5, 2, 1, 4, 3, 6, 2};
-    maxHeap *heap = newMaxHeap(nums, sizeof(nums) / sizeof(int));
+    MaxHeap *heap = newMaxHeap(nums, sizeof(nums) / sizeof(int));
     printf("输入数组并建堆后\n");
     printHeap(heap->data, heap->size);
 

codes/c/chapter_searching/two_sum.c

@@ -23,26 +23,24 @@ int *twoSumBruteForce(int *nums, int numsSize, int target, int *returnSize) {
 }
 
 /* 哈希表 */
-struct hashTable {
+typedef struct {
     int key;
     int val;
     UT_hash_handle hh; // 基于 uthash.h 实现
-};
+} HashTable;
-
-typedef struct hashTable hashTable;
 
 /* 哈希表查询 */
-hashTable *find(hashTable *h, int key) {
+HashTable *find(HashTable *h, int key) {
-    hashTable *tmp;
+    HashTable *tmp;
     HASH_FIND_INT(h, &key, tmp);
     return tmp;
 }
 
 /* 哈希表元素插入 */
-void insert(hashTable *h, int key, int val) {
+void insert(HashTable *h, int key, int val) {
-    hashTable *t = find(h, key);
+    HashTable *t = find(h, key);
     if (t == NULL) {
-        hashTable *tmp = malloc(sizeof(hashTable));
+        HashTable *tmp = malloc(sizeof(HashTable));
         tmp->key = key, tmp->val = val;
         HASH_ADD_INT(h, key, tmp);
     } else {
@@ -52,9 +50,9 @@ void insert(hashTable *h, int key, int val) {
 
 /* 方法二：辅助哈希表 */
 int *twoSumHashTable(int *nums, int numsSize, int target, int *returnSize) {
-    hashTable *hashtable = NULL;
+    HashTable *hashtable = NULL;
     for (int i = 0; i < numsSize; i++) {
-        hashTable *t = find(hashtable, target - nums[i]);
+        HashTable *t = find(hashtable, target - nums[i]);
         if (t != NULL) {
             int *res = malloc(sizeof(int) * 2);
             res[0] = t->val, res[1] = i;

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; // 队列容量
-};
+} ArrayDeque;
-
-typedef struct arrayDeque arrayDeque;
 
 /* 构造函数 */
-arrayDeque *newArrayDeque(int capacity) {
+ArrayDeque *newArrayDeque(int capacity) {
-    arrayDeque *deque = (arrayDeque *)malloc(sizeof(arrayDeque));
+    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; // 队列容量
-};
+} ArrayQueue;
-
-typedef struct arrayQueue arrayQueue;
 
 /* 构造函数 */
-arrayQueue *newArrayQueue(int capacity) {
+ArrayQueue *newArrayQueue(int capacity) {
-    arrayQueue *queue = (arrayQueue *)malloc(sizeof(arrayQueue));
+    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;
-};
+} ArrayStack;
-
-typedef struct arrayStack arrayStack;
 
 /* 构造函数 */
-arrayStack *newArrayStack() {
+ArrayStack *newArrayStack() {
-    arrayStack *s = malloc(sizeof(arrayStack));
+    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 *next; // 后继节点
-    struct doublyListNode *prev; // 前驱节点
+    struct DoublyListNode *prev; // 前驱节点
-};
+} DoublyListNode;
-
-typedef struct doublyListNode doublyListNode;
 
 /* 构造函数 */
-doublyListNode *newDoublyListNode(int num) {
+DoublyListNode *newDoublyListNode(int num) {
-    doublyListNode *new = (doublyListNode *)malloc(sizeof(doublyListNode));
+    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 {
+typedef struct {
-    doublyListNode *front, *rear; // 头节点 front ，尾节点 rear
+    DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
     int queSize;                  // 双向队列的长度
-};
+} LinkedListDeque;
-
-typedef struct linkedListDeque linkedListDeque;
 
 /* 构造函数 */
-linkedListDeque *newLinkedListDeque() {
+LinkedListDeque *newLinkedListDeque() {
-    linkedListDeque *deque = (linkedListDeque *)malloc(sizeof(linkedListDeque));
+    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) {
+void push(LinkedListDeque *deque, int num, bool isFront) {
-    doublyListNode *node = newDoublyListNode(num);
+    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;
-};
+} LinkedListQueue;
-
-typedef struct linkedListQueue linkedListQueue;
 
 /* 构造函数 */
-linkedListQueue *newLinkedListQueue() {
+LinkedListQueue *newLinkedListQueue() {
-    linkedListQueue *queue = (linkedListQueue *)malloc(sizeof(linkedListQueue));
+    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;      // 栈的长度
-};
+} LinkedListStack;
-
-typedef struct linkedListStack linkedListStack;
 
 /* 构造函数 */
-linkedListStack *newLinkedListStack() {
+LinkedListStack *newLinkedListStack() {
-    linkedListStack *s = malloc(sizeof(linkedListStack));
+    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);

codes/c/chapter_tree/array_binary_tree.c

@@ -7,26 +7,24 @@
 #include "../utils/common.h"
 
 /* 数组表示下的二叉树类 */
-struct arrayBinaryTree {
+typedef struct {
     vector *tree;
-};
+} ArrayBinaryTree;
-
-typedef struct arrayBinaryTree arrayBinaryTree;
 
 /* 构造函数 */
-arrayBinaryTree *newArrayBinaryTree(vector *arr) {
+ArrayBinaryTree *newArrayBinaryTree(vector *arr) {
-    arrayBinaryTree *newABT = malloc(sizeof(arrayBinaryTree));
+    ArrayBinaryTree *newABT = malloc(sizeof(ArrayBinaryTree));
     newABT->tree = arr;
     return newABT;
 }
 
 /* 节点数量 */
-int size(arrayBinaryTree *abt) {
+int size(ArrayBinaryTree *abt) {
     return abt->tree->size;
 }
 
 /* 获取索引为 i 节点的值 */
-int val(arrayBinaryTree *abt, int i) {
+int val(ArrayBinaryTree *abt, int i) {
     // 若索引越界，则返回 INT_MAX ，代表空位
     if (i < 0 || i >= size(abt))
         return INT_MAX;
@@ -49,7 +47,7 @@ int parent(int i) {
 }
 
 /* 深度优先遍历 */
-void dfs(arrayBinaryTree *abt, int i, const char *order, vector *res) {
+void dfs(ArrayBinaryTree *abt, int i, const char *order, vector *res) {
     // 若为空位，则返回
     if (val(abt, i) == INT_MAX)
         return;
@@ -73,7 +71,7 @@ void dfs(arrayBinaryTree *abt, int i, const char *order, vector *res) {
 }
 
 /* 层序遍历 */
-vector *levelOrder(arrayBinaryTree *abt) {
+vector *levelOrder(ArrayBinaryTree *abt) {
     vector *res = newVector();
     // 直接遍历数组
     for (int i = 0; i < size(abt); i++) {
@@ -86,21 +84,21 @@ vector *levelOrder(arrayBinaryTree *abt) {
 }
 
 /* 前序遍历 */
-vector *preOrder(arrayBinaryTree *abt) {
+vector *preOrder(ArrayBinaryTree *abt) {
     vector *res = newVector();
     dfs(abt, 0, "pre", res);
     return res;
 }
 
 /* 中序遍历 */
-vector *inOrder(arrayBinaryTree *abt) {
+vector *inOrder(ArrayBinaryTree *abt) {
     vector *res = newVector();
     dfs(abt, 0, "in", res);
     return res;
 }
 
 /* 后序遍历 */
-vector *postOrder(arrayBinaryTree *abt) {
+vector *postOrder(ArrayBinaryTree *abt) {
     vector *res = newVector();
     dfs(abt, 0, "post", res);
     return res;
@@ -129,7 +127,7 @@ int main() {
         vectorPushback(vArr, &arr[i], sizeof(int));
     }
     // 数组表示下的二叉树类
-    arrayBinaryTree *abt = newArrayBinaryTree(vArr);
+    ArrayBinaryTree *abt = newArrayBinaryTree(vArr);
 
     // 访问节点
     int i = 1;

codes/c/chapter_tree/avl_tree.c

@@ -7,15 +7,13 @@
 #include "../utils/common.h"
 
 /* AVL Tree */
-struct aVLTree {
+typedef struct {
     TreeNode *root;
-};
+} AVLTree;
-
-typedef struct aVLTree aVLTree;
 
 /* 构建 AVL 树 */
-aVLTree *newAVLTree() {
+AVLTree *newAVLTree() {
-    aVLTree *tree = (aVLTree *)malloc(sizeof(aVLTree));
+    AVLTree *tree = (AVLTree *)malloc(sizeof(AVLTree));
     tree->root = NULL;
     return tree;
 }
@@ -134,7 +132,7 @@ TreeNode *insertHelper(TreeNode *node, int val) {
 }
 
 /* 插入节点 */
-void insert(aVLTree *tree, int val) {
+void insert(AVLTree *tree, int val) {
     tree->root = insertHelper(tree->root, val);
 }
 
@@ -183,12 +181,12 @@ TreeNode *removeHelper(TreeNode *node, int val) {
 
 /* 删除节点 */
 // 由于引入了 stdio.h ，此处无法使用 remove 关键词
-void removeItem(aVLTree *tree, int val) {
+void removeItem(AVLTree *tree, int val) {
     TreeNode *root = removeHelper(tree->root, val);
 }
 
 /* 查找节点 */
-TreeNode *search(aVLTree *tree, int val) {
+TreeNode *search(AVLTree *tree, int val) {
     TreeNode *cur = tree->root;
     // 循环查找，越过叶节点后跳出
     while (cur != NULL) {
@@ -207,13 +205,13 @@ TreeNode *search(aVLTree *tree, int val) {
     return cur;
 }
 
-void testInsert(aVLTree *tree, int val) {
+void testInsert(AVLTree *tree, int val) {
     insert(tree, val);
     printf("\n插入节点 %d 后，AVL 树为 \n", val);
     printTree(tree->root);
 }
 
-void testRemove(aVLTree *tree, int val) {
+void testRemove(AVLTree *tree, int val) {
     removeItem(tree, val);
     printf("\n删除节点 %d 后，AVL 树为 \n", val);
     printTree(tree->root);
@@ -222,7 +220,7 @@ void testRemove(aVLTree *tree, int val) {
 /* Driver Code */
 int main() {
     /* 初始化空 AVL 树 */
-    aVLTree *tree = (aVLTree *)newAVLTree();
+    AVLTree *tree = (AVLTree *)newAVLTree();
     /* 插入节点 */
     // 请关注插入节点后，AVL 树是如何保持平衡的
     testInsert(tree, 1);

codes/c/chapter_tree/binary_search_tree.c

@@ -7,11 +7,9 @@
 #include "../utils/common.h"
 
 /* 二叉搜索树 */
-struct binarySearchTree {
+typedef struct {
     TreeNode *root;
-};
+} BinarySearchTree;
-
-typedef struct binarySearchTree binarySearchTree;
 
 /* 比较器：从小到大排序 */
 int sortIntHelper(const void *a, const void *b) {
@@ -32,8 +30,8 @@ TreeNode *buildTree(int nums[], int i, int j) {
     return root;
 }
 
-binarySearchTree *newBinarySearchTree(int nums[], int size) {
+BinarySearchTree *newBinarySearchTree(int nums[], int size) {
-    binarySearchTree *bst = (binarySearchTree *)malloc(sizeof(binarySearchTree));
+    BinarySearchTree *bst = (BinarySearchTree *)malloc(sizeof(BinarySearchTree));
     TreeNode *root;
     // 从小到大排序数组
     qsort(nums, size, sizeof(int), sortIntHelper);
@@ -44,12 +42,12 @@ binarySearchTree *newBinarySearchTree(int nums[], int size) {
 }
 
 /* 获取二叉树根节点 */
-TreeNode *getRoot(binarySearchTree *bst) {
+TreeNode *getRoot(BinarySearchTree *bst) {
     return bst->root;
 }
 
 /* 查找节点 */
-TreeNode *search(binarySearchTree *bst, int num) {
+TreeNode *search(BinarySearchTree *bst, int num) {
     TreeNode *cur = bst->root;
     // 循环查找，越过叶节点后跳出
     while (cur != NULL) {
@@ -69,7 +67,7 @@ TreeNode *search(binarySearchTree *bst, int num) {
 }
 
 /* 插入节点 */
-void insert(binarySearchTree *bst, int num) {
+void insert(BinarySearchTree *bst, int num) {
     // 若树为空，则初始化根节点
     if (bst->root == NULL) {
         bst->root = newTreeNode(num);
@@ -102,7 +100,7 @@ void insert(binarySearchTree *bst, int num) {
 
 /* 删除节点 */
 // 由于引入了 stdio.h ，此处无法使用 remove 关键词
-void removeItem(binarySearchTree *bst, int num) {
+void removeItem(BinarySearchTree *bst, int num) {
     // 若树为空，直接提前返回
     if (bst->root == NULL)
         return;
@@ -154,7 +152,7 @@ void removeItem(binarySearchTree *bst, int num) {
 int main() {
     /* 初始化二叉搜索树 */
     int nums[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
-    binarySearchTree *bst = newBinarySearchTree(nums, sizeof(nums) / sizeof(int));
+    BinarySearchTree *bst = newBinarySearchTree(nums, sizeof(nums) / sizeof(int));
     printf("初始化的二叉树为\n");
     printTree(getRoot(bst));
 

codes/c/utils/list_node.h

@@ -12,13 +12,10 @@ extern "C" {
 #endif
 
 /* 链表节点结构体 */
-struct ListNode {
+typedef struct ListNode {
     int val;               // 节点值
     struct ListNode *next; // 指向下一节点的引用
-};
+} ListNode;
-
-// typedef 作用是为一种数据类型定义一个新名字
-typedef struct ListNode ListNode;
 
 /* 构造函数，初始化一个新节点 */
 ListNode *newListNode(int val) {
@@ -56,4 +53,4 @@ ListNode *getListNode(ListNode *head, int val) {
 }
 #endif
 
-#endif // LIST_NODE_H
+#endif // LIST_NODE_H

codes/c/utils/print_util.h

@@ -72,12 +72,10 @@ static void printLinkedList(ListNode *node) {
     printf("%d\n", node->val);
 }
 
-struct Trunk {
+typedef struct Trunk {
     struct Trunk *prev;
     char *str;
-};
+} Trunk;
-
-typedef struct Trunk Trunk;
 
 Trunk *newTrunk(Trunk *prev, char *str) {
     Trunk *trunk = (Trunk *)malloc(sizeof(Trunk));

codes/c/utils/tree_node.h

@@ -16,14 +16,12 @@ extern "C" {
 #define MAX_NODE_SIZE 5000
 
 /* 二叉树节点结构体 */
-struct TreeNode {
+typedef struct TreeNode {
     int val;                // 节点值
     int height;             // 节点高度
     struct TreeNode *left;  // 左子节点指针
     struct TreeNode *right; // 右子节点指针
-};
+} TreeNode;
-
-typedef struct TreeNode TreeNode;
 
 TreeNode *newTreeNode(int val) {
     TreeNode *node;

docs/chapter_array_and_linkedlist/linked_list.md

@@ -147,12 +147,10 @@
 
     ```c title=""
     /* 链表节点结构体 */
-    struct ListNode {
+    typedef struct ListNode {
         int val;               // 节点值
         struct ListNode *next; // 指向下一节点的指针
-    };
+    } ListNode;
-
-    typedef struct ListNode ListNode;
 
     /* 构造函数 */
     ListNode *newListNode(int val) {
@@ -617,13 +615,11 @@
 
     ```c title=""
     /* 双向链表节点结构体 */
-    struct ListNode {
+    typedef struct ListNode {
         int val;               // 节点值
         struct ListNode *next; // 指向后继节点的指针
         struct ListNode *prev; // 指向前驱节点的指针
-    };
+    } ListNode;
-
-    typedef struct ListNode ListNode;
 
     /* 构造函数 */
     ListNode *newListNode(int val) {

docs/chapter_tree/avl_tree.md

@@ -181,14 +181,12 @@ AVL 树既是二叉搜索树也是平衡二叉树，同时满足这两类二叉
 
     ```c title=""
     /* AVL 树节点结构体 */
-    struct TreeNode {
+    TreeNode struct TreeNode {
         int val;
         int height;
         struct TreeNode *left;
         struct TreeNode *right;
-    };
+    } TreeNode;
-
-    typedef struct TreeNode TreeNode;
 
     /* 构造函数 */
     TreeNode *newTreeNode(int val) {

docs/chapter_tree/binary_tree.md

@@ -157,14 +157,12 @@
 
     ```c title=""
     /* 二叉树节点结构体 */
-    struct TreeNode {
+    typedef struct TreeNode {
         int val;                // 节点值
         int height;             // 节点高度
         struct TreeNode *left;  // 左子节点指针
         struct TreeNode *right; // 右子节点指针
-    };
+    } TreeNode;
-
-    typedef struct TreeNode TreeNode;
 
     /* 构造函数 */
     TreeNode *newTreeNode(int val) {
@@ -594,9 +592,9 @@
 
 <p align="center"> 表 <id> &nbsp; 二叉树的最佳与最差情况 </p>
 
-|                               | 完美二叉树 | 链表         |
+|                         | 完美二叉树         | 链表    |
-| ----------------------------- | ---------- | ---------- |
+| ----------------------- | ------------------ | ------- |
-| 第 $i$ 层的节点数量    | $2^{i-1}$          | $1$     |
+| 第 $i$ 层的节点数量     | $2^{i-1}$          | $1$     |
-| 高度 $h$ 树的叶节点数量 | $2^h$          | $1$     |
+| 高度 $h$ 树的叶节点数量 | $2^h$              | $1$     |
-| 高度 $h$ 树的节点总数 | $2^{h+1} - 1$      | $h + 1$     |
+| 高度 $h$ 树的节点总数   | $2^{h+1} - 1$      | $h + 1$ |
-| 节点总数 $n$ 树的高度 | $\log_2 (n+1) - 1$ | $n - 1$     |
+| 节点总数 $n$ 树的高度   | $\log_2 (n+1) - 1$ | $n - 1$ |