UP

lib/src/list/list.cpp

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

lib/src/list/queue.cpp

@@ -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);
 }

lib/src/tool.cpp

@@ -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);
 }