数据结构——带头双向循环链表的实现

前言

上期我们讲到无头单向非循环链表的实现，其中尾插尾删时都需要取遍历整个链表，才能找到尾，这样太耗费时间了，而且用二级指针的方式来接受参数，不注意就会导致错误。所以这期我们要实现带头双向循环链表，来完美解决这些问题。在实现的过程中，我们可以仔细对比一下两者的区别。
最后我们将对顺序表和链表进行一个对比，看看它们的区别以及优缺点

---

一、带头双向循环链表的实现？

1.每个接口

带头双向循环 -- 最有链表结构，任意位置插入删除数据的时间复杂度都是O(1)
代码如下：

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}ListNode;
//链表的初始化
ListNode* ListInit();
//释放链表
void ListDestory(ListNode* phead);
//打印链表中的数据
void ListPrint(ListNode* phead);
//尾插
void ListPushBack(ListNode* phead, LTDataType x);
//头插
void ListPushFront(ListNode* phead, LTDataType x);
//头删
void ListPopFront(ListNode* phead);
//尾删
void ListPopBack(ListNode* phead);
//在所有结点中，找到第一个与x相等的结点，并返回这个结点的指针
ListNode* ListFind(ListNode* phead, LTDataType x);
// pos位置之前插入x
void ListInsert(ListNode* pos, LTDataType x);
// 删除pos位置的值
void ListErase(ListNode* pos);
//判断链表是否为NULL
bool ListEmpty(ListNode* phead);
//获取链表中有效数据的个数
int ListSize(ListNode* phead);

2.每个接口的实现

在前面我们说到过，双向链表在某些方面是优于单向链表的，具体在哪些方面，请看代码，逐步分析：

ListNode* BuyListNode(LTDataType x)//因为在链表的所有插入接口中，我们都需要创建一个新的结点，并且要对结点中的值进行赋值
{                                  //所以为了防止代码冗余(每个接口只实现相应的功能，不掺杂其他功能)，我们对创建结点进行单独封装
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)//还是老规矩，在使用这个结点前，先判断结点是否创建成功，如果失败则异常终止程序
	{
		printf("BuyListNode fail\n");
		exit(-1);
	}
	newnode->next = newnode->prev = NULL;//将结点的前一个指针和后一个指针都置为NULL，方便后序操作
	newnode->data = x;//进行赋值
	return newnode;//既然我们创建好了这个结点，如果想使用它，则需要返回这个结点的指针
}

ListNode*ListInit()//对链表进行初始化
{
	ListNode* phead = (ListNode*)malloc(sizeof(ListNode));//创建一个结点用来当做链表的头
	phead->data = 0;//因为这个结点是头，所以该结点中存放什么值，都无所谓(1,2,3都行)，但注意的是这里最好不要存链表中数据的有效个数
	               //因为假设链表中的数据类型是char(可能会溢出),double或者是一个指针，亦或是另一个结构体类型，此时就会出错
	phead->next = phead->prev = phead;//因为是循环链表，所以它的next和prev都需要指向自己
	return phead;
}

void ListDestory(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)//这里为什么不是是cur!=NULL，因为循环链表的指针可能指向空，从头的下一个结点开始释放，直到循环回到phead为止
	{
		ListNode* next = cur->next;//释放当前结点之前，保存下一个结点的指针，以此迭代
		free(cur);
		cur = next;
	}//这里我们需要明白头结点不应该在这释放，而在整个工程结束的时候释放
}

void ListPrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)//当cur等于phead的时候，表明已经打印了链表中的所有数据
	{
		printf("%d ", cur->data);
		cur = cur->next;//迭代过程
	}
	printf("\n");
}

void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* tail = phead->prev;//尾插需要找到尾结点，因为我们是循环链表，所以头结点的前一个结点就是尾结点
	                             //这就是循环链表的好处，不需要遍历整个链表，才能找到尾
	                             //这里也不需要考虑是否是插入的第一个结点
	tail->next = newnode;//下面就将newnode链接到整个链表中
	phead->prev = newnode;
	newnode->next = phead;
	newnode->prev = tail;
}

void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* newnode = BuyListNode(x);
	ListNode* next = phead->next;//跟尾插的唯一区别就是这里保存的是头结点的后一个结点的指针，而尾插是保存的前一结点的指针
	phead->next = newnode;//下面就将newnode链接到整个链表中
	next->prev = newnode;
	newnode->prev = phead;
	newnode->next = next;
}

void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//删除数据时，需要判断链表是否为NULL
	ListNode* next = phead->next->next;
	free(phead->next);
	phead->next = next;
	next->prev = phead;
}

void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(!ListEmpty(phead));//同样样需要判断链表是否为NULL
	ListNode* prev = phead->prev->prev;//头结点的下一个结点才是第一个存放有效数据的结点，所以应当保存第一个有效数据结点的下一个结点
	free(phead->prev);//释放掉第一个存储有效数据的结点
	phead->prev = prev;//进行链接
	prev->next = phead;
}

ListNode* ListFind(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)//遍历链表，类似于打印数据
	{
		if (cur->data == x)
		{
			return cur;//找到就返回结点的指针
		}
		cur = cur->next;//迭代过程
	}
	return NULL;//没找到就返回NULL
}

void ListInsert(ListNode* pos, LTDataType x)//与单链表不同的是，这里我们不需要遍历链表从而找出pos的前一个结点，因为我们是双向链表，pos->prev就是前一个结点
{
	assert(pos);//判断pos是否合法
	ListNode* newnode = BuyListNode(x);
	ListNode* pos_next = pos->next;//保存pos前一个结点的指针
	pos->next = newnode;//下面代码是进行链接，没有顺序要求
	newnode->prev = pos;
	newnode->next = pos_next;
	pos_next->prev = newnode;
}

void ListErase(ListNode* pos)
{
	assert(pos);//判断pos是否合法
	ListNode* pos_prev = pos->prev;//保存pos的前一个结点的指针
	ListNode* pos_next = pos->next;保存pos的后一个结点的指针
	free(pos);
	pos_prev->next = pos_next;//将pos删除后进行链接
	pos_next->prev = pos_prev;
}

bool ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead;//因为是循环链表，如果头结点的next指向自己，则表示为NULL，就返回true，否则返回false
}

int ListSize(ListNode* phead)
{
	int size = 0;//定义一个计数器
	ListNode* cur = phead->next;//从头结点的下一个结点开始遍历
	while (cur != phead)//当cur和phead相等时，表明已经将整个链表遍历完成
	{
		size++;
		cur = cur->next;
	}
	return size;
}

画图分析:

3.测试程序

void test()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 7);
	printf("%d\n", ListSize(plist));

	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);

	ListInsert(ListFind(plist, 3), 5);
	ListPrint(plist);

	ListErase(ListFind(plist, 5));
	ListPrint(plist);

	ListPopBack(plist);
	ListPrint(plist);

	ListPopBack(plist);
	ListPrint(plist);

	ListDestory(plist);//在结束程序前，要记得释放链表，防止内存泄漏，这个问题已经是老生常谈了
	free(plist);//最后还要释放头结点，并且将plist置为NULL
	plist = NULL;
}

int main()
{

	test();

	return 0;
}

测试：

二、顺序表和链表的区别

不同点	顺序表	链表
存储空间上	物理上一定连续	逻辑上连续，但物理上不一定连续
随机访问	支持O(1)	不支持:O(N)
任意位置插入或者删除元素	可能需要搬移元素，效率低O(N)	只需修改指针指向
插入	动态顺序表，空间不够时需要扩容	没有容量的概念
应用场景	元素高效存储+频繁访问	任意位置插入和删除频繁
缓存利用率	高	低

备注：缓存基本上来说就是把后面的数据加载到离自己近的地方，对于CPU来说，它是不会一个字节一个字节的加载的，因为这非常没有效率，一般来说都是要一块一块的加载的，对于这样的一块一块的数据单位，术语叫“Cache Line”，一般来说，一个主流的CPU的Cache Line 是 64 Bytes（也有的CPU用32Bytes和128Bytes），64Bytes也就是16个32位的整型，这就是CPU从内存中捞数据上来的最小数据单位。
简单的来说：
如果是顺序表(物理地址连续)，将加载连续的地址到Cache中，如果顺序表想进行连续访问，就不需要到内存中找，因为Cache里面有，而Cache的访问速度要要高于内存。
如果是链表(物理地址不连续)，每次加载一个数据单位的数据时，链表每个结点的地址是不连续，所以如果要对链表进行连续访问，就要重新加载数据，因为Cache中找不到相应的数据，此时就要去内存中找。

总结

本期我们学习了带头循环双向链表，也了解了它相对于无头单向非循环链表的优点。这次我们也进行了链表和顺序表的对比，各有优缺点。除此之外，其他的数据结构也有相应的优缺点，每种数据结构都不是十全十美，不同的数据结构用于不同的应用场景，这样才能发挥出结构本身的特性。