Создать двусвязный циклический список

#include <iostream>
#include <clocale>
#include <iomanip>
#include <ctime>
using namespace std;
 
typedef struct _Node {
    void* value;
    struct _Node* next;
    struct _Node* prev;
} Node;
 
 
typedef struct _DblLinkedList {
    size_t size;
    Node* head;
    Node* tail;
} DblLinkedList;
 
DblLinkedList* createDblLinkedList() {
    DblLinkedList* tmp = (DblLinkedList*)malloc(sizeof(DblLinkedList));
    tmp->size = 0;
    tmp->head = tmp->tail = NULL;
 
    return tmp;
}
 
 
void pushFront(DblLinkedList* list, void* data) {
    Node* tmp = (Node*)malloc(sizeof(Node));
    if (tmp == NULL) {
        exit(1);
    }
    tmp->value = data;
    tmp->next = list->head;
    tmp->prev = NULL;
    if (list->head) {
        list->head->prev = tmp;
    }
    list->head = tmp;
 
    if (list->tail == NULL) {
        list->tail = tmp;
    }
    list->size++;
}
 
void* popFront(DblLinkedList* list) {
    Node* prev;
    void* tmp;
    if (list->head == NULL) {
        exit(2);
    }
 
    prev = list->head;
    list->head = list->head->next;
    if (list->head) {
        list->head->prev = NULL;
    }
    if (prev == list->tail) {
        list->tail = NULL;
    }
    tmp = prev->value;
    free(prev);
 
    list->size--;
    return tmp;
}
 
void pushBack(DblLinkedList* list, void* value) {
    Node* tmp = (Node*)malloc(sizeof(Node));
    if (tmp == NULL) {
        exit(3);
    }
    tmp->value = value;
    tmp->next = NULL;
    tmp->prev = list->tail;
    if (list->tail) {
        list->tail->next = tmp;
    }
    list->tail = tmp;
 
    if (list->head == NULL) {
        list->head = tmp;
    }
    list->size++;
}
 
void insertBeforeElement(DblLinkedList* list, Node* elm, void* value) {
    Node* ins = NULL;
    if (elm == NULL) {
        exit(6);
    }
 
    if (!elm->prev) {
        pushFront(list, value);
        return;
    }
    ins = (Node*)malloc(sizeof(Node));
    ins->value = value;
    ins->prev = elm->prev;
    elm->prev->next = ins;
    ins->next = elm;
    elm->prev = ins;
 
    list->size++;
}
 
void insertionSort(DblLinkedList** list, int (*cmp)(void*, void*)) {
    DblLinkedList* out = createDblLinkedList();
    Node* sorted = NULL;
    Node* unsorted = NULL;
 
    pushFront(out, popFront(*list));
 
    unsorted = (*list)->head;
    while (unsorted) {
        sorted = out->head;
        while (sorted && !cmp(unsorted->value, sorted->value)) {
            sorted = sorted->next;
        }
        if (sorted) {
            insertBeforeElement(out, sorted, unsorted->value);
        }
        else {
            pushBack(out, unsorted->value);
        }
        unsorted = unsorted->next;
    }
 
    free(*list);
    *list = out;
}
 
void printDblLinkedList(DblLinkedList* list, void (*fun)(void*)) {
    Node* tmp = list->head;
    while (tmp) {
        fun(tmp->value);
        tmp = tmp->next;
    }
    printf("\n");
}
 
void printInt(void* value) {
    printf("%d ", *((int*)value));
}
 
void printFloat(void* value) {
    printf("%f ", *((float*)value));
}
 
int compareInt(void* a, void* b) {
    //return *(int*)a - *(int*)b;
    if (* (int*)a > * (int*)b)
        return *(int*)a;
    else return *(int*)b;
}
 
int main()
{
    setlocale(LC_ALL, "Russian");
    DblLinkedList* list = createDblLinkedList();
    float o, j, k;   
    int a, b, c, d, e, f, g, h;
    a = -98;
    b = 9;
    c = 3;
    d = -42;
    e = 21;
    f = 129;
    pushFront(list, &c);
    pushBack(list, &d);
    pushFront(list, &b);
    pushFront(list, &a);
    pushBack(list, &e);
    pushBack(list, &f);
    printf("Задаем список: \n");
    printDblLinkedList(list, printInt);
    printf("Вставка сортировок: \n");
    insertionSort(&list, compareInt);
    printDblLinkedList(list, printInt);
}