C doubly circular linked list library

Following is the code for doubly circular linked list :

You can enable the debug by commenting actual printf macro and dummy print_list :

#define printf(…)

struct node {
int val;
struct node *next, *prev;
};

typedef struct {
struct node *hd;
int num_ele;
} MyLinkedList;

MyLinkedList* myLinkedListCreate() {
MyLinkedList *list;
list = (MyLinkedList *)calloc(1, sizeof(MyLinkedList));
return list;
}

#ifdef DEBUG
void print_list(MyLinkedList* obj)
{
struct node *tmp = obj->hd;
int ii=0;

printf(“Number of elements in list %d\n”, obj->num_ele);
while (ii != obj->num_ele){
printf(“ii %d, ele val : %d\n”, ii++, tmp->val);
tmp = tmp->next;
}
tmp = obj->hd;
ii=0;
while (ii != obj->num_ele){
printf(“ii %d, ele val : %d\n”, ii++, tmp->val);
tmp = tmp->prev;
}
return;
}
#else
#define print_list(…)
#endif
int myLinkedListGet(MyLinkedList* obj, int index) {
int ii=0;
struct node *tmp = obj->hd;
printf(“%s(%d) index %d, num_ele %d\n”,__func__, __LINE__,index, obj->num_ele);
print_list(obj);
if (index >= obj->num_ele)
return -1;
while (ii++ != index) {
tmp = tmp->next;
}
printf(“%s(%d) ii %d, num_ele %d\n”,__func__, __LINE__,ii, obj->num_ele);
print_list(obj);
if ( ii == index+1)
return tmp->val;
return -1;
}

void myLinkedListAddAtHead(MyLinkedList* obj, int val) {
struct node *nd;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
nd = (struct node *)calloc(1, sizeof(struct node));
nd->val = val;
if (obj->hd)
{
if (!obj->hd->prev)
{
obj->hd->next = nd;
nd->prev = obj->hd;
}
else
{
nd->prev = obj->hd->prev;
obj->hd->prev->next = nd;
}
}
nd->next = obj->hd;
if (obj->hd)
obj->hd->prev = nd;
obj->hd = nd;
obj->num_ele ++;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
return;
}

void myLinkedListAddAtTail(MyLinkedList* obj, int val) {
struct node *nd;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
nd = (struct node *)calloc(1, sizeof(struct node));
nd->val = val;
obj->num_ele ++;
if (!obj->hd)
{
obj->hd = nd;
return;
}
if (!obj->hd->prev) {
nd->next = obj->hd;
obj->hd->prev = nd;
obj->hd->next = nd;
nd->prev = obj->hd;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
return;
}
nd->next = obj->hd->prev->next;
obj->hd->prev->next = nd;
nd->prev = obj->hd->prev;
obj->hd->prev = nd;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
return;
}

void myLinkedListAddAtIndex(MyLinkedList* obj, int index, int val) {
int ii=0;
struct node *tmp = obj->hd, *nd;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
if (index > obj->num_ele)
return;
if (!index) {
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
myLinkedListAddAtHead(obj, val);
return;
}
if (index == obj->num_ele){
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
myLinkedListAddAtTail(obj, val);
return;
}
while ((ii++ != index) && (tmp != NULL)){
printf(“%s(%d) ii %d, index %d tmp %p, obj->num_ele %d\n”, __func__,__LINE__, ii, index, tmp, obj->num_ele);
tmp = tmp->next;
}
printf(“%s(%d) ii %d, index %d tmp %p\n”, __func__,__LINE__, ii, index, tmp);
nd = (struct node *)calloc(1, sizeof(struct node));
nd->val = val;
nd->prev = tmp->prev;
nd->next = tmp;
tmp->prev->next = nd;
tmp->prev = nd;
obj->num_ele ++;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
return;

}

void myLinkedListDeleteAtIndex(MyLinkedList* obj, int index) {
int ii = 0;
struct node *node;
printf(“%s(%d) index %d\n”,__func__, __LINE__,index);
print_list(obj);
if (index >= obj->num_ele)
return;

if (index == 0){
if (!obj->hd)
return;
/* delete the first element */
node = obj->hd;
if (!obj->hd->next)
obj->hd = NULL;
else if (obj->hd->next->next == obj->hd) {
obj->hd = obj->hd->next;
obj->hd->next = obj->hd->prev = NULL;
} else {
obj->hd->next->prev = obj->hd->prev;
obj->hd->prev->next = obj->hd->next;
obj->hd = obj->hd->next;
}
obj->num_ele — ;
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
free(node);
return;
}
node = obj->hd;
printf(“node val %d, prev %p val %d, prev-next %p, val %d, nxt %p val %d\n”, node->val, node->prev, node->prev ? node->prev->val : 0xfffff, node->prev ? node->prev->next : NULL, node->prev ? node->prev->next->val : 0xffff, node->next, node->next ? node->next->val : 0xff);
do {
node = node->next;
}while ((ii++ != index-1) && (node != obj->hd));
printf(“node val %d, prev %p val %d, prev-next %p, val %d, nxt %p val %d\n”, node->val, node->prev, node->prev ? node->prev->val : 0xfffff, node->prev ? node->prev->next : NULL, node->prev ? node->prev->next->val : 0xffff, node->next, node->next ? node->next->val : 0xff);
node->prev->next = node->next;
node->next->prev = node->prev;
obj->num_ele — ;
free(node);
printf(“%s(%d)\n”,__func__, __LINE__);
print_list(obj);
return;
}

void myLinkedListFree(MyLinkedList* obj) {
struct node *tmp, *nxt;
tmp = obj->hd;
obj->hd = NULL;
while (obj->num_ele){
obj->num_ele — ;
nxt = tmp->next;
free(tmp);
tmp = nxt;
}
return;
}