범용 싱글 리스트

//main.c
#include <stdio.h>
#include <stdlib.h>
#include "list.h"

void printInt(const void *pData)
{
	printf("%d",*(int*)pData);
}

void printDouble(const void *pData)
{
	printf("%f",*(double*)pData);
}

int main(void)
{
	list_t list1, list2;
	initList(&list1, sizeof(int));
	initList(&list2, sizeof(double));

	int i=10;		insertFirstNode(&list1,&i);
	int j = 40;		insertNode(&list1,&i,&j);
	j = 30;			insertNode(&list1,&i,&j);
	j = 20;			insertNode(&list1,&i,&j);
	printList(&list1,printInt);	// { 10, 20, 30, 40}
	
	double x=1.1;		insertFirstNode(&list2,&x);
	double y = 4.4;		insertNode(&list2,&x,&y);
	y = 3.3;		insertNode(&list2,&x,&y);
	y = 2.2;		insertNode(&list2,&x,&y);
	printList(&list2,printDouble);	// { 1.1, 2.2, 3.3, 4.4}

	j=30;
	deleteNode(&list1, &j);
	printList(&list1,printInt);

	y=3.3;
	deleteNode(&list2, &y);
	printList(&list2,printDouble);

	cleanupList(&list1);
	cleanupList(&list2);


	return 0;
}

//list.c
#include "list.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void initList(list_t *pList, int element_size)
{
	pList->ptr = malloc(sizeof(list_t));
	pList->ptr->next = NULL;
	pList->element_size = element_size;
}
void cleanupList(list_t *pList)
{
	node_t *ptr = pList->ptr;
	while(ptr)
	{
		node_t *tmp = ptr;
		ptr = ptr->next;
		free(tmp);
	}
	pList->ptr = NULL;
}
void printList(const list_t *pList, void (*print)(const void*))
{
	node_t *ptr;
	if(pList->ptr)
		ptr = pList->ptr->next;
	else
		ptr = NULL;

	while(ptr)
	{
		print(ptr+1);
		printf(" ");
		ptr = ptr->next;
	}
	printf("\n");
}

void insertFirstNode(list_t *pList, const void *pData)
{
	node_t *tmp = malloc(sizeof(node_t)+pList->element_size);

	memcpy(tmp +1 ,pData,pList->element_size);
	tmp->next = pList->ptr->next;
	pList->ptr->next = tmp;
}
void insertNode(list_t *pList, const void *pPrevData, const void *pData)
{
	node_t *ptr = pList->ptr->next;
	while(ptr)
	{
		if(memcmp(ptr+1,pPrevData,pList->element_size) == 0)
			break;
		ptr = ptr->next;
	}
	if(ptr)
	{
		node_t *tmp = malloc(sizeof(node_t));
		memcpy(tmp+1,pData,pList->element_size);
		tmp->next = ptr->next;
		ptr->next = tmp;
	}
}
void deleteNode(list_t *pList, const void *pData)
{
	node_t *ptr1 = pList->ptr->next;
	node_t *ptr2 = pList->ptr;

	while(ptr1)
	{
		if(memcmp(ptr1 + 1, pData, pList->element_size) == 0)
			break;
		ptr1=ptr1->next;
		ptr2=ptr2->next;
	}

	if(ptr1)
	{
		ptr2->next = ptr1->next;
		free(ptr1);
	}
}

//list.h
#ifndef LIST_H
#define LIST_H

typedef struct node{
	struct node* next;
}node_t;

typedef struct {
	node_t *ptr;
	int element_size;
}list_t;

void initList(list_t *pListi, int element_size);
void cleanupList(list_t *pList);
void printList(const list_t *pList,void (*print)(const void*));

void insertFirstNode(list_t *pList, const void *pData);
void insertNode(list_t *pList, const void *pPrevData, const void *pData);
void deleteNode(list_t *pList, const void *pData);

#endif // end of list.h