更正文件名称

CMakeLists.txt

@@ -16,11 +16,11 @@ set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -O0")
 
 include_directories(
     .
-    src/lib/queue
+    src/lib/list
 )
 set(PROJECT_SOURCES
     src/main.c
-    src/lib/queue/queue.c
+    src/lib/list/list.c
 )
 add_executable(${PROJECT_NAME}
     ${PROJECT_SOURCES}

src/lib/list/list.c

@@ -1,5 +1,5 @@
 /**
- * @file queue.c
+ * @file list.c
  * @author guishenking (guishenking@outlook.com)
  * @brief 
  * @version 0.1
@@ -8,46 +8,46 @@
  * @copyright Copyright (c) 2025
  * 
  */
-#include "queue.h"
+#include "list.h"
 #include <stdlib.h>
 #include <string.h>
 
 /**
  * @brief 初始化队列
  * 
- * @param queue 
+ * @param list 
  * @param elem_size 数据类型大小
  */
-bool queue_init(queue_t *queue, size_t elem_size) {
-    queue->head = NULL;
-    queue->tail = NULL;
-    queue->size = 0;
+bool list_init(list_t *list, size_t elem_size) {
+    list->head = NULL;
+    list->tail = NULL;
+    list->size = 0;
     if(elem_size == 0) {
         return false; // 元素大小不能为0
     }
-    queue->elem_size = elem_size;
+    list->elem_size = elem_size;
     return true;
 }
 
 /**
  * @brief 入队
  * 
- * @param queue 
+ * @param list 
  * @param value 
  * @return true 
  * @return false 
  */
-bool queue_enqueue(queue_t *queue, const void *value) {
+bool list_enlist(list_t *list, const void *value) {
     // 分配新节点
-    if (queue->size >= QUEUE_MAX_SIZE) {
+    if (list->size >= list_MAX_SIZE) {
         return false;   
     }
-    queue_node_t *node = (queue_node_t *)malloc(sizeof(queue_node_t));
+    list_node_t *node = (list_node_t *)malloc(sizeof(list_node_t));
     if (!node) {
         return false;
     }
     // 分配数据空间并复制数据
-    node->data = malloc(queue->elem_size);
+    node->data = malloc(list->elem_size);
     // 检查数据分配是否成功
     if (!node->data) {
         // 数据分配失败，此时node还未加入链表，只需释放node本身即可
@@ -55,115 +55,115 @@ bool queue_enqueue(queue_t *queue, const void *value) {
         return false;
     }
     // 复制数据到节点
-    memcpy(node->data, value, queue->elem_size);
+    memcpy(node->data, value, list->elem_size);
     // 将下一级节点添加到队列
     node->next = NULL;
     // 如果队列为空，设置头尾指针
-    if (queue->tail) {
+    if (list->tail) {
         // 如果队列不为空，将新节点添加到尾部
-        queue->tail->next = node;
+        list->tail->next = node;
     } else {
         // 如果队列为空，将新节点设置为头部
-        queue->head = node;
+        list->head = node;
     }
     // 更新尾部指针并增加队列大小
-    queue->tail = node;
-    queue->size++;
+    list->tail = node;
+    list->size++;
     return true;
 }
 
 /**
  * @brief 从队列头部出队
  * 
- * @param queue 
+ * @param list 
  * @param value 
  * @return true 
  * @return false 
  */
-bool queue_dequeue_head(queue_t *queue, void *value) {
+bool list_delist_head(list_t *list, void *value) {
     // 检查队列是否为空
-    if (queue->size == 0) {
+    if (list->size == 0) {
         return false;
     }
-    queue_node_t *node = queue->head;
+    list_node_t *node = list->head;
     // 复制头部数据到输出参数
-    memcpy(value, node->data, queue->elem_size);
+    memcpy(value, node->data, list->elem_size);
     // 更新头部指针
-    queue->head = node->next;
+    list->head = node->next;
     // 如果头部为空，更新尾部指针
-    if (!queue->head) {
-        queue->tail = NULL;
+    if (!list->head) {
+        list->tail = NULL;
     }
     // 释放节点和数据
     free(node->data);
     free(node);
-    queue->size--;
+    list->size--;
     return true;
 }
 
 /**
  * @brief 从队列尾部出队
  * 
- * @param queue 
+ * @param list 
  * @param value 
  * @return true 
  * @return false 
  */
-bool queue_dequeue_tail(queue_t *queue, void *value) {
-    if (queue->size == 0) {
+bool list_delist_tail(list_t *list, void *value) {
+    if (list->size == 0) {
         return false;
     }
-    queue_node_t *prev = NULL;
-    queue_node_t *node = queue->head;
+    list_node_t *prev = NULL;
+    list_node_t *node = list->head;
     // 找到最后一个节点
     while (node && node->next) {
         prev = node;
         node = node->next;
     }
-    memcpy(value, node->data, queue->elem_size);
+    memcpy(value, node->data, list->elem_size);
     if (prev) {
         prev->next = NULL;
-        queue->tail = prev;
+        list->tail = prev;
     } else {
         // 只有一个节点
-        queue->head = NULL;
-        queue->tail = NULL;
+        list->head = NULL;
+        list->tail = NULL;
     }
     free(node->data);
     free(node);
-    queue->size--;
+    list->size--;
     return true;
 }
 
 /**
  * @brief 查询队列指定位置的数据
  * 
- * @param queue 队列指针
+ * @param list 队列指针
  * @param index 位置(0为头部)
  * @param value 输出数据指针
  * @return true 查询成功
  * @return false 越界或队列为空
  */
-bool queue_peek_at(const queue_t *queue, size_t index, void *value) {
-    if (index >= queue->size || queue->size == 0) {
+bool list_peek_at(const list_t *list, size_t index, void *value) {
+    if (index >= list->size || list->size == 0) {
         return false; // 越界或队列为空
     }
-    queue_node_t *node = queue->head;
+    list_node_t *node = list->head;
     for (size_t i = 0; i < index; ++i) {
         node = node->next;
     }
-    memcpy(value, node->data, queue->elem_size);
+    memcpy(value, node->data, list->elem_size);
     return true;
 }
 
 /**
  * @brief 遍历队列
  * 
- * @param queue 
+ * @param list 
  * @param func 回调函数 指定了数据(未指定数据类型)和索引
  */
-void queue_foreach(const queue_t *queue, void (*func)(void *data, size_t index)) {
-    queue_node_t *node = queue->head;
+void list_foreach(const list_t *list, void (*func)(void *data, size_t index)) {
+    list_node_t *node = list->head;
     size_t idx = 0;
     while (node) {
         func(node->data, idx);
@@ -175,30 +175,30 @@ void queue_foreach(const queue_t *queue, void (*func)(void *data, size_t index))
 /**
  * @brief 抛弃队列前n个数据
  * 
- * @param queue 队列指针
+ * @param list 队列指针
  * @param n 要抛弃的元素数量
  * @return size_t 实际抛弃的元素数量
  */
-size_t queue_drop_head(queue_t *queue, size_t n) {
+size_t list_drop_head(list_t *list, size_t n) {
     size_t dropped = 0;
-    if (n == 0 || queue->size == 0) {
+    if (n == 0 || list->size == 0) {
         return 0;
     }
-    if (n >= queue->size) {
-        dropped = queue->size;
-        queue_clear(queue);
+    if (n >= list->size) {
+        dropped = list->size;
+        list_clear(list);
         return dropped;
     }
-    while (dropped < n && queue->size > 0) {
-        queue_node_t *node = queue->head;
-        queue->head = node->next;
+    while (dropped < n && list->size > 0) {
+        list_node_t *node = list->head;
+        list->head = node->next;
         free(node->data);
         free(node);
-        queue->size--;
+        list->size--;
         dropped++;
     }
-    if (!queue->head) {
-        queue->tail = NULL;
+    if (!list->head) {
+        list->tail = NULL;
     }
     return dropped;
 }
@@ -206,24 +206,24 @@ size_t queue_drop_head(queue_t *queue, size_t n) {
 /**
  * @brief 抛弃队列尾部n个数据
  * 
- * @param queue 队列指针
+ * @param list 队列指针
  * @param n 要抛弃的元素数量
  * @return size_t 实际抛弃的元素数量
  */
-size_t queue_drop_tail(queue_t *queue, size_t n) {
+size_t list_drop_tail(list_t *list, size_t n) {
     size_t dropped = 0;
-    if (n == 0 || queue->size == 0) {
+    if (n == 0 || list->size == 0) {
         return 0;
     }
-    if (n >= queue->size) {
+    if (n >= list->size) {
         // 清空整个队列
-        dropped = queue->size;
-        queue_clear(queue);
+        dropped = list->size;
+        list_clear(list);
         return dropped;
     }
     for (size_t i = 0; i < n; ++i) {
-        queue_node_t *prev = NULL;
-        queue_node_t *node = queue->head;
+        list_node_t *prev = NULL;
+        list_node_t *node = list->head;
         // 找到最后一个节点
         while (node && node->next) {
             prev = node;
@@ -232,15 +232,15 @@ size_t queue_drop_tail(queue_t *queue, size_t n) {
         if (!node) break;
         if (prev) {
             prev->next = NULL;
-            queue->tail = prev;
+            list->tail = prev;
         } else {
             // 只有一个节点
-            queue->head = NULL;
-            queue->tail = NULL;
+            list->head = NULL;
+            list->tail = NULL;
         }
         free(node->data);
         free(node);
-        queue->size--;
+        list->size--;
         dropped++;
     }
     return dropped;
@@ -249,48 +249,48 @@ size_t queue_drop_tail(queue_t *queue, size_t n) {
 /**
  * @brief 判断队列是否为空
  * 
- * @param queue 
+ * @param list 
  * @return true 
  * @return false 
  */
-bool queue_is_empty(const queue_t *queue) {
-    return queue->size == 0;
+bool list_is_empty(const list_t *list) {
+    return list->size == 0;
 }
 
 /**
  * @brief 获取队列长度
  * 
- * @param queue 
+ * @param list 
  * @return size_t 
  */
-size_t queue_length(const queue_t *queue) {
-    return queue->size;
+size_t list_length(const list_t *list) {
+    return list->size;
 }
 
 /**
  * @brief 清空队列
  * 
- * @param queue 
+ * @param list 
  */
-void queue_clear(queue_t *queue) {
-    queue_node_t *node = queue->head;
+void list_clear(list_t *list) {
+    list_node_t *node = list->head;
     while (node) {
-        queue_node_t *next = node->next;
+        list_node_t *next = node->next;
         free(node->data);
         free(node);
         node = next;
     }
-    queue->head = NULL;
-    queue->tail = NULL;
-    queue->size = 0;
+    list->head = NULL;
+    list->tail = NULL;
+    list->size = 0;
 }
 
 /**
  * @brief 销毁队列
  * 
- * @param queue 
+ * @param list 
  */
-void queue_destroy(queue_t *queue) {
-    queue_clear(queue);
+void list_destroy(list_t *list) {
+    list_clear(list);
     // 如果有其他资源分配，可在此释放
 }

src/lib/list/list.h

@@ -0,0 +1,60 @@
+/**
+ * @file list.h
+ * @author guishenking (guishenking@outlook.com)
+ * @brief 
+ * @version 0.1
+ * @date 2025-08-14
+ * 
+ * @copyright Copyright (c) 2025
+ * 
+ */
+#ifndef _GSK_list_H
+#define _GSK_list_H
+
+#include <stdbool.h>
+#include <stddef.h>
+
+#define list_MAX_SIZE (1024)
+// 定义队列节点
+typedef struct list_node {
+    void *data;
+    struct list_node *next;
+} list_node_t;
+
+// 定义队列结构
+typedef struct {
+    list_node_t *head;
+    list_node_t *tail;
+    size_t size;
+    size_t elem_size;
+} list_t;
+
+//初始化队列
+bool list_init(list_t *list, size_t elem_size);
+
+// 入队操作
+bool list_enlist(list_t *list, const void *value);
+// 出队操作
+
+// 从队列头部出队
+bool list_delist_head(list_t *list, void *value);
+// 从队列尾部出队
+bool list_delist_tail(list_t *list, void *value);
+// 查询队列指定位置的数据
+bool list_peek_at(const list_t *list, size_t index, void *value);
+// 遍历队列
+void list_foreach(const list_t *list, void (*func)(void *data, size_t index));
+// 抛弃队列前n个数据
+size_t list_drop_head(list_t *list, size_t n);
+// 抛弃队列尾部n个数据
+size_t list_drop_tail(list_t *list, size_t n);
+// 检查队列是否为空
+bool list_is_empty(const list_t *list);
+// 获取队列长度
+size_t list_length(const list_t *list);
+// 清空队列
+void list_clear(list_t *list);
+// 销毁队列
+void list_destroy(list_t *list);
+
+#endif // !_GSK_list_H

src/lib/queue/queue.h

@@ -1,60 +0,0 @@
-/**
- * @file queue.h
- * @author guishenking (guishenking@outlook.com)
- * @brief 
- * @version 0.1
- * @date 2025-08-14
- * 
- * @copyright Copyright (c) 2025
- * 
- */
-#ifndef _GSK_queue_H
-#define _GSK_queue_H
-
-#include <stdbool.h>
-#include <stddef.h>
-
-#define QUEUE_MAX_SIZE (1024)
-// 定义队列节点
-typedef struct queue_node {
-    void *data;
-    struct queue_node *next;
-} queue_node_t;
-
-// 定义队列结构
-typedef struct {
-    queue_node_t *head;
-    queue_node_t *tail;
-    size_t size;
-    size_t elem_size;
-} queue_t;
-
-//初始化队列
-bool queue_init(queue_t *queue, size_t elem_size);
-
-// 入队操作
-bool queue_enqueue(queue_t *queue, const void *value);
-// 出队操作
-
-// 从队列头部出队
-bool queue_dequeue_head(queue_t *queue, void *value);
-// 从队列尾部出队
-bool queue_dequeue_tail(queue_t *queue, void *value);
-// 查询队列指定位置的数据
-bool queue_peek_at(const queue_t *queue, size_t index, void *value);
-// 遍历队列
-void queue_foreach(const queue_t *queue, void (*func)(void *data, size_t index));
-// 抛弃队列前n个数据
-size_t queue_drop_head(queue_t *queue, size_t n);
-// 抛弃队列尾部n个数据
-size_t queue_drop_tail(queue_t *queue, size_t n);
-// 检查队列是否为空
-bool queue_is_empty(const queue_t *queue);
-// 获取队列长度
-size_t queue_length(const queue_t *queue);
-// 清空队列
-void queue_clear(queue_t *queue);
-// 销毁队列
-void queue_destroy(queue_t *queue);
-
-#endif // !_GSK_queue_H

src/main.c

@@ -8,7 +8,7 @@
  * @copyright Copyright (c) 2025
  * 
  */
-#include "queue.h"
+#include "list.h"
 #include <stdio.h>
 
 
@@ -17,54 +17,54 @@ void print_int(void *data, size_t idx) {
 }
 
 int main(void) {
-    queue_t q;
+    list_t q;
     int ret;
     // 初始化队列，存储int类型
-    if (!queue_init(&q, sizeof(int))) {
+    if (!list_init(&q, sizeof(int))) {
         printf("Init failed!\n");
         return -1;
     }
 
     // 入队
     for (int i = 1; i <= 10; ++i) {
-        ret = queue_enqueue(&q, &i);
-        printf("Enqueue %d: %s\n", i, ret ? "OK" : "FAIL");
+        ret = list_enlist(&q, &i);
+        printf("Enlist %d: %s\n", i, ret ? "OK" : "FAIL");
     }
-    queue_foreach(&q, print_int);
+    list_foreach(&q, print_int);
 
     // 查询第3个元素
     int val = 0;
-    if (queue_peek_at(&q, 2, &val)) {
+    if (list_peek_at(&q, 2, &val)) {
         printf("Peek index 2: %d\n", val);
     }
 
     // 从头部出队
     for (int i = 0; i < 2; ++i) {
-        if (queue_dequeue_head(&q, &val)) {
-            printf("Dequeue head: %d\n", val);
+        if (list_delist_head(&q, &val)) {
+            printf("Delist head: %d\n", val);
         }
     }
-    queue_foreach(&q, print_int);
+    list_foreach(&q, print_int);
 
     // 从尾部出队
-    if (queue_dequeue_tail(&q, &val)) {
-        printf("Dequeue tail: %d\n", val);
+    if (list_delist_tail(&q, &val)) {
+        printf("Delist tail: %d\n", val);
     }
-    queue_foreach(&q, print_int);
+    list_foreach(&q, print_int);
 
     // 抛弃前3个
-    size_t dropped = queue_drop_head(&q, 3);
+    size_t dropped = list_drop_head(&q, 3);
     printf("Drop head 3, actually dropped: %zu\n", dropped);
-    queue_foreach(&q, print_int);
+    list_foreach(&q, print_int);
 
     // 抛弃尾部10个（超出队列长度，实际清空）
-    dropped = queue_drop_tail(&q, 10);
+    dropped = list_drop_tail(&q, 10);
     printf("Drop tail 10, actually dropped: %zu\n", dropped);
-    queue_foreach(&q, print_int);
+    list_foreach(&q, print_int);
 
     // 销毁队列
-    queue_destroy(&q);
-    printf("Queue destroyed.\n");
+    list_destroy(&q);
+    printf("list destroyed.\n");
 
     return 0;
 }