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_Queue();
#endif //HW_LIB_T_LIST_H

90
demo/list/test.c
View File

@ -2,6 +2,7 @@
#include <stdio.h>
#include "list.h"
#include "queue.h"
typedef struct test {
int val1;
@ -27,7 +28,7 @@ int compare_int_sort(const void *s1, const void *s2) {
return (data1->val1 - data2->val1);
}
void print(List *list) {
void print(List_t *list) {
printf("list len = %ld\n", list_get_lenth(list));
if (!list_is_empty(list)) {
//test list_reverse
@ -38,66 +39,83 @@ void print(List *list) {
}
void Test_List() {
List list;
list_init(&list);
List_t list;
list_init(&list); // 初始化链表
test_t test1 = {10, 10.5};
test_t test2 = {20, 20.5};
test_t test3 = {30, 30.5};
test_t test4 = {40, 40.5};
test_t test5 = {50, 50.5};
//test list_insert
// 测试插入操作
printf("------insert(_at_tail)----\n");
list_insert(&list, &test1);
list_insert(&list, &test2);
list_insert(&list, &test3);
print(&list);
list_insert(&list, &test1); // 在尾部插入test1
list_insert(&list, &test2); // 在尾部插入test2
list_insert(&list, &test3); // 在尾部插入test3
print(&list); // 打印链表
//test list_delete
// 测试删除操作
printf("------delete----\n");
list_delete(&list, &test1.val1, compare_int);
print(&list);
list_delete(&list, &test1.val1, compare_int); // 删除值为test1.val1的节点
print(&list); // 打印链表
//test list_insert_at_head
// 测试在头部插入操作
printf("------insert_at_head----\n");
list_insert_at_head(&list, &test4);
print(&list);
list_insert_at_head(&list, &test4); // 在头部插入test4
print(&list); // 打印链表
//test list_insert_at_index
// 测试在指定位置插入操作
printf("------insert_at_index(2)----\n");
list_insert_at_index(&list, &test5, 2);
print(&list);
list_insert_at_index(&list, &test5, 2); // 在索引2处插入test5
print(&list); // 打印链表
//test list_reverse
// 测试链表反转操作
printf("------reverse----\n");
list_reverse(&list);
print(&list);
list_reverse(&list); // 反转链表
print(&list); // 打印链表
//test list_search
// 测试搜索操作
int key = 20;
test_t *ret;
printf("------search----\n");
ret = list_search(&list, &key, compare_int);
printf("%d:%f\n", ret->val1, ret->val2);
ret = list_search(&list, &key, compare_int); // 搜索值为key的节点
printf("%d:%f\n", ret->val1, ret->val2); // 打印搜索结果
key = 50;
ret = list_search(&list, &key, compare_int);
printf("%d:%f\n", ret->val1, ret->val2);
ret = list_search(&list, &key, compare_int); // 搜索值为key的节点
printf("%d:%f\n", ret->val1, ret->val2); // 打印搜索结果
//test list_get_element
// 测试获取指定位置元素操作
printf("------list_get_element----\n");
ret = list_get_element(&list, 2);
printf("%d:%f\n", ret->val1, ret->val2);
ret = list_get_element(&list, 3);
printf("%d:%f\n", ret->val1, ret->val2);
ret = list_get_element(&list, 2); // 获取索引为2的元素
printf("%d:%f\n", ret->val1, ret->val2); // 打印获取的元素
ret = list_get_element(&list, 3); // 获取索引为3的元素
printf("%d:%f\n", ret->val1, ret->val2); // 打印获取的元素
//test list_sort
// 测试排序操作
printf("-----sort----\n");
list_sort(&list, compare_int_sort);
print(&list);
list_sort(&list, compare_int_sort); // 按照整数值排序
print(&list); // 打印排序后的链表
//test list_destroy
// 测试销毁操作
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
#define HW_LIB_LIST_H
#ifdef __cplusplus
@ -6,59 +7,59 @@ extern "C" {
#include <stdbool.h>
typedef struct node { //节点结构
typedef struct List_Node_t { //节点结构
void *data;
struct node *next;
} node;
struct List_Node_t *next;
} List_Node_t;
typedef struct { //链表结构
struct node *head;
struct node *tail;
struct List_Node_t *head;
struct List_Node_t *tail;
long len;
} List;
} List_t;
/**
* @brief 初始化链表
* @param list: [输入] 链表指针
* @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 检查链表是否为空
* @param list: [输入] 链表指针
* @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 在链表尾部插入元素
* @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针
* @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 在链表头部插入元素
* @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针
* @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 在链表尾部插入元素
* @param list: [输入] 链表指针
* @param data: [输入] 待插入的数据指针
* @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 在指定位置插入元素
@ -66,9 +67,9 @@ extern void list_insert_at_tail(List *list, void *data);
* @param data: [输入] 待插入的数据指针
* @param idx: [输入] 插入位置索引
* @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 删除链表中指定元素
@ -76,9 +77,9 @@ extern void list_insert_at_index(List *list, void *data, long idx);
* @param key: [输入] 待删除的数据指针
* @param compare: [输入] 比较函数指针
* @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 在链表中查找指定元素
@ -86,61 +87,61 @@ extern void *list_delete(List *list, void *key, int (*compare)(const void *, con
* @param key: [输入] 待查找的数据指针
* @param compare: [输入] 比较函数指针
* @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 对链表进行排序
* @param list: [输入] 链表指针
* @param compare: [输入] 比较函数指针
* @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 遍历链表并对每个元素执行指定操作
* @param list: [输入] 链表指针
* @param handle: [输入] 处理函数指针
* @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 反转链表
* @param list: [输入] 链表指针
* @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 获取链表长度
* @param list: [输入] 链表指针
* @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 获取链表指定位置的元素
* @param list: [输入] 链表指针
* @param idx: [输入] 元素索引
* @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 销毁链表
* @param list: [输入] 链表指针
* @param destroy: [输入] 数据销毁函数指针
* @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
}

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

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

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

@ -4,21 +4,21 @@
#include "list.h"
void list_init(List *list) {
void list_init(List_t *list) {
list->head = NULL;
list->tail = NULL;
list->len = 0;
}
bool list_is_empty(List *list) {
bool list_is_empty(List_t *list) {
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);
n->next = NULL;
@ -27,9 +27,9 @@ static struct node *make_node(void *data) //把用户传递过来的数据打
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);
if (list->head == NULL) { //如果是空链表
@ -42,10 +42,10 @@ void list_insert_at_head(List *list, void *data) //头插法
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开始算
struct node *p, *n;
struct List_Node_t *p, *n;
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);
if (list_is_empty(list)) { //如果是空链表
@ -77,12 +77,12 @@ void list_insert_at_tail(List *list, void *data) //尾插法
list->len++;
}
//void list_insert(List *list, void *data) //默认采用尾插法
//void list_insert(List_t *list, void *data) //默认采用尾插法
//{
//#if 0
// list_insert_at_tail(list, data);
//#else
// struct node *n;
// struct List_Node_t *n;
// n = make_node(data);
// if(list->head == NULL){
// list->head = n;
@ -96,8 +96,8 @@ void list_insert_at_tail(List *list, void *data) //尾插法
//}
void list_insert(List *list, void *data) {
struct node *n;
void list_insert(List_t *list, void *data) {
struct List_Node_t *n;
n = make_node(data);
@ -111,9 +111,9 @@ void list_insert(List *list, void *data) {
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;
struct node *n, *t;
struct List_Node_t *n, *t;
n = list->head;
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
}
void *list_search(List *list, void *key, int (*compare)(const void *, const void *)) {
struct node *n;
void *list_search(List_t *list, void *key, int (*compare)(const void *, const void *)) {
struct List_Node_t *n;
n = list->head;
while (n) {
@ -156,9 +156,9 @@ void *list_search(List *list, void *key, int (*compare)(const void *, const void
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 *)) {
struct node *min, *n;
struct List_Node_t *min, *n;
n = list->head;
min = list->head;
@ -173,8 +173,8 @@ static struct node *find_min_node(List *list,
return min;
}
static void delete_node(List *list, struct node *key) {
struct node *n;
static void delete_node(List_t *list, struct List_Node_t *key) {
struct List_Node_t *n;
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) {
list->head = 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 *)) {
List tmp;
struct node *n;
List_t tmp;
struct List_Node_t *n;
list_init(&tmp);
@ -222,8 +222,8 @@ void list_sort(List *list,
list->tail = tmp.tail;
}
void list_traverse(List *list, void (*handle)(void *)) {
struct node *p;
void list_traverse(List_t *list, void (*handle)(void *)) {
struct List_Node_t *p;
p = list->head;
while (p) {
@ -232,8 +232,8 @@ void list_traverse(List *list, void (*handle)(void *)) {
}
}
void list_reverse(List *list) {
struct node *pre = NULL, *next, *p = list->head;
void list_reverse(List_t *list) {
struct List_Node_t *pre = NULL, *next, *p = list->head;
list->tail = list->head; //tail指向head；
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);
}
void *list_get_element(List *list, int idx) {
void *list_get_element(List_t *list, int idx) {
int i = 1;
struct node *n;
struct List_Node_t *n;
n = list->head;
while (n && i < idx) {
@ -269,9 +269,9 @@ void *list_get_element(List *list, int idx) {
return NULL;
}
void list_destroy(List *list, void (*destroy)(void *)) {
void list_destroy(List_t *list, void (*destroy)(void *)) {
list->len = 0;
struct node *n, *t;
struct List_Node_t *n, *t;
n = list->head;
while (n) {

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

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