通用链表（C语言实现）

用c语言实现的一份通用链表，包含了链表的创建，添加，删除，插入，查找，遍历。

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

// 定义函数指针类型
typedef int (*compar)(const void* p1, const void* p2);

//设计链表节点
typedef struct Node
{    
	void* ptr; //指向数据的首地址    
	struct Node* next; // 元素的下一个位置
}Node;

// 设计链表
typedef struct List
{    
	Node* head;    //指向头节点的指针
	size_t size;	//记录链表长度
}List;

// 创建节点
Node* create_node(void* ptr)
{    
	Node* node = malloc(sizeof(Node)); //为节点申请一块内存
	node->ptr = ptr; // 将节点数据域指针指向数据
	node->next = NULL; //将节点的next指向空
	return node; //返回节点
}

// 创建链表
List* create_list(void)
{    
	List* list = malloc(sizeof(List)); // 为链表申请一块内存
	list->head = NULL; // 将头指针指向空
	list->size = 0; // 将链表节点数量赋值为0
	return list; //返回链表
}

// 销毁链表
void destory_list(List* list)
{    
	while(del_head_list(list)); // 调用头删除，删除所有节点    
	free(list); // 释放存放链表的内存
}

//头部添加
void add_head_list(List* list, void* ptr)
{    
	Node* node = create_node(ptr); // 创建一个节点
	node->next = list->head; // 将节点的next指针指向当前链表的头结点
	list->head = node; // 将头结点指针指向node，现在node为链表的头结点
	list->size ++; // 链表节点数加1
}

// 尾部添加
void add_tail_list(List* list, void* ptr)
{
	if(!list->size) // 如果链表节点数为0，就相当于是头部添加，调用头部添加函数即可
		add_head_list(list, ptr);    
	else     
	{
		Node* tail = list->head; // 定义一个结构体指针tail，指向头结点
		while(NULL != tail->next) tail=tail->next; // 遍历链表，使tail指针指向链表的最后一个结点
		Node* node = create_node(ptr); //创建一个结点
		tail->next = node; // 将链表最后一个结点的next指针指向要添加的结点node   
	}    
	list->size ++; //链表结点数量加1
}

// 头部删除
bool del_head_list(List* list)
{
	if(0 == list->size) return false; // 如果链表为空，则删除失败
	Node* node = list->head; // 定义一个结点指向头结点
	if(1 == list->size) // 如果链表中只有一个结点，则删除这个结点后，得把头指针指向空
		list->head = NULL;
	else // 如果不止一个结点，则把头指针指向头结点的下一个结点 
		list->head = list->head->next;
	free(node); //释放原先的头结点，因为上面定义了node指向原先的头结点，所以释放node指向的结点就行。
	list->size --; // 链表结点数量减1
	return true; // 返回一个真值
}

// 尾部删除
bool del_tail_list(List* list)
{
	if(0 == list->size) return false; // 如果链表为空，则删除失败
	if(1 == list->size) // 如果链表中只有一个元素，则删除该结点后，头指针需要指向空   
	{
    		free(list->head);        
    		list->head = NULL;   
	}    
	else
	{    
		Node* node = list->head; // 定义一个结构体指针指向头结点            
		while(NULL != node->next->next) // 遍历链表使node指针指向链表最后一个结点的前一个结点
			node = node->next;    
		free(node->next); // 释放node指针所指向的结点的下一个结点，也就是链表的最后一个结点
		node->next = NULL; // 将node指针所指向的结点（也就是现在链表的最后一个结点）的next指向空
	}    
	list->size --; // 链表结点数量减1
	return true;
}

// 从index位置前插入元素（index从0开始计算）
bool insert_list(List* list, int index, void* ptr)
{
	if(index < 0 || index >= list->size) return false; // 如果插入位置小于0或者大于链表结点数，则插入失败    
	if(0 == index) // 如果插入位置为0，则相当于头添加，调用头部添加函数即可
	{
		add_head_list(list, ptr);
	}    
	else    
	{        
		Node* node = create_node(ptr); //创建一结点        
		Node* p = list->head; // 定义一个结构体指针p指向头结点
		for(int i=0; i<index-1; i++) // 循环index-1次，使p指向要插入位置的前一个结点
		{            
			p = p->next;        
		}        
		node->next = p->next; // 将要插入的结点的next指针指向要插入的位置的结点，也就是p所指向的结点的next指针所指向的结点
		p->next = node; // 然后再将p所指向的结点的next指针指向node，这样node结点就插入完成      
		list->size ++; // 链表结点数加1    
	}    
	return true;
}

// 访问index元素
void* access_list(List* list, int index)
{    
	if(index < 0 || index >= list->size) return NULL;// 如果访问的位置小于0或者大于链表的长度，则访问失败
	Node* node = list->head; // 定义一个结构体指针node指向头结点 
	for(int i=0; i<index; i++) // 循环index次，使node指针指向要访问的结点
	{        
		node = node->next;    
	}    
	return node->ptr; // 返回要访问的结点的数据域
}

// 按位置删除元素
bool del_index_list(List* list, int index)
{
	if(index < 0 || index >= list->size) return false; // 如果要删除的位置小于0或者大于链表的长度，则删除失败
	if(0 == index) 
		del_head_list(list)； // 如果位置为0，则等价于删除头结点，调用头部删除即可
	else if(list->size - 1 == index) // 如果要删除的结点位/置为最后一个，则等价于删除尾结点，调用尾部删除函数即可
		del_tail_list(list);
	else
	{           
    		Node* node = list->head; // 定义一个结构体指针指向链表的头部
    		for(int i=0; i<index-1; i++) //循环遍历至要删除的结点的前一个
    		{            
    			node = node->next;        
    		}        
    		Node* temp = node->next; // 定义一个结构体指针指向要删除的结点
    		node->next = temp->next; // 将要删除的结点的前一个结点的next指针指向要删除的结点的下一个结点
    		free(temp); //释放要删除的结点        
    		list->size --; // 链表结点数减1 
	}    
	return true;
}

// 遍历链表，并显示
void show_list(List* list, void (*show)(void* ptr)) 
{
	for(Node* i=list->head; NULL!=i; i=i->next)   
	{
		show(i->ptr); //调用回调函数显示结点    
	}   
	printf("\n");
}

// 回调函数
void show(void* ptr)
{    
	double* p = ptr; // 将ptr的类型转换为double类型的指针
	printf("%lf\n", *p);
}

// 主函数
int main()
{    
	List* list = create_list();    
	double arr[] = {1, 2, 9, 4, 5, 7, 6, 8, 3, 10};    
	for(int i=0; i<10; i++)    
	{        
		add_tail_list(list, arr+i);    
	}    
	show_list(list, show);
	return 0;
}