浅析链表结构

一、单向链表

C语言中数组是常用的一种数据类型，但可惜数组长度是固定大小的，不能动态扩展，使用起来有时不是很方便。然后就有了自定义的动态数组结构，动态数组就比较好用了，长度可以任意扩展，但还有一个问题不好解决，就是每次插入数据时，数组后面的数据都得乾坤大挪移一回，如果数组长度较大的话效率就比较低了。再然后就有了链表结构的出现。链表的原理如下图所示：

具体代码如下：

cpp 复制代码

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

// 链表中节点结构体
typedef struct _stu_linkNode
{
	void* data;						// 本节点存储的数据（由于不知道本节点中要存储何种类型数据，因此用万能指针void*来代表所有数据类型包括自定义类型。）
	struct _stu_linkNode* next;		// 下个节点的地址
} stu_linkNode;


// 链表结构体
typedef struct _stu_linkList
{
	stu_linkNode head;		// 链表头节点
	int size;				// 链表长度
} stu_linkList;

// 用万能指针来代替链表结构体，这是封装的关键
typedef void* linkList;

// 链表初始化
linkList linkListInit()
{
	// 在堆区开辟链表
	stu_linkList* pList = (stu_linkList*)malloc(sizeof(stu_linkList));
	if (pList == NULL) { return NULL; }
	
	// 设置初始大小
	pList->head.data = NULL;
	pList->head.next = NULL;
	pList->size = 0;

	return pList;
}

// 链表指定位置插入
void linkListInsert(linkList ll, int pos, void* val)
{
	if (ll == NULL) { return; }
	if (val == NULL) { return; }
	stu_linkList* pList = (stu_linkList*)ll;					// 强制转换
	if (pos < 0 || pos > pList->size) { pos = pList->size; }	// 位置不正确则默认尾插

	// 找到pos位置所在节点的前驱节点
	stu_linkNode* prevNode = &pList->head;	// 定义节点变量指向头节点（如果链表为空则前驱节点就是头节点）
	for (int i = 0; i < pos; i++)			// 循环改变节点变量指向，直至pos位置所在节点的前驱节点
	{
		prevNode = prevNode->next;			// 重点：prevNode是当前节点的指针地址，prevNode->next是下一个节点的指针地址
	}

	// 创建要插入的新节点
	stu_linkNode* newNode = (stu_linkNode*)malloc(sizeof(stu_linkNode));
	if (newNode == NULL) { return; }
	newNode->data = val;
	newNode->next = NULL;

	// 将新节点插入到链表中
	newNode->next = prevNode->next;
	prevNode->next = newNode;

	// 更新链表大小
	pList->size++;
}

// 链表尾插法
void linkListPushBack(linkList ll, void* val)
{
	if (ll == NULL) { return; }
	if (val == NULL) { return; }
	stu_linkList* pList = (stu_linkList*)ll;					// 强制转换
	linkListInsert(ll, pList->size, val);
}

// 链表指定位置删除
void linkListErase(linkList ll, int pos)
{
	if (ll == NULL) { return; }
	stu_linkList* pList = (stu_linkList*)ll;					// 强制转换
	if (pos < 0 || pos > pList->size - 1) { return; }			// 位置不正确则返回

	// 找到pos位置所在节点的前驱节点
	stu_linkNode* prevNode = &pList->head;
	for (int i = 0; i < pos; i++)
	{
		prevNode = prevNode->next;
	}
	
	// 得到当前pos所在节点
	stu_linkNode* delNode = prevNode->next;
	
	// 开始删除
	prevNode->next = delNode->next;
	free(delNode);
	delNode = NULL;
	
	// 更新元素大小
	pList->size--;
}

// 链表尾删法
void linkListPopBack(linkList ll)
{
	if (ll == NULL) { return; }
	stu_linkList* pList = (stu_linkList*)ll;					// 强制转换
	linkListErase(ll, pList->size - 1);
}

// 链表指定值删除（利用回调函数让用户自己去比较）
void linkListRemove(linkList ll, void* data, int (*myCompare)(void*, void*))
{
	if (ll == NULL) { return; }
	if (data == NULL) { return; }

	// 强制转换
	stu_linkList* pList = (stu_linkList*)ll;

	// 在遍历查找该值匹配的节点时还要记录该节点的前驱节点，因此这里我们用双指针。
	stu_linkNode* prevNode = &pList->head;			// 当前节点的前驱节点
	stu_linkNode* curNode = pList->head.next;		// 当前节点
	for (int i = 0; i < pList->size; i++)
	{
		if (myCompare(data, curNode->data))	// 找到了
		{
			prevNode->next = curNode->next;
			free(curNode);
			curNode = NULL;
			pList->size--;
			break;
		}

		// 未找到，双指针向后移动
		prevNode = curNode;							// 前驱节点指向当前节点
		curNode = curNode->next;					// 当前节点指向下一节点
	}
}

// 链表大小
int linkListSize(linkList ll)
{
	if (ll == NULL) { return -1; }
	stu_linkList* pList = (stu_linkList*)ll;		// 强制转换
	return pList->size;
}

// 链表遍历（利用回调函数）
void linkListForEach(linkList ll, int (*myForEach)(void*))
{
	if (ll == NULL) { return; }
	if (myForEach == NULL) { return; }
	
	stu_linkList* pList = (stu_linkList*)ll;		// 强制转换

	stu_linkNode* curNode = pList->head.next;	// 第一个节点
	for (int i = 0; i < pList->size; i++)
	{
		if (myForEach(curNode->data) == -1) { break; }	// 根据返回值判断是否中途退出遍历
		curNode = curNode->next;
	}
}

// 链表清空
void linkListClear(linkList ll)
{
	if (ll == NULL) { return; }

	// 强制转换	
	stu_linkList* pList = (stu_linkList*)ll;

	// 释放内部每个节点
	stu_linkNode* curNode = pList->head.next;
	for (int i = 0; i < pList->size; i++)
	{
		stu_linkNode* nextNode = curNode->next;	// 得到当前节点的后继节点
		free(curNode);
		curNode = nextNode;
	}
	
	// 将头节点的next设为NULL
	pList->head.next = NULL;

	// 更新元素大小
	pList->size = 0;
}

// 链表销毁
void linkListDestroy(linkList ll)
{
	if (ll == NULL) { return; }

	linkListClear(ll);

	free(ll);
	ll = NULL;
}

// 测试用结构体
struct _stu_person
{
	char name[31];
	int age;
};

// 测试用回调函数（返回-1则退出遍历）
int personPrint(void* val)
{
	struct _stu_person* p = (struct _stu_person*)val;
	printf("姓名：%s 年龄：%d\n", p->name, p->age);
	return 0;
}

// 测试用比较回调函数（1-成功，0-失败）
int personCompare(void* data1, void* data2)
{
	struct _stu_person* p1 = (struct _stu_person*)data1;
	struct _stu_person* p2 = (struct _stu_person*)data2;
	if (strcmp(p1->name,p2->name) == 0 && p1->age == p2->age)
	{
		return 1;
	}
	else
	{
		return 0;
	}
}

// 测试链表
void testLinkList()
{
	// 创建链表
	linkList list = linkListInit();

	// 测试数据
	struct _stu_person p1 = { "刘备",39 };
	struct _stu_person p2 = { "关羽",34 };
	struct _stu_person p3 = { "张飞",32 };
	struct _stu_person p4 = { "赵云",28 };
	struct _stu_person p5 = { "吕布",30 };

	// 开始插入
	linkListPushBack(list, &p1);
	linkListInsert(list, 10, &p2);
	linkListInsert(list, 1, &p3);
	linkListPushBack(list, &p4);
	linkListInsert(list, 0, &p5);

	// 遍历
	printf("=====元素个数：%d=====\n", linkListSize(list));
	linkListForEach(list, personPrint);

	// 删除指定位置数据
	linkListErase(list, 1);
	printf("\n=====删除第一个位置数据后的元素个数：%d=====\n", linkListSize(list));
	linkListForEach(list, personPrint);
	linkListPopBack(list);
	printf("\n=====删除最后位置数据后的元素个数：%d=====\n", linkListSize(list));
	linkListForEach(list, personPrint);

	// 删除指定值数据
	struct _stu_person pp = { "张飞",32 };
	linkListRemove(list, &pp, personCompare);
	printf("\n=====删除指定值【张飞，32】数据后的元素个数：%d=====\n", linkListSize(list));
	linkListForEach(list, personPrint);

	// 清空链表
	linkListClear(list);
	printf("\n=====链表清空后的元素个数：%d=====\n", linkListSize(list));
	linkListForEach(list, personPrint);

	// 销毁链表
	linkListDestroy(list);
	printf("\n=====链表已经销毁=====\n");

}

// 链表
int main()
{
	testLinkList();

	return 0;
}

二、双向链表

单向链表已经基本实现了用户想要的功能，但是有一个问题啊，在插入或删除时都得查找该节点的前一个节点，找到后更改其next指针，问题是找该节点的前驱节点的方法就得从头节点开始遍历链表啊，这效率太低了，如果我们在每个节点中不仅能存储它的后继节点指针还能存储其前驱节点的指针就方便了，这就是双向链表的原理了。