C_Base_lib/list
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

更正文件名称

Browse Source
This commit is contained in:
guishenking
2025-08-19 20:28:21 +08:00
parent 6ffe4c830d
commit d0e1a196de
5 changed files with 167 additions and 167 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
CMakeLists.txt
View File

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

172
src/lib/queue/queue.c → src/lib/list/list.c
View File

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

60
src/lib/list/list.h Normal file
View File

@@ -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

60
src/lib/queue/queue.h
View File

@@ -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

38
src/main.c
View File

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