数据结构初阶 --- 双向链表的C语言实现

目录

一.链表的分类：

二.带头双向循环链表

三. 双向链表的各函数接口的实现

1.双向链表的结构体定义

2.双向链表的初始化

3.双向链表之创建新结点

4.双向链表的打印

5.双向链表的尾插

6.双向链表的尾删

7.双向链表的头插

8.双向链表的头删

9.双向链表的查找

10.双向链表之在pos位置之前插入

11.双向链表之删除pos位置

12.双向链表的销毁

---

一.链表的分类：

链表的8种结构：

单向带头循环	双向带头循环
单向带头不循环	双向带头不循环
单向不带头循环	双向不带头循环
单向不带头不循环	双向不带头不循环

二.带头双向循环链表

带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向 循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而 简单了。

双向链表的结构：

由1个数据域和2个指针域组成，其中这2个指针一个存储的是前一个结点的地址，一个存储的是后一个结点的地址。

只有一个结点的（头结点）双向链表：

有多个结点的双向链表：

三. 双向链表的各函数接口的实现 1.双向链表的结构体定义

双向循环链表：要定义2个指针，(prev)一个指向当前结点的前一个结点，(next)一个指向当前结点的后一个结点。

typedef int LTDateType;

//带头+双向+循环链表(双向链表)

typedef struct ListNode
{
	LTDateType data;
	struct ListNode* next;
	struct ListNode* prev;
}LTNode;

2.双向链表的初始化

我们这里要实现的是一个带头的链表，所以初始化的时候要创建一个头结点出来（哨兵位的头结点，不需要存储有效数据）。

LTNode* ListInit()//初始化
{
	LTNode* phead = (LTNode*)malloc(sizeof(LTNode)); 
	//带有头结点的链表，这里malloc出的是头结点的空间(带头)
	phead->next = phead;
	phead->prev = phead;
	return phead;
}

3.双向链表之创建新结点

LTNode* BuyListNode(LTDateType x)//malloc一个新的newnode
{
	LTNode* newnode = (LTNode*)malloc(sizeof(LTNode));
	newnode->data = x;
	newnode->next = newnode->prev = NULL;
	return newnode;
}

4.双向链表的打印

双向链表的打印要注意终止条件：

当再次遍历到头结点的时候就应该停下来了。

void ListPrint(LTNode* phead)//打印
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		printf("%d ", cur->data);
		cur = cur->next;
	}
	printf("\n");
}

5.双向链表的尾插

双向链表的尾是很好找的，尾就是头结点的prev (tail=head->prev) ，然后把新节点和原链表的头结点和尾结点建立链接。

void ListPushBack(LTNode* phead, LTDateType x)//尾插
{
	assert(phead);
	LTNode* tail = phead->prev;
	LTNode* newnode = BuyListNode(x);//malloc一个新的newnode

	//  phead   tail   newnode 

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;
}

6.双向链表的尾删

删除 *** 作要注意一下，那个哨兵位的头结点是不能删的（用assert(phead->next!=phead);来避免这种情况)。

尾部删除 *** 作就是要先保存一下尾的前一个结点（tailprev=tail->prev)，然后free(释放)掉尾，并把尾置空；然后把头和新的尾建立链接。

 

void ListPopBack(LTNode* phead)//尾删
{
	assert(phead);
	assert(phead->next!=phead);
    //这里判断链表是否只剩下头结点了，如果链表只剩下 头结点了，就不能再删了

	LTNode* tail = phead->prev;
	LTNode* tailprev = tail->prev;
	tailprev->next = phead;
	phead->prev = tailprev;
	free(tail);
	tail = NULL;
}

7.双向链表的头插

我们这里实现的是带有哨兵位的头结点的双向链表，所以头插是插在哨兵位的头结点的next的位置，就是哨兵位的头结点的下一个位置。

头插需要注意的就是要在插入之前先保存一下哨兵位头结点的下一个结点

（next=phead->next)，然后在phead和next之间把它插入进去，建立链接。

void ListPushFront(LTNode* phead, LTDateType x)//头插
{
	assert(phead);
	LTNode* newnode = BuyListNode(x);//malloc一个新的newnode
	LTNode* next = phead->next;

	//     phead    newnode   next   

	newnode->next = next;
	next->prev = newnode;

	newnode->prev = phead;
	phead->next = newnode;
}

8.双向链表的头删

我们这里实现的是带有头结点的双向链表所以头删的时候，要删除的是头结点的下一个结点（head->next)，需要注意的是如果这个链表里面只有哨兵位的头结点的时候，就不能删了。

要保存出要删除的结点（next=head->next)，并且也要保存要删除结点的下一个结点（nextnext=next->next)，这样把next的结点释放掉（free)以后，还要把next置空，然后把head和nextnext之间重新建立链接关系就可以了。

void ListPopFront(LTNode* phead)//头删
{
	assert(phead);
	assert(phead->next != phead);
	//判断链表是否只剩下头结点了，如果链表只剩下 头结点了，就不能再删了

	LTNode* next = phead->next;
	LTNode* nextnext = next->next;

	//    phead   nextnext

	phead->next = nextnext;
	nextnext->prev = phead;
	free(next);
	next = NULL;
}

9.双向链表的查找

遍历链表查找是否有结点的值（data) 是等于要查找的x的值，找到了就返回该结点，遍历结束都没有找到的话，就返回NULL

//在链表中寻找值为x的结点并返回，找不到的话就返回NULL
LTNode* ListFind(LTNode* phead, LTDateType x)
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		if (cur->data == x)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;
}

10.双向链表之在pos位置之前插入

找到pos的前一个位置，并保存起来了（prev=pos->prev) ，然后就是 prev  newnode  pos  

这样的位置关系，再按照这个位置关系把这3个结点链接起来就可以了。

void ListInsert(LTNode* pos, LTDateType x)//在pos位置之前插入
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* newnode = BuyListNode(x);//malloc一个新的newnode 

	//   prev   newnode   pos

	prev->next = newnode;
	newnode->prev = prev;

	newnode->next = pos;
	pos->prev = newnode;
}

11.双向链表之删除pos位置

找到pos位置的前一个位置（prev=pos->prev)，找到pos位置的后一个位置

（next=pos->next)，并把这2个位置保存起来，然后把prev和next链接起来，

  把pos释放掉并置空。

void ListErase(LTNode* pos)//删除pos位置
{
	assert(pos);
	LTNode* prev = pos->prev;
	LTNode* next = pos->next;

	//    prev   next  

	prev->next = next;
	next->prev = prev;
	free(pos);
	pos = NULL;
}

12.双向链表的销毁

链表的销毁这里，因为链表里面的每一个结点都是malloc申请来的空间，所以每个结点都需要释放，（遍历释放）先释放其他的结点，最后释放哨兵位头结点的空间，然后把指向头结点的指针置空。

void ListDestroy(LTNode* phead)//销毁链表
{
	assert(phead);
	LTNode* cur = phead->next;
	while (cur != phead)
	{
		LTNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL;
}