这里实现的链表是内核链表的一个简单优化，在内核链表中next指针放在数据的尾部，定位指针域需要计算偏移量，增加了处理难度。优化后将next指针放在数据块的开头，免去了偏移量的计算。 

头文件：

#ifndef LINKLIST_H
#define LINKLIST_H

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

//挂钩
typedef struct LINKNODE {
	struct LINKNODE* next;
}LinkNode;

//链表节点
typedef struct LINKLIST{
	LinkNode head;
	int size;
}LinkList;

//遍历函数指针
typedef void(*PRINTNODE)(LinkNode*);
//比较函数指针
//返回-1代表未找到，0代表找到
typedef int(*COMPARENODE)(LinkNode*, LinkNode*);


//初始化链表
LinkList* initList();
//插入
void insertList(LinkList* list, int pos, LinkNode* data);
//根据位置删除
void removeByPos(LinkList* list, int pos);
//查找
int findList(LinkList* list, LinkNode* data, COMPARENODE compare);
//返回链表大小
int size(LinkList* list);
//打印
void printList(LinkList* list, PRINTNODE print);
//释放链表内存
void freeSpace(LinkList* list);

#endif

 实现部分：

#include "LinkList.h"

//初始化链表
LinkList* initList() {
	LinkList* list = (LinkList*)malloc(sizeof(LinkList));
	list->head.next = NULL;
	list->size = 0;
	return list;
}

//插入
void insertList(LinkList* list, int pos, LinkNode* data) {
	if (list == NULL) {
		return;
	}
	if (data == NULL) {
		return;
	}
	//友好处理，如果需要插入的位置不在范围内，直接插入到链表尾部
	if (pos < 0 || pos >= list->size) {
		pos = list->size;
	}
	//查找插入位置的前驱
	LinkNode* pCurrent = &(list->head);
	for (int i = 0; i < pos; i++) {
		pCurrent = pCurrent->next;
	}

	//插入新节点
	data->next = pCurrent->next;
	pCurrent->next = data;
	list->size++;
}

//根据位置删除
void removeByPos(LinkList* list, int pos) {
	if (list == NULL) {
		return;
	}
    if (pos < 0 || pos >= list->size) {
		return;
	}

	//查找待删除节点的前驱
	LinkNode* pCurrent = &(list->head);
	for (int i = 0; i < pos; i++) {
		pCurrent = pCurrent->next;
	}
	
	//因为这里没有申请内存，所以不用释放
	pCurrent->next = pCurrent->next->next;
	list->size--;
}

//查找
int findList(LinkList* list, LinkNode* data, COMPARENODE compare) {
	if (list == NULL) {
		return -1;
	}
	if (data == NULL) {
		return -1;
	}
	//这里先给到第一个有数据的节点
	LinkNode* pCurrent = list->head.next;
	int pos = 0;
	int flag = -1; //定义是否查找到，起初没查找到，就设置位置为-1
	while (pCurrent != NULL) {
		if (compare(pCurrent, data) == 0) {
			flag = pos;
			break;
		}
		pCurrent = pCurrent->next;
		pos++;
	}
	return flag;
}

//返回链表大小
int size(LinkList* list) {
	if (list == NULL) {
		return -1;
	}
	return list->size;
}

//打印
void printList(LinkList* list, PRINTNODE print) {
	if (list == NULL) {
		return;
	}

	//辅助指针
	LinkNode* pCurrent = list->head.next;
	while (pCurrent != NULL) {
		print(pCurrent);
		pCurrent = pCurrent->next;
	}
}

//释放链表内存
void freeSpace(LinkList* list) {
	if (list == NULL) {
		return;
	}
	free(list);
}

测试部分：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "LinkList.h"

typedef struct PERSON {
	//相当于挂钩
	LinkNode node; //每次链接数据时，就把node连接起来就可以
	char name[64];
	int age;
}Person;

//回调函数实现
void MyPrint(void* data) {
	Person* person = (Person*)data;
	printf("name: %s, age: %d\n", person->name, person->age);
}

int MyCompare(LinkNode* node1, LinkNode* node2) {
	Person* p1 = (Person*)node1;
	Person* p2 = (Person*)node2;

	if (strcmp(p1->name, p2->name) == 0 && p1->age == p2->age) {
		return 0;
	}

	return -1;
}

void test() {
	//创建链表
	LinkList* list = initList();

	//创建数据
	Person p1, p2, p3, p4, p5;
	strcpy(p1.name, "aaa");
	strcpy(p2.name, "bbb");
	strcpy(p3.name, "ccc");
	strcpy(p4.name, "ddd");
	strcpy(p5.name, "eee");
	p1.age = 10;
	p2.age = 20;
	p3.age = 30;
	p4.age = 40;
	p5.age = 50;
	printf("size: %d\n", list->size);

	//将节点插入到链表
	insertList(list, 0, (LinkNode*)&p1);
	insertList(list, 0, (LinkNode*)&p2);
	insertList(list, 0, (LinkNode*)&p3);
	insertList(list, 0, (LinkNode*)&p4);
	insertList(list, 0, (LinkNode*)&p5);
	printf("size: %d\n", list->size);
	//打印链表
	printList(list, MyPrint);

	//删除节点
	removeByPos(list, 2);
	printf("========================\n");

	//查找
	Person findP;
	strcpy(findP.name, "bbb");
	findP.age = 20;
	int pos = findList(list, (LinkNode*)&findP, MyCompare);
	printf("查找到的位置为： %d\n", pos);

	//打印链表
	printList(list, MyPrint);
}

int main(void) {
	test();
	return 0;
}

注意事项：

自定义数据使用通用链表的时候，需要加 LinkNode node参数，原因：

• 其实就是C语言里面的强制类型转换，把一个LinkNode节点放在首个元素位置方便强转后定位next指针