Reuseable linked list implementation - c

Question

Hi I'm trying to implement a generic linked list. I've got something working using the following code but I can't see an obvious and neat way to remove the dependance on the global pointers (curr and root,) and thus allow multiple linked lists to be defined. If I were using c++ I would probably just wrap the whole thing in a class, but as it is I can only see one solution which is manually handling and passing root and curr to the functions that need them. I'm sure there is a better way than this so how would you go about this.
Thanks
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
struct Node{
int value;
struct Node *next;
};
struct Node * curr = NULL;
struct Node * root = NULL;
struct Node * createList(int val){
struct Node *n = malloc(sizeof(struct Node));
if(n==NULL){
printf("Node creation failed\n");
return NULL;
}
n->value = val;
n->next = NULL;
root=curr=n;
return n;
}
struct Node * extendList(int val, bool end){
if(curr == NULL){
return createList(val);
}
struct Node * newNode = malloc(sizeof(struct Node));
if(newNode==NULL){
printf("Node creation failed\n");
return NULL;
}
newNode->value = val;
newNode->next = NULL;
if(end){
curr->next = newNode;
curr = newNode;
}
else{
newNode->next = root;
root=newNode;
}
return curr;
}
void printList(void){
struct Node *ptr = root;
while(ptr!=NULL){
printf("%d\n",ptr->value);
ptr = ptr->next;
}
return;
}
struct Node * pos_in_list(unsigned int pos, struct Node **prev){
struct Node * ptr = root;
struct Node * tmp = NULL;
unsigned int i = 0;
while(ptr!=NULL){
if(i == pos){
break;
}
tmp = ptr;
ptr=ptr->next;
i++;
}
*prev = tmp;
return ptr;
}
void deletefromlist(int pos){
struct Node * del = NULL;
struct Node * prev = NULL;
del = pos_in_list(pos,&prev);
if(del == NULL)
{
printf("Out of range\n");
}
else
{
if(prev != NULL)
prev->next = del->next;
if(del == curr)
{
curr = prev;
}
else if(del == root)
{
root = del->next;
}
}
free(del);
del = NULL;
}
void deleteList(){
struct Node * del = root;
while(curr!=NULL){
curr = del->next;
free(del);
del=curr;
}
root = NULL;
curr = NULL;
}
int main(void)
{
int i;
for(i=0;i<10;i++){
extendList(i,true);
}
for(i=10;i>0;i--){
extendList(i,false);
}
printList();
deletefromlist(5);
printList();
deleteList();
return 0;
}

Answer 1

Create a Structure of Node * root and Node * curr
struct LinkedList{
struct Node * curr;
struct Node * next;
};

Answer 2

You can create another struct to hold the curr and root. This struct will function like a "linked-list object" frontend, while your node structs will be the backend. As an added benefit, you can store other attributes about the linked-list, like the number of elements in the list.
struct LinkedList {
int numElements;
struct Node * curr;
struct Node * root;
};
You can modify your functions to work with this struct, and once you are done, the benefit is that the end-user can create many linked-lists, and all they have to do is call the functions and pass in their pointers to the LinkedList struct.

Answer 3

The way this is usually done is by giving each function an argument for the linked list pointer. Like this:
struct Node * extendList(struct Node * head, int val, bool end){
if(head == NULL){
return createList(val);
}
struct Node * newNode = malloc(sizeof(struct Node));
if(newNode==NULL){
printf("Node creation failed\n");
return NULL;
}
newNode->value = val;
newNode->next = NULL;
struct Node * tail = head;
while (tail->next) tail = tail->next;
tail->next = newNode;
tail = newNode;
return newNode; // return the new node
}
Which removes any need for a global pointer and allows for an arbitrary number of lists. In fact, I would strongly advise you to avoid the use of global variables in this context.
I had submitted a review for a linked list implementation you can check out. You may want to check the criticisms to, the ones that may apply to your own implementation.

Answer 4

I have implemented a generic list in C.
It is intended to be used as a static library. List operations (on generic data) are exposed from a list service. As you have asked,
neat way to remove the dependance on the global pointers (head)
Defining multiple linked lists.
This list service accomplish both these features in following way,
Upon creating a new Linked list this service returns a unique identifier representing it instead of traditional Linked list head pointer. This way client code can't directly corrupt linked list. this list service allows creation of multiple linked lists. Each having unique id. It is upto client to free lists when they are done and service can re-use that slot later when creating a new one. Maintaining global head pointer for each list is mandatory in any approach, but here is it hidden inside list service.
Following is my implementation :
https://github.com/rajan-goswami/glist/wiki

Answer 5

Take a look at the Berkeley-derived generic implementations for some other ideas on how to do it.
Documentation queue(3)
Source OpenBSD, Linux libc