JiXieShi
/
HW_Lib
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

UP

main
JiXieShi 2024-06-21 15:21:42 +08:00
parent 9d4fd5a082
commit cd1bb16183
8 changed files with 207 additions and 184 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
demo/list/t_list.h
View File

@ -7,4 +7,5 @@
extern void Test_List(); extern void Test_List();
extern void Test_Queue();
#endif //HW_LIB_T_LIST_H #endif //HW_LIB_T_LIST_H

92
demo/list/test.c
View File

@ -2,6 +2,7 @@
#include <stdio.h> #include <stdio.h>
#include "list.h" #include "list.h"
#include "queue.h"
typedef struct test { typedef struct test {
int val1; int val1;
@ -27,7 +28,7 @@ int compare_int_sort(const void *s1, const void *s2) {
return (data1->val1 - data2->val1); return (data1->val1 - data2->val1);
} }
void print(List *list) { void print(List_t *list) {
printf("list len = %ld\n", list_get_lenth(list)); printf("list len = %ld\n", list_get_lenth(list));
if (!list_is_empty(list)) { if (!list_is_empty(list)) {
//test list_reverse //test list_reverse
@ -38,66 +39,83 @@ void print(List *list) {
} }
void Test_List() { void Test_List() {
List list; List_t list;
list_init(&list); list_init(&list); // 初始化链表
test_t test1 = {10, 10.5}; test_t test1 = {10, 10.5};
test_t test2 = {20, 20.5}; test_t test2 = {20, 20.5};
test_t test3 = {30, 30.5}; test_t test3 = {30, 30.5};
test_t test4 = {40, 40.5}; test_t test4 = {40, 40.5};
test_t test5 = {50, 50.5}; test_t test5 = {50, 50.5};
//test list_insert // 测试插入操作
printf("------insert(_at_tail)----\n"); printf("------insert(_at_tail)----\n");
list_insert(&list, &test1); list_insert(&list, &test1); // 在尾部插入test1
list_insert(&list, &test2); list_insert(&list, &test2); // 在尾部插入test2
list_insert(&list, &test3); list_insert(&list, &test3); // 在尾部插入test3
print(&list); print(&list); // 打印链表
//test list_delete // 测试删除操作
printf("------delete----\n"); printf("------delete----\n");
list_delete(&list, &test1.val1, compare_int); list_delete(&list, &test1.val1, compare_int); // 删除值为test1.val1的节点
print(&list); print(&list); // 打印链表
//test list_insert_at_head // 测试在头部插入操作
printf("------insert_at_head----\n"); printf("------insert_at_head----\n");
list_insert_at_head(&list, &test4); list_insert_at_head(&list, &test4); // 在头部插入test4
print(&list); print(&list); // 打印链表
//test list_insert_at_index // 测试在指定位置插入操作
printf("------insert_at_index(2)----\n"); printf("------insert_at_index(2)----\n");
list_insert_at_index(&list, &test5, 2); list_insert_at_index(&list, &test5, 2); // 在索引2处插入test5
print(&list); print(&list); // 打印链表
//test list_reverse // 测试链表反转操作
printf("------reverse----\n"); printf("------reverse----\n");
list_reverse(&list); list_reverse(&list); // 反转链表
print(&list); print(&list); // 打印链表
//test list_search // 测试搜索操作
int key = 20; int key = 20;
test_t *ret; test_t *ret;
printf("------search----\n"); printf("------search----\n");
ret = list_search(&list, &key, compare_int); ret = list_search(&list, &key, compare_int); // 搜索值为key的节点
printf("%d:%f\n", ret->val1, ret->val2); printf("%d:%f\n", ret->val1, ret->val2); // 打印搜索结果
key = 50; key = 50;
ret = list_search(&list, &key, compare_int); ret = list_search(&list, &key, compare_int); // 搜索值为key的节点
printf("%d:%f\n", ret->val1, ret->val2); printf("%d:%f\n", ret->val1, ret->val2); // 打印搜索结果
//test list_get_element // 测试获取指定位置元素操作
printf("------list_get_element----\n"); printf("------list_get_element----\n");
ret = list_get_element(&list, 2); ret = list_get_element(&list, 2); // 获取索引为2的元素
printf("%d:%f\n", ret->val1, ret->val2); printf("%d:%f\n", ret->val1, ret->val2); // 打印获取的元素
ret = list_get_element(&list, 3); ret = list_get_element(&list, 3); // 获取索引为3的元素
printf("%d:%f\n", ret->val1, ret->val2); printf("%d:%f\n", ret->val1, ret->val2); // 打印获取的元素
//test list_sort // 测试排序操作
printf("-----sort----\n"); printf("-----sort----\n");
list_sort(&list, compare_int_sort); list_sort(&list, compare_int_sort); // 按照整数值排序
print(&list); print(&list); // 打印排序后的链表
//test list_destroy // 测试销毁操作
printf("-----destroy----\n"); printf("-----destroy----\n");
list_destroy(&list, NULL); list_destroy(&list, NULL); // 销毁链表
}
return 0;
void Test_Queue() {
Queue_List_t *deque = newQueue_List(sizeof(int)); // 创建一个int类型的双端队列
// 测试入队操作
int val1 = 10;
pushFirst(deque, &val1); // 将10插入队首
char val2 = 'A';
pushLast(deque, &val2); // 将字符'A'插入队尾
// 测试出队操作
int *popVal1 = (int *) popFirst(deque); // 从队首出队
char *popVal2 = (char *) popLast(deque); // 从队尾出队
// 打印出队的值
printf("Pop value from front: %d\n", *popVal1);
printf("Pop value from rear: %c\n", *popVal2);
} }

69
lib/inc/list/list.h
View File

@ -1,3 +1,4 @@
#pragma once
#ifndef HW_LIB_LIST_H #ifndef HW_LIB_LIST_H
#define HW_LIB_LIST_H #define HW_LIB_LIST_H
#ifdef __cplusplus #ifdef __cplusplus
@ -6,59 +7,59 @@ extern "C" {
#include <stdbool.h> #include <stdbool.h>
typedef struct node { //节点结构 typedef struct List_Node_t { //节点结构
void *data; void *data;
struct node *next; struct List_Node_t *next;
} node; } List_Node_t;
typedef struct { //链表结构 typedef struct { //链表结构
struct node *head; struct List_Node_t *head;
struct node *tail; struct List_Node_t *tail;
long len; long len;
} List; } List_t;
/** /**
* @brief 初始化链表 * @brief 初始化链表
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @return void * @return void
* @example list_init(&myList); * @example list_init(&myList_t);
*/ */
extern void list_init(List *list); extern void list_init(List_t *list);
/** /**
* @brief 检查链表是否为空 * @brief 检查链表是否为空
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @return bool 若链表为空返回true，否则返回false * @return bool 若链表为空返回true，否则返回false
* @example if (list_is_empty(&myList)) { // do something } * @example if (list_is_empty(&myList_t)) { // do something }
*/ */
extern bool list_is_empty(List *list); extern bool list_is_empty(List_t *list);
/** /**
* @brief 在链表尾部插入元素 * @brief 在链表尾部插入元素
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针 * @param data: [输入] 待插入的数据指针
* @return void * @return void
* @example list_insert(&myList, newData); * @example list_insert(&myList_t, newData);
*/ */
extern void list_insert(List *list, void *data); extern void list_insert(List_t *list, void *data);
/** /**
* @brief 在链表头部插入元素 * @brief 在链表头部插入元素
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针 * @param data: [输入] 待插入的数据指针
* @return void * @return void
* @example list_insert_at_head(&myList, newData); * @example list_insert_at_head(&myList_t, newData);
*/ */
extern void list_insert_at_head(List *list, void *data); extern void list_insert_at_head(List_t *list, void *data);
/** /**
* @brief 在链表尾部插入元素 * @brief 在链表尾部插入元素
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针 * @param data: [输入] 待插入的数据指针
* @return void * @return void
* @example list_insert_at_tail(&myList, newData); * @example list_insert_at_tail(&myList_t, newData);
*/ */
extern void list_insert_at_tail(List *list, void *data); extern void list_insert_at_tail(List_t *list, void *data);
/** /**
* @brief 在指定位置插入元素 * @brief 在指定位置插入元素
@ -66,9 +67,9 @@ extern void list_insert_at_tail(List *list, void *data);
* @param data: [输入] 待插入的数据指针 * @param data: [输入] 待插入的数据指针
* @param idx: [输入] 插入位置索引 * @param idx: [输入] 插入位置索引
* @return void * @return void
* @example list_insert_at_index(&myList, newData, 2); * @example list_insert_at_index(&myList_t, newData, 2);
*/ */
extern void list_insert_at_index(List *list, void *data, long idx); extern void list_insert_at_index(List_t *list, void *data, long idx);
/** /**
* @brief 删除链表中指定元素 * @brief 删除链表中指定元素
@ -76,9 +77,9 @@ extern void list_insert_at_index(List *list, void *data, long idx);
* @param key: [输入] 待删除的数据指针 * @param key: [输入] 待删除的数据指针
* @param compare: [输入] 比较函数指针 * @param compare: [输入] 比较函数指针
* @return void* 返回被删除元素的数据，若未找到返回NULL * @return void* 返回被删除元素的数据，若未找到返回NULL
* @example deletedData = list_delete(&myList, keyData, compareFunc); * @example deletedData = list_delete(&myList_t, keyData, compareFunc);
*/ */
extern void *list_delete(List *list, void *key, int (*compare)(const void *, const void *)); extern void *list_delete(List_t *list, void *key, int (*compare)(const void *, const void *));
/** /**
* @brief 在链表中查找指定元素 * @brief 在链表中查找指定元素
@ -86,61 +87,61 @@ extern void *list_delete(List *list, void *key, int (*compare)(const void *, con
* @param key: [输入] 待查找的数据指针 * @param key: [输入] 待查找的数据指针
* @param compare: [输入] 比较函数指针 * @param compare: [输入] 比较函数指针
* @return void* 返回找到的元素的数据，若未找到返回NULL * @return void* 返回找到的元素的数据，若未找到返回NULL
* @example foundData = list_search(&myList, keyData, compareFunc); * @example foundData = list_search(&myList_t, keyData, compareFunc);
*/ */
extern void *list_search(List *list, void *key, int (*compare)(const void *, const void *)); extern void *list_search(List_t *list, void *key, int (*compare)(const void *, const void *));
/** /**
* @brief 对链表进行排序 * @brief 对链表进行排序
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param compare: [输入] 比较函数指针 * @param compare: [输入] 比较函数指针
* @return void * @return void
* @example list_sort(&myList, compareFunc); * @example list_sort(&myList_t, compareFunc);
*/ */
extern void list_sort(List *list, int (*compare)(const void *, const void *)); extern void list_sort(List_t *list, int (*compare)(const void *, const void *));
/** /**
* @brief 遍历链表并对每个元素执行指定操作 * @brief 遍历链表并对每个元素执行指定操作
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param handle: [输入] 处理函数指针 * @param handle: [输入] 处理函数指针
* @return void * @return void
* @example list_traverse(&myList, handleFunc); * @example list_traverse(&myList_t, handleFunc);
*/ */
extern void list_traverse(List *list, void (*handle)(void *)); extern void list_traverse(List_t *list, void (*handle)(void *));
/** /**
* @brief 反转链表 * @brief 反转链表
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @return void * @return void
* @example list_reverse(&myList); * @example list_reverse(&myList_t);
*/ */
extern void list_reverse(List *list); extern void list_reverse(List_t *list);
/** /**
* @brief 获取链表长度 * @brief 获取链表长度
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @return long 返回链表中元素个数 * @return long 返回链表中元素个数
* @example length = list_get_lenth(&myList); * @example length = list_get_lenth(&myList_t);
*/ */
extern long list_get_lenth(List *list); extern long list_get_lenth(List_t *list);
/** /**
* @brief 获取链表指定位置的元素 * @brief 获取链表指定位置的元素
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param idx: [输入] 元素索引 * @param idx: [输入] 元素索引
* @return void* 返回指定位置的元素指针，若索引无效返回NULL * @return void* 返回指定位置的元素指针，若索引无效返回NULL
* @example element = list_get_element(&myList, 3); * @example element = list_get_element(&myList_t, 3);
*/ */
extern void *list_get_element(List *list, int idx); extern void *list_get_element(List_t *list, int idx);
/** /**
* @brief 销毁链表 * @brief 销毁链表
* @param list: [输入] 链表指针 * @param list: [输入] 链表指针
* @param destroy: [输入] 数据销毁函数指针 * @param destroy: [输入] 数据销毁函数指针
* @return void * @return void
* @example list_destroy(&myList, destroyFunc); * @example list_destroy(&myList_t, destroyFunc);
*/ */
extern void list_destroy(List *list, void (*destroy)(void *data)); extern void list_destroy(List_t *list, void (*destroy)(void *data));
#ifdef __cplusplus #ifdef __cplusplus
} }

51
lib/inc/list/queue.h
View File

@ -1,3 +1,4 @@
#pragma once
#ifndef HW_LIB_QUEUE_H #ifndef HW_LIB_QUEUE_H
#define HW_LIB_QUEUE_H #define HW_LIB_QUEUE_H
#ifdef __cplusplus #ifdef __cplusplus
@ -7,34 +8,36 @@ extern "C" {
/** /**
* @brief 双向链表节点结构体 * @brief 双向链表节点结构体
*/ */
typedef struct DoublyListNode { typedef struct Queue_Node_t {
void *val; // 节点值 void *val; // 节点值
struct DoublyListNode *next; // 后继节点 struct Queue_Node_t *next; // 后继节点
struct DoublyListNode *prev; // 前驱节点 struct Queue_Node_t *prev; // 前驱节点
} DoublyListNode; } Queue_Node_t;
/** /**
* @brief 双端队列结构体 * @brief 双端队列结构体
*/ */
typedef struct { typedef struct {
DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear Queue_Node_t *front, *rear; // 头节点 front ，尾节点 rear
int queSize; // 双向队列的长度 int queSize; // 双向队列的长度
} LinkedListDeque; size_t typeSize; // 元素类型的大小
} Queue_List_t;
/** /**
* @brief 创建一个新的双端队列 * @brief 创建一个新的双端队列
* @return LinkedListDeque* 返回新创建的双端队列指针 * @param typeSize: [输入] 元素类型的大小
* @example deque = newLinkedListDeque(); * @return Queue_List_t* 返回新创建的双端队列指针
* @example deque = newQueue_List(sizeof(int));
*/ */
extern LinkedListDeque *newLinkedListDeque(); extern Queue_List_t *newQueue_List(unsigned char size);
/** /**
* @brief 销毁双端队列 * @brief 销毁双端队列
* @param deque: [输入] 双端队列指针 * @param deque: [输入] 双端队列指针
* @return void * @return void
* @example delLinkedListdeque(deque); * @example delQueue_List(deque);
*/ */
extern void delLinkedListdeque(LinkedListDeque *deque); extern void delQueue_List(Queue_List_t *deque);
/** /**
* @brief 获取队列大小 * @brief 获取队列大小
@ -42,7 +45,7 @@ extern void delLinkedListdeque(LinkedListDeque *deque);
* @return int 返回队列中元素个数 * @return int 返回队列中元素个数
* @example size = queue_size(deque); * @example size = queue_size(deque);
*/ */
extern int queue_size(LinkedListDeque *deque); extern int queue_size(Queue_List_t *deque);
/** /**
* @brief 检查队列是否为空 * @brief 检查队列是否为空
@ -50,7 +53,7 @@ extern int queue_size(LinkedListDeque *deque);
* @return bool 若队列为空返回true，否则返回false * @return bool 若队列为空返回true，否则返回false
* @example if (queue_is_empty(deque)) { // do something } * @example if (queue_is_empty(deque)) { // do something }
*/ */
extern bool queue_is_empty(LinkedListDeque *deque); extern bool queue_is_empty(Queue_List_t *deque);
/** /**
* @brief 在队列头部插入元素 * @brief 在队列头部插入元素
@ -59,7 +62,7 @@ extern bool queue_is_empty(LinkedListDeque *deque);
* @return void * @return void
* @example pushFirst(deque, newData); * @example pushFirst(deque, newData);
*/ */
extern void pushFirst(LinkedListDeque *deque, void *data); extern void pushFirst(Queue_List_t *deque, void *data);
/** /**
* @brief 在队列尾部插入元素 * @brief 在队列尾部插入元素
@ -68,7 +71,7 @@ extern void pushFirst(LinkedListDeque *deque, void *data);
* @return void * @return void
* @example pushLast(deque, newData); * @example pushLast(deque, newData);
*/ */
extern void pushLast(LinkedListDeque *deque, void *data); extern void pushLast(Queue_List_t *deque, void *data);
/** /**
* @brief 获取队列头部元素但不移除 * @brief 获取队列头部元素但不移除
@ -76,7 +79,7 @@ extern void pushLast(LinkedListDeque *deque, void *data);
* @return void* 返回队列头部元素的指针，若队列为空返回NULL * @return void* 返回队列头部元素的指针，若队列为空返回NULL
* @example firstData = peekFirst(deque); * @example firstData = peekFirst(deque);
*/ */
extern void *peekFirst(LinkedListDeque *deque); extern void *peekFirst(Queue_List_t *deque);
/** /**
* @brief 获取队列尾部元素但不移除 * @brief 获取队列尾部元素但不移除
@ -84,24 +87,14 @@ extern void *peekFirst(LinkedListDeque *deque);
* @return void* 返回队列尾部元素的指针，若队列为空返回NULL * @return void* 返回队列尾部元素的指针，若队列为空返回NULL
* @example lastData = peekLast(deque); * @example lastData = peekLast(deque);
*/ */
extern void *peekLast(LinkedListDeque *deque); extern void *peekLast(Queue_List_t *deque);
/**
* @brief 弹出队列头部或尾部元素
* @param deque: [输入] 双端队列指针
* @param isFront: [输入] 若为true则从头部弹出，否则从尾部弹出
* @return void* 返回被弹出元素的指针，若队列为空返回NULL
* @example poppedData = pop(deque, true);
*/
extern void *pop(LinkedListDeque *deque, bool isFront);
/** /**
* @brief 弹出队列头部元素 * @brief 弹出队列头部元素
* @param deque: [输入] 双端队列指针 * @param deque: [输入] 双端队列指针
* @return void* 返回被弹出的头部元素的指针，若队列为空返回NULL * @return void* 返回被弹出的头部元素的指针，若队列为空返回NULL
* @example poppedData = popFirst(deque); * @example poppedData = popFirst(deque);
*/ */
extern void *popFirst(LinkedListDeque *deque); extern void *popFirst(Queue_List_t *deque);
/** /**
* @brief 弹出队列尾部元素 * @brief 弹出队列尾部元素
@ -109,7 +102,7 @@ extern void *popFirst(LinkedListDeque *deque);
* @return void* 返回被弹出的尾部元素的指针，若队列为空返回NULL * @return void* 返回被弹出的尾部元素的指针，若队列为空返回NULL
* @example poppedData = popLast(deque); * @example poppedData = popLast(deque);
*/ */
extern void *popLast(LinkedListDeque *deque); extern void *popLast(Queue_List_t *deque);
#ifdef __cplusplus #ifdef __cplusplus

72
lib/src/list/list.cpp
View File

@ -4,21 +4,21 @@
#include "list.h" #include "list.h"
void list_init(List *list) { void list_init(List_t *list) {
list->head = NULL; list->head = NULL;
list->tail = NULL; list->tail = NULL;
list->len = 0; list->len = 0;
} }
bool list_is_empty(List *list) { bool list_is_empty(List_t *list) {
return (list->head == NULL); return (list->head == NULL);
} }
static struct node *make_node(void *data) //把用户传递过来的数据打包为一个链表节点 static struct List_Node_t *make_node(void *data) //把用户传递过来的数据打包为一个链表节点
{ {
struct node *n; struct List_Node_t *n;
n = (struct node *) malloc(sizeof(struct node)); n = (struct List_Node_t *) malloc(sizeof(struct List_Node_t));
assert(n != NULL); assert(n != NULL);
n->next = NULL; n->next = NULL;
@ -27,9 +27,9 @@ static struct node *make_node(void *data) //把用户传递过来的数据打
return n; return n;
} }
void list_insert_at_head(List *list, void *data) //头插法 void list_insert_at_head(List_t *list, void *data) //头插法
{ {
struct node *n; struct List_Node_t *n;
n = make_node(data); n = make_node(data);
if (list->head == NULL) { //如果是空链表 if (list->head == NULL) { //如果是空链表
@ -42,10 +42,10 @@ void list_insert_at_head(List *list, void *data) //头插法
list->len++; list->len++;
} }
void list_insert_at_index(List *list, void *data, long index) //定插法 void list_insert_at_index(List_t *list, void *data, long index) //定插法
{ {
long i = 1; //从1开始算 long i = 1; //从1开始算
struct node *p, *n; struct List_Node_t *p, *n;
p = list->head; p = list->head;
@ -62,9 +62,9 @@ void list_insert_at_index(List *list, void *data, long index) //定插法
} }
} }
void list_insert_at_tail(List *list, void *data) //尾插法 void list_insert_at_tail(List_t *list, void *data) //尾插法
{ {
struct node *n; struct List_Node_t *n;
n = make_node(data); n = make_node(data);
if (list_is_empty(list)) { //如果是空链表 if (list_is_empty(list)) { //如果是空链表
@ -77,12 +77,12 @@ void list_insert_at_tail(List *list, void *data) //尾插法
list->len++; list->len++;
} }
//void list_insert(List *list, void *data) //默认采用尾插法 //void list_insert(List_t *list, void *data) //默认采用尾插法
//{ //{
//#if 0 //#if 0
// list_insert_at_tail(list, data); // list_insert_at_tail(list, data);
//#else //#else
// struct node *n; // struct List_Node_t *n;
// n = make_node(data); // n = make_node(data);
// if(list->head == NULL){ // if(list->head == NULL){
// list->head = n; // list->head = n;
@ -96,8 +96,8 @@ void list_insert_at_tail(List *list, void *data) //尾插法
//} //}
void list_insert(List *list, void *data) { void list_insert(List_t *list, void *data) {
struct node *n; struct List_Node_t *n;
n = make_node(data); n = make_node(data);
@ -111,9 +111,9 @@ void list_insert(List *list, void *data) {
list->len++; list->len++;
} }
void *list_delete(List *list, void *key, int (*compare)(const void *, const void *)) { void *list_delete(List_t *list, void *key, int (*compare)(const void *, const void *)) {
void *data; void *data;
struct node *n, *t; struct List_Node_t *n, *t;
n = list->head; n = list->head;
if (!compare(n->data, key)) { //如果要删除的节点为首节点 if (!compare(n->data, key)) { //如果要删除的节点为首节点
@ -142,8 +142,8 @@ void *list_delete(List *list, void *key, int (*compare)(const void *, const void
return NULL; //没找到匹配的节点，返回NULL return NULL; //没找到匹配的节点，返回NULL
} }
void *list_search(List *list, void *key, int (*compare)(const void *, const void *)) { void *list_search(List_t *list, void *key, int (*compare)(const void *, const void *)) {
struct node *n; struct List_Node_t *n;
n = list->head; n = list->head;
while (n) { while (n) {
@ -156,9 +156,9 @@ void *list_search(List *list, void *key, int (*compare)(const void *, const void
return NULL; //找不到，返回NULL return NULL; //找不到，返回NULL
} }
static struct node *find_min_node(List *list, static struct List_Node_t *find_min_node(List_t *list,
int (*compare)(const void *, const void *)) { int (*compare)(const void *, const void *)) {
struct node *min, *n; struct List_Node_t *min, *n;
n = list->head; n = list->head;
min = list->head; min = list->head;
@ -173,8 +173,8 @@ static struct node *find_min_node(List *list,
return min; return min;
} }
static void delete_node(List *list, struct node *key) { static void delete_node(List_t *list, struct List_Node_t *key) {
struct node *n; struct List_Node_t *n;
n = list->head; n = list->head;
@ -195,7 +195,7 @@ static void delete_node(List *list, struct node *key) {
} }
} }
static void insert_node(List *list, struct node *key) { static void insert_node(List_t *list, struct List_Node_t *key) {
if (list->head == NULL) { if (list->head == NULL) {
list->head = key; list->head = key;
list->tail = key; list->tail = key;
@ -205,10 +205,10 @@ static void insert_node(List *list, struct node *key) {
} }
} }
void list_sort(List *list, void list_sort(List_t *list,
int (*compare)(const void *, const void *)) { int (*compare)(const void *, const void *)) {
List tmp; List_t tmp;
struct node *n; struct List_Node_t *n;
list_init(&tmp); list_init(&tmp);
@ -222,8 +222,8 @@ void list_sort(List *list,
list->tail = tmp.tail; list->tail = tmp.tail;
} }
void list_traverse(List *list, void (*handle)(void *)) { void list_traverse(List_t *list, void (*handle)(void *)) {
struct node *p; struct List_Node_t *p;
p = list->head; p = list->head;
while (p) { while (p) {
@ -232,8 +232,8 @@ void list_traverse(List *list, void (*handle)(void *)) {
} }
} }
void list_reverse(List *list) { void list_reverse(List_t *list) {
struct node *pre = NULL, *next, *p = list->head; struct List_Node_t *pre = NULL, *next, *p = list->head;
list->tail = list->head; //tail指向head； list->tail = list->head; //tail指向head；
while (p) { while (p) {
@ -248,13 +248,13 @@ void list_reverse(List *list) {
} }
} }
long list_get_lenth(List *list) { long list_get_lenth(List_t *list) {
return (list->len); return (list->len);
} }
void *list_get_element(List *list, int idx) { void *list_get_element(List_t *list, int idx) {
int i = 1; int i = 1;
struct node *n; struct List_Node_t *n;
n = list->head; n = list->head;
while (n && i < idx) { while (n && i < idx) {
@ -269,9 +269,9 @@ void *list_get_element(List *list, int idx) {
return NULL; return NULL;
} }
void list_destroy(List *list, void (*destroy)(void *)) { void list_destroy(List_t *list, void (*destroy)(void *)) {
list->len = 0; list->len = 0;
struct node *n, *t; struct List_Node_t *n, *t;
n = list->head; n = list->head;
while (n) { while (n) {

101
lib/src/list/queue.cpp
View File

@ -1,136 +1,145 @@
#include <cstdlib> #include <cstdlib>
#include <cassert> #include <cassert>
#include <cstring>
#include <cstdio>
#include "queue.h" #include "queue.h"
DoublyListNode *newDoublyListNode(void *data) { static Queue_Node_t *newQueue_Node_t(void *data, unsigned char size) {
DoublyListNode *node = (DoublyListNode *) malloc(sizeof(DoublyListNode)); Queue_Node_t *node = (Queue_Node_t *) malloc(sizeof(Queue_Node_t));
node->val = data; node->val = malloc(size);
node->next = NULL; node->next = NULL;
node->prev = NULL; node->prev = NULL;
if (node->val == NULL) {
printf("Error allocating memory");
return NULL;
}
memcpy(node->val, data, size);
return node; return node;
} }
/* 析构函数 */ /* 析构函数 */
void delDoublyListNode(DoublyListNode *node) { static void delQueue_Node_t(Queue_Node_t *node) {
free(node->val);
free(node); free(node);
} }
/* 构造函数 */ /* 构造函数 */
LinkedListDeque *newLinkedListDeque() { Queue_List_t *newQueue_List(unsigned char size) {
LinkedListDeque *deque = (LinkedListDeque *) malloc(sizeof(LinkedListDeque)); Queue_List_t *deque = (Queue_List_t *) malloc(sizeof(Queue_List_t));
deque->front = NULL; deque->front = NULL;
deque->rear = NULL; deque->rear = NULL;
deque->queSize = 0; deque->queSize = 0;
deque->typeSize = size;
return deque; return deque;
} }
/* 析构函数 */ /* 析构函数 */
void delLinkedListdeque(LinkedListDeque *deque) { void delQueue_List(Queue_List_t *deque) {
// 释放所有节点 // 释放所有节点
for (int i = 0; i < deque->queSize && deque->front != NULL; i++) { for (int i = 0; i < deque->queSize && deque->front != NULL; i++) {
DoublyListNode *tmp = deque->front; Queue_Node_t *tmp = deque->front;
deque->front = deque->front->next; deque->front = deque->front->next;
free(tmp); delQueue_Node_t(tmp);
} }
// 释放 deque 结构体 // 释放 deque 结构体
free(deque); free(deque);
} }
/* 获取队列的长度 */ /* 获取队列的长度 */
int queue_size(LinkedListDeque *deque) { int queue_size(Queue_List_t *deque) {
return deque->queSize; return deque->queSize;
} }
/* 判断队列是否为空 */ /* 判断队列是否为空 */
bool queue_is_empty(LinkedListDeque *deque) { bool queue_is_empty(Queue_List_t *deque) {
return (queue_size(deque) == 0); return (queue_size(deque) == 0);
} }
/* 入队 */ /* 入队 */
void push(LinkedListDeque *deque, void *data, bool isFront) { static void push(Queue_List_t *deque, void *data, bool isFront) {
DoublyListNode *node = newDoublyListNode(data); Queue_Node_t *node = newQueue_Node_t(data, deque->typeSize);
// 若链表为空，则令 front 和 rear 都指向node if (node == NULL) {
printf("Error creating new node");
return;
}
if (queue_is_empty(deque)) { if (queue_is_empty(deque)) {
deque->front = deque->rear = node; deque->front = deque->rear = node;
} } else if (isFront) {
// 队首入队操作
else if (isFront) {
// 将 node 添加至链表头部
deque->front->prev = node; deque->front->prev = node;
node->next = deque->front; node->next = deque->front;
deque->front = node; // 更新头节点 deque->front = node;
} } else {
// 队尾入队操作
else {
// 将 node 添加至链表尾部
deque->rear->next = node; deque->rear->next = node;
node->prev = deque->rear; node->prev = deque->rear;
deque->rear = node; deque->rear = node;
} }
deque->queSize++; // 更新队列长度 deque->queSize++;
} }
/* 队首入队 */ /* 队首入队 */
void pushFirst(LinkedListDeque *deque, void *data) { void pushFirst(Queue_List_t *deque, void *data) {
push(deque, data, true); push(deque, data, true);
} }
/* 队尾入队 */ /* 队尾入队 */
void pushLast(LinkedListDeque *deque, void *data) { void pushLast(Queue_List_t *deque, void *data) {
push(deque, data, false); push(deque, data, false);
} }
/* 访问队首元素 */ /* 访问队首元素 */
void *peekFirst(LinkedListDeque *deque) { void *peekFirst(Queue_List_t *deque) {
assert(queue_size(deque) && deque->front); assert(queue_size(deque) && deque->front);
return deque->front->val; return deque->front->val;
} }
/* 访问队尾元素 */ /* 访问队尾元素 */
void *peekLast(LinkedListDeque *deque) { void *peekLast(Queue_List_t *deque) {
assert(queue_size(deque) && deque->rear); assert(queue_size(deque) && deque->rear);
return deque->rear->val; return deque->rear->val;
} }
/* 出队 */ /* 出队 */
void *pop(LinkedListDeque *deque, bool isFront) { static void *pop(Queue_List_t *deque, bool isFront) {
if (queue_is_empty(deque)) if (queue_is_empty(deque))
return nullptr; return NULL;
void *val;
// 队首出队操作 void *val = malloc(deque->typeSize);
if (val == nullptr) {
printf("Error allocating memory");
return NULL;
}
if (isFront) { if (isFront) {
val = peekFirst(deque); // 暂存头节点值 memcpy(val, deque->front->val, deque->typeSize);
DoublyListNode *fNext = deque->front->next; Queue_Node_t *fNext = deque->front->next;
if (fNext) { if (fNext) {
fNext->prev = NULL; fNext->prev = NULL;
deque->front->next = NULL; deque->front->next = NULL;
} }
delDoublyListNode(deque->front); delQueue_Node_t(deque->front);
deque->front = fNext; // 更新头节点 deque->front = fNext;
} } else {
// 队尾出队操作 memcpy(val, deque->rear->val, deque->typeSize);
else { Queue_Node_t *rPrev = deque->rear->prev;
val = peekLast(deque); // 暂存尾节点值
DoublyListNode *rPrev = deque->rear->prev;
if (rPrev) { if (rPrev) {
rPrev->next = NULL; rPrev->next = NULL;
deque->rear->prev = NULL; deque->rear->prev = NULL;
} }
delDoublyListNode(deque->rear); delQueue_Node_t(deque->rear);
deque->rear = rPrev; // 更新尾节点 deque->rear = rPrev;
} }
deque->queSize--; // 更新队列长度 deque->queSize--;
return val; return val;
} }
/* 队首出队 */ /* 队首出队 */
void *popFirst(LinkedListDeque *deque) { void *popFirst(Queue_List_t *deque) {
return pop(deque, true); return pop(deque, true);
} }
/* 队尾出队 */ /* 队尾出队 */
void *popLast(LinkedListDeque *deque) { void *popLast(Queue_List_t *deque) {
return pop(deque, false); return pop(deque, false);
} }

4
lib/src/tool.cpp
View File

@ -85,7 +85,7 @@ void Test_RunTime(char *name, void (*pFunction)()) {
cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("\nTime taken by %s: %f seconds\n", name, cpu_time_used);
printf("\n------< %s END >------\n", name); printf("\n------< %s END >------\n", name);
printf("\nTime taken by %s: %f seconds\n", name, cpu_time_used);
} }

3
main.c
View File

@ -22,6 +22,7 @@ int main() {
// Test_RunTime("IIC", Test_iic); // Test_RunTime("IIC", Test_iic);
// Test_RunTime("ArgPase", Test_argpase); // Test_RunTime("ArgPase", Test_argpase);
// Test_RunTime("Task", Test_task); // Test_RunTime("Task", Test_task);
Test_RunTime("List", Test_List); // Test_RunTime("List", Test_List);
Test_RunTime("Queue", Test_Queue);
return 0; return 0;
} }