C语言数据结构之线性表-双向链表篇

心有半亩花田

藏于世俗人间

C语言数据结构之线性表-双向链表篇_第1张图片


烟雨长虹,孤鹜齐飞的个人主页

个人专栏

前期回顾-单链表

期待小伙伴们的支持与关注!!!


目录

双向链表的介绍 

双向链表的结构 

双向链表的功能 

 为节点分配动态内存空间 

创建双向链表的哨兵位 

打印双向链表 

双向链表的头插 

双向链表的尾插 

双向链表的头删

双向链表的尾删

 双向链表的查找

双向链表的指定位置之后插入节点 

双向链表的删除指定节点 

双向链表的销毁 

代码的整体实现 

总结# 

双向链表的介绍 

双向链表:它的每个数据结点中都有两个指针,分别指向前驱和后驱。所以,从双向链表中的任意一个结点开始,都可以很方便地访问它的前驱结点后驱结点

双向链表的结构 

双向链表的全称:带头双向循环链表

注意:这里的 带头 跟前⾯我们说的 头节点 是两个概念,实际前面的在单链表阶段称呼不严谨,但是为了大家更好的理解就直接称为单链表的头节点

带头链表里的头节点,实际为 哨兵位 ,哨兵位节点不存储任何有效元素,只是起个带头作用

哨兵位存在的意义: 遍历循环链表避免死循环

C语言数据结构之线性表-双向链表篇_第2张图片

双向链表的结构定义:

typedef int ListType;       //将数据类型重命名,防止以后换类型所带来的麻烦

typedef struct ListNode
{
	ListType data;
	struct ListNode* next;  //指向该节点的后驱指针
	struct ListNode* prev;  //指向该节点的前驱指针
}ListNode;                  //结构体类型的重命名,为了以后书写方便

跟我们讲到过的火车模拟差不多,现在是一个车厢存放了两把钥匙,即可以访问该车厢的前车厢也可以访问该车厢的后车厢

今天我将带大家去实现双向链表的 增删查改

双向链表的功能 

 为节点分配动态内存空间 

后面我们要在单链表中进行头插和尾插,为了方便和减少代码的重复度,我们分装一个函数用来专门创建新结点

ListNode* ListMalloc(ListType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));//利用malloc开辟动态空间
	assert(newNode);                         //判断空间是否开辟成功
	newNode->data = x;                       //读入数据
	newNode->next = newNode->prev = newNode; //该空间的后驱以及前驱指针都指向该节点形成一个环
	return newNode;                          //这个节点空间已经创建好了返回出去
}

创建双向链表的哨兵位 

我们设置了 -1 节点就是我们的带头节点也就是 哨兵位

ListNode* LTInit()
{
	ListNode* head = ListMalloc(-1);
	return head;
}

打印双向链表 

我们写代码最好是写一点测一点,不要最后才调试,所以我们先把打印接口先规划好

void ListPrint(ListNode* head) {
	assert(head);                  //判断链表为不为空
	ListNode* pcur = head->next;   //定义一个指针指向哨兵位的下一个节点,也就是第一个节点
	while (pcur != head)           //因为双向链表是一个循环链表,尾节点的下一个就是哨兵位
	{
		printf("%d->", pcur->data);//打印数据
		pcur = pcur->next;         //访问下一个节点数据
	}
	printf("\n");
}

双向链表的头插 

C语言数据结构之线性表-双向链表篇_第3张图片

C语言数据结构之线性表-双向链表篇_第4张图片

void ListPushFront(ListNode* head, ListType x)
{
	assert(head);                     //判断链表为不为空
	ListNode* newNode = ListMalloc(x);//开辟动态空间
	newNode->next = head->next;       //新节点的后驱指针指向第一个节点
	newNode->prev = head;             //新节点的前驱指针指向哨兵位
	head->next->prev = newNode;       //第一个节点的前驱指针指向新节点
	head->next = newNode;             //哨兵位的后驱指针指向新节点
}

C语言数据结构之线性表-双向链表篇_第5张图片

双向链表的尾插 

C语言数据结构之线性表-双向链表篇_第6张图片

C语言数据结构之线性表-双向链表篇_第7张图片

void ListPushBack(ListNode* head, ListType x)
{
	assert(head);                     //判断链表是否为空
	ListNode* newNode = ListMalloc(x);//开辟动态空间
	newNode->next = head;             //新节点的后驱指针指向哨兵位
	newNode->prev = head->prev;       //新节点的前驱指针指向尾节点
	head->prev->next = newNode;       //尾节点的后驱指针指向新节点
	head->prev = newNode;             //哨兵位的前驱节点指向新节点
}

C语言数据结构之线性表-双向链表篇_第8张图片

双向链表的头删

C语言数据结构之线性表-双向链表篇_第9张图片

void ListPopFront(ListNode* head)
{
	assert(head);                //判断链表是否为空
	assert(head->next != head);  //判断哨兵位的下一个节点为不为空
	ListNode* pulic = head->next;//定义一个指针记录要删除首节点的位置
	ListNode* next = pulic->next;//定义一个指针指向首节点的后驱节点
	next->prev = head;           //首节点的后驱节点也就是第二节点的前驱指针指向哨兵位
	head->next = next;           //哨兵位的后驱指针指向第二节点
	free(pulic);                 //释放首节点
	pulic = NULL;
}

双向链表的尾删

C语言数据结构之线性表-双向链表篇_第10张图片

void ListPopBack(ListNode* head)
{
	assert(head);                  //判断链表是否为空
	assert(head->next != head);    //判断哨兵位的下一个节点是否为空
	ListNode* pulic = head->prev;  //定义一个指针指向尾节点
	ListNode* prev = pulic->prev;  //定义一个指针指向尾节点的前驱节点
	prev->next = head;             //尾节点的前驱节点的后驱指针指向哨兵位
	head->prev = prev;             //哨兵位的前驱指针指向尾节点的前驱节点
	free(pulic);                   //释放尾节点
	pulic = NULL;
}

 双向链表的查找

ListNode* ListFind(ListNode* head, ListType x)
{
	assert(head);                //判断链表是否为空
	ListNode* pcur = head->next; //定义一个指针指向哨兵位
	while (pcur != head)         //遍历链表寻找指定数据
	{
		if (pcur->data == x)
		{
			return pcur;         //找到了返回当前指针
		}
		pcur = pcur->next;
	}
	return NULL;                 //找不到返回NULL
}

C语言数据结构之线性表-双向链表篇_第11张图片

双向链表的指定位置之后插入节点 

C语言数据结构之线性表-双向链表篇_第12张图片

C语言数据结构之线性表-双向链表篇_第13张图片

void ListInsert(ListNode* pos,ListType x) 
{
	assert(pos);                     //判断pod合不合法
	ListNode* newnode = ListMalloc(x);
	
	newnode->next = pos->next;
	newnode->prev = pos;

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

C语言数据结构之线性表-双向链表篇_第14张图片

双向链表的删除指定节点 

C语言数据结构之线性表-双向链表篇_第15张图片

void ListErase(ListNode* pos)
{
	pos->next->prev = pos->prev;//指定元素的后驱节点的前驱指针指向指定节点的前驱节点
	pos->prev->next = pos->next;//指定元素的前驱节点的后驱指针指向指定节点的后驱节点
	free(pos);                  //释放指定元素的空间
	pos = NULL;
}

C语言数据结构之线性表-双向链表篇_第16张图片

双向链表的销毁 

void ListDesTroy(ListNode* head) {
	//哨兵位不能为空
	assert(head);

	ListNode* pcur = head->next;
	while (pcur != head)
	{
		ListNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	//链表中只有一个哨兵位
	free(head);
	head = NULL;
}

代码的整体实现 

#include
#include
#include

typedef int ListType;      
typedef struct ListNode
{
	ListType data;
	struct ListNode* next;  
	struct ListNode* prev;  
}ListNode;             
ListNode* ListMalloc(ListType x)
{
	ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
	assert(newNode);                         
	newNode->data = x;                       
	newNode->next = newNode->prev = newNode; 
	return newNode;                          
}

ListNode* LTInit()
{
	ListNode* head = ListMalloc(-1);
	return head;
}

void ListPrint(ListNode* head) {
	assert(head);                 
	ListNode* pcur = head->next;  
	while (pcur != head)           
	{
		printf("%d->", pcur->data);
		pcur = pcur->next;         
	}
	printf("\n");
}


void ListPushBack(ListNode* head, ListType x)
{
	assert(head);                     
	ListNode* newNode = ListMalloc(x);
	newNode->next = head;            
	newNode->prev = head->prev;      
	head->prev->next = newNode;       
	head->prev = newNode;            
}

void ListPushFront(ListNode* head, ListType x)
{
	assert(head);                    
	ListNode* newNode = ListMalloc(x);
	newNode->next = head->next;       
	newNode->prev = head;            
	head->next->prev = newNode;       
	head->next = newNode;            
}

void ListPopBack(ListNode* head)
{
	assert(head);                  
	assert(head->next != head);   
	ListNode* pulic = head->prev;  
	ListNode* prev = pulic->prev;  
	prev->next = head;             
	head->prev = prev;           
	free(pulic);                  
	pulic = NULL;
}

void ListPopFront(ListNode* head)
{
	assert(head);               
	assert(head->next != head);  
	ListNode* pulic = head->next;
	ListNode* next = pulic->next;
	next->prev = head;         
	head->next = next;           
	free(pulic);               
	pulic = NULL;
}

ListNode* ListFind(ListNode* head, ListType x)
{
	assert(head);                
	ListNode* pcur = head->next; 
	while (pcur != head)        
	{
		if (pcur->data == x)
		{
			return pcur;
		}
		pcur = pcur->next;
	}
	return NULL;
}

void ListInsert(ListNode* pos,ListType x) 
{
	assert(pos);                     
	ListNode* newnode = ListMalloc(x);
	
	newnode->next = pos->next;
	newnode->prev = pos;

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

void ListErase(ListNode* pos)
{
	pos->next->prev = pos->prev;
	pos->prev->next = pos->next;
	free(pos);                  
	pos = NULL;
}

void ListDesTroy(ListNode* head) {
	assert(head);

	ListNode* pcur = head->next;
	while (pcur != head)
	{
		ListNode* next = pcur->next;
		free(pcur);
		pcur = next;
	}
	free(head);
	head = NULL;
}
void CeShi()
{
	ListNode* plist = LTInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
}

int main()
{
	CeShi();
	system("pause");
	return 0;
}

总结# 

其实双向链表和单向链表相比改变并不是很大,也只是多了一个指向前驱的指针而已,变化最大的也就是添加节点和删除节点,需要将前面的和后面的节点都进行连接

C语言数据结构之线性表-双向链表篇_第17张图片

你可能感兴趣的:(C语言数据结构,数据结构,c语言,链表)