UP

lib/inc/list/list.h

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

lib/inc/list/queue.h

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

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