• 数据结构之带头双向循环链表

    目录

    链表的分类

    带头双向循环链表的实现

    带头双向循环链表的结构

    带头双向循环链表的结构示意图

    空链表结构示意图

    单结点链表结构示意图

     多结点链表结构示意图

    链表创建结点

    双向链表初始化

    销毁双向链表

    打印双向链表

     双向链表尾插

    尾插函数测试

    双向链表头插

    头插函数测试

     双向链表尾删

    尾删函数测试

    双向链表头删

    头删函数测试

    双向链表查找

    双向链表pos位置前插

    插入函数测试

     双向链表删除pos位置的结点

    删除函数测试

    利用 ListInsert()函数改造头插尾插函数

    尾插函数改造版本

    头插函数改造版本

    利用ListEarse()函数改造头删 尾删函数

    头删函数改造版本

    尾删函数改造版本

    计算双向链表长度

    链表的分类

    • 单向/双向

    单向列表：每一个结点结构中只保存下一结点的地址，所以很难从后一结点找到前一节点；

    双向列表：每一个结点结构中不仅保存下一结点的地址，还保存上一节点的地址；方便寻找前一节点和后一节点；

     

    • 带头/不带头

    带头：在头结点之前有一个哨兵位结点，哨兵位的数据域不存储有效数据，指针域指向头结点；

    不带头：没有哨兵位结点，尾插尾删考虑头结点情况；

     

    • 循环/非循环

    循环：头结点与尾结点相连；

    非循环：头结点与尾结点不相连；

    上述情况相互组合，共有8种情况,  实际中使用的链表数据结构，都是带头双向循环链表，带头双向循环链表虽然结构复杂，但是其结构具有很多优势，实现反而简单；

    带头双向循环链表的实现

    带头双向循环链表的结构

    1. typedef int LTDataType;
    2. typedef struct ListNode
    3. {
    4. 	struct ListNode* prev;//前址域-存放前一个结点的地址
    5. 	LTDataType data;//数据域
    6. 	struct ListNode* next;//后址域-存放后一个结点的地址
    7. }ListNode;

    逻辑图：

    物理图：

    带头双向循环链表的结构示意图

    由图可知，head->prev=head; head->next=head;

    • 单结点链表结构示意图

    由图可知：

    head->next=FirstNode;

    head->prev=FirstNode;

    FirstNode->prev=head;

    FirstNode->next=head;

    •  多结点链表结构示意图

    由图可知:

    head->next=firstnode;

    head->prev=tail;

    tail->next=head;

    firstnode->prev=head;

    链表创建结点

    1. //创建链表结点,返回链表结点地址
    2. ListNode* BuyListNode(LTDataType x)
    3. {
    4. 	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
    5. 	if (newnode == NULL)
    6. 	{
    7. 		perror("malloc failed:");
    8. 		exit(-1);
    9. 	}
    10.  
    11. 	newnode->data = x;
    12. 	newnode->next = NULL;
    13. 	newnode->prev = NULL;
    14.  
    15. 	return newnode;
    16. }

    双向链表初始化

     注：函数调用时得到动态开辟的链表空间起始地址的两种方案如下

    方案一： 当传参时为链表结点的地址，函数的形参设计为二级指针，只有通过传址调用，可以将动态开辟的链表的起始地址带出函数；

    方案二： 设计函数的返回类型为结点指针，返回动态开辟的链表结点指针，如此可以得到链表空间的起始地址；

    1. //初始化链表(空链表)
    2. ListNode* ListInit()
    3. {
    4. 	//创建哨兵位结点
    5. 	ListNode* head = BuyListNode(0);//0不是有效数据
    6.  
    7. 	//初始化哨兵位结点的指针域
    8. 	head->next = head;
    9. 	head->prev = head;
    10.  
    11. 	return head;
    12. }

    销毁双向链表

    • 循环遍历释放结点，包含哨兵位结点；
    • 释放前保存下一结点地址，避免地址丢失；
    1. //销毁链表,包含哨兵位结点
    2. void DestoryList(ListNode* phead)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//创建寻址指针
    7. 	ListNode* cur = phead;
    8. 	//断开循环链表
    9. 	phead->prev->next = NULL;
    10. 	while (cur != NULL)
    11. 	{
    12. 		//记录下一结点地址
    13. 		ListNode* next = cur->next;
    14.         //释放当前结点
    15. 		free(cur);
    16. 		//寻找下一节点
    17. 		cur = next;
    18. 	}
    19. 	return;
    20. }

    打印双向链表

    • 循环遍历链表打印数据，不显示哨兵位结点的数据域；
    • 以哨兵位头结点作为结束标志；
    1. void PrintList(ListNode* phead)
    2. {
    3. 	assert(phead != NULL);
    4.  
    5. 	ListNode* cur = phead->next;
    6.  
    7. 	printf("phead<==>");
    8. 	while (cur != phead)
    9. 	{
    10. 		printf("%d<==>", cur->data);
    11. 		cur = cur->next;
    12. 	}
    13. 	printf("\n");
    14. }

     双向链表尾插

    •  尾插先找尾，哨兵位的前址域即为尾结点即tail=head->prev;
    • 当链表为空时，连接的逻辑关系相同（创建三个指针变量，按照新结点的前址域指向谁，谁指向新结点，新结点的后址域指向谁，谁指向新结点进行连接）；
    1. void ListPushBack(ListNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4.     
    5. 	//寻找尾结点
    6. 	ListNode* tail = phead->prev;
    7.     //创建新结点
    8. 	ListNode* newnode = BuyListNode(x);
    9.  
    10.    //尾插
    11. 	newnode->prev = tail;
    12. 	tail->next = newnode;
    13.  
    14. 	newnode->next = phead;
    15. 	phead->prev = newnode;
    16. }
    尾插函数测试
    1. void Test1()
    2. {
    3. 	ListNode* plist=ListInit();
    4. 	
    5. 	ListPushBack(plist, 1);
    6. 	ListPushBack(plist, 2);
    7. 	ListPushBack(plist, 3);
    8. 	ListPushBack(plist, 4);
    9. 	ListPushBack(plist, 5);
    10. 	PrintList(plist);
    11. }
    12. int main()
    13. {
    14. 	Test1();
    15. 	return 0;
    16. }

    运行结果：

    双向链表头插

    • 头插前先保存哨兵位结点的下一节点即原先真正的首节点；
    • 按照按照新结点的前址域指向谁，谁指向新结点，新结点的后址域指向谁，谁指向新结点进行连接从而实现头插，链表为空时，头插逻辑仍然相同；
    1. //链表头插
    2. void ListPushFront(ListNode* phead, LTDataType x)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//保存原先的首节点
    7. 	ListNode* firstnode = phead->next;
    8. 	//创建新结点
    9. 	ListNode* newnode = BuyListNode(x);
    10.  
    11. 	//头插
    12. 	newnode->prev = phead;
    13. 	phead->next = newnode;
    14.  
    15. 	newnode->next = firstnode;
    16. 	firstnode->prev = newnode;
    17. }
    头插函数测试
    1. void Test2()
    2. {
    3. 	ListNode* plist = ListInit();
    4. 	ListPushFront(plist, 10);
    5. 	ListPushFront(plist, 20);
    6. 	ListPushFront(plist, 30);
    7. 	ListPushFront(plist, 40);
    8. 	ListPushFront(plist, 50);
    9. 	PrintList(plist);
    10.  
    11. }
    12. int main()
    13. {
    14. 	Test2();
    15. 	return 0;
    16. }

    运行结果：

     双向链表尾删

    • 链表中只剩哨兵位结点，此时链表为空，不再进行尾删；
    • 尾删前记录前一节点的地址，方便修改逻辑关系；
    1. //链表尾删
    2. void ListPopBack(ListNode* phead)
    3. {
    4. 	assert(phead);
    5.  
    6. 	//链表中只剩哨兵位的情况
    7. 	assert(phead->next != phead);
    8.  
    9. 	//查找尾结点
    10. 	ListNode* tail = phead->prev;
    11. 	//保存尾结点的上一节点
    12. 	ListNode* tailprev = tail->prev;
    13.  
    14.    //尾删
    15. 	free(tail);
    16.    //建立链接关系
    17. 	tailprev->next = phead;
    18. 	phead->prev = tailprev;
    19.  
    20. }
    尾删函数测试
    1. void Test3()
    2. {
    3. 	ListNode* plist = ListInit();
    4.  
    5. 	ListPushBack(plist, 1);
    6. 	ListPushBack(plist, 2);
    7. 	ListPushBack(plist, 3);
    8. 	ListPushBack(plist, 4);
    9. 	ListPushBack(plist, 5);
    10. 	PrintList(plist);
    11.  
    12. 	ListPopBack(plist);
    13. 	PrintList(plist);
    14.  
    15. 	ListPopBack(plist);
    16. 	PrintList(plist);
    17.  
    18. 	ListPopBack(plist);
    19. 	PrintList(plist);
    20.  
    21. }
    22. int main()
    23. {
    24. 	Test3();
    25. 	return 0;
    26. }

    运行结果：

    双向链表头删

    • 链表中只剩哨兵位结点，此时链表为空，不再进行头删；
    • 头删前记录下一节点的地址，方便修改逻辑关系；
    1. //链表头删
    2. void ListPopFront(ListNode* phead)
    3. {
    4. 	assert(phead);
    5. 	//只剩哨兵位,不再头删
    6. 	assert(phead->next != phead);
    7.  
    8. 	//保存原先的首节点
    9. 	ListNode* head = phead->next;
    10.  
    11. 	//保存首结点的下一节点
    12. 	ListNode* headnext = phead->next->next;
    13.  
    14. 	//头删
    15. 	free(head);
    16. 	//建立链接关系
    17. 	headnext->prev = phead;
    18. 	phead->next = headnext;
    19.  
    20. }
    头删函数测试
    1. void Test4()
    2. {
    3. 	ListNode* plist = ListInit();
    4.  
    5. 	ListPushBack(plist, 1);
    6. 	ListPushBack(plist, 2);
    7. 	ListPushBack(plist, 3);
    8. 	ListPushBack(plist, 4);
    9. 	ListPushBack(plist, 5);
    10. 	PrintList(plist);
    11.  
    12. 	ListPopFront(plist);
    13. 	PrintList(plist);
    14.  
    15. 	ListPopFront(plist);
    16. 	PrintList(plist);
    17.  
    18. 	ListPopFront(plist);
    19. 	PrintList(plist);
    20. }
    21. int main()
    22. {
    23. 	Test4();
    24. 	return 0;
    25. }

    运行结果：

    双向链表查找

    • 循环遍历链表，从首节点开始遍历，以哨兵位头结点作为结束标志；
    • 根据数据域进行查找，找到返回数据域的结点地址，找不到返回空指针；
    1. ListNode* ListFind(ListNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4.  
    5. 	//创建遍历指针
    6. 	ListNode* cur = phead->next;
    7.  
    8. 	//遍历链表
    9. 	while (cur != phead)
    10. 	{
    11. 		if ((cur->data) == x)
    12. 		{
    13. 			//找到返回下标
    14. 			return cur;
    15. 		}
    16. 		cur = cur->next;
    17. 	}
    18. 	//没找到返回空指针
    19. 	return NULL;
    20. }

    双向链表pos位置前插

    • 前插时保存pos位置的前一个节点，方便修改逻辑关系；
    • 按照按照新结点的前址域指向谁，谁指向新结点，新结点的后址域指向谁，谁指向新结点进行链接；
    1. void ListInsert(ListNode* pos, LTDataType x)
    2. {
    3. 	assert(pos != NULL);
    4.  
    5. 	//创建新结点
    6. 	ListNode* newnode = BuyListNode(x);
    7. 	//保存pos位置的前一个结点
    8. 	ListNode* posprev = pos->prev;
    9.  
    10. 	//前插
    11. 	newnode->prev = posprev;
    12. 	posprev->next = newnode;
    13. 	newnode->next = pos;
    14. 	pos->prev = newnode;
    15. }
    插入函数测试
    1. void Test5()
    2. {
    3. 	ListNode* plist = ListInit();
    4. 	ListPushBack(plist, 1);
    5. 	ListPushBack(plist, 2);
    6. 	ListPushBack(plist, 3);
    7. 	ListPushBack(plist, 4);
    8. 	ListPushBack(plist, 5);
    9.  
    10. 	int x = 0;
    11. 	printf("请输入查找的数值:");
    12. 	scanf("%d", &x);
    13. 	ListNode* pos = ListFind(plist, x);
    14. 	if (pos == NULL)
    15. 	{
    16. 		printf("要查找的值不存在\n");
    17. 		return;
    18. 	}
    19. 	//在查找到数值前插入100
    20. 	ListInsert(pos, 100);
    21. 	PrintList(plist);
    22.  
    23. }
    24. int main()
    25. {
    26. 	Test5();
    27. 	return 0;
    28. }

    运行结果：

     双向链表删除pos位置的结点

    • 链表删除pos位置处的结点前先保存前结点和后结点的地址，方便处理链接关系；
    1. //双向链表删除pos位置
    2. void ListEarse(ListNode* pos)
    3. {
    4. 	assert(pos);
    5.  
    6. 	//保存pos位置处的前一个和后一个结点;
    7. 	ListNode* posprev = pos->prev;
    8. 	ListNode* posnext = pos->next;
    9. 	//删除pos位置结点
    10. 	free(pos);
    11.  
    12. 	//建立前后节点的链接关系
    13. 	posprev->next = posnext;
    14. 	posnext->prev = posprev;
    15.  
    16. }
    删除函数测试
    1. void Test6()
    2. {
    3. 	ListNode* plist = ListInit();
    4. 	ListPushBack(plist, 1);
    5. 	ListPushBack(plist, 2);
    6. 	ListPushBack(plist, 3);
    7. 	ListPushBack(plist, 4);
    8. 	ListPushBack(plist, 5);
    9. 	PrintList(plist);
    10.  
    11. 	int x = 0;
    12. 	printf("请输入删除的数值:");
    13. 	scanf("%d", &x);
    14. 	ListNode* pos = ListFind(plist, x);
    15. 	if (pos == NULL)
    16. 	{
    17. 		printf("要删除的值不存在\n");
    18. 		return;
    19. 	}
    20. 	
    21. 	ListEarse(pos);
    22. 	PrintList(plist);
    23. }
    24. int main()
    25. {
    26. 	Test6();
    27. 	return 0;
    28. }

    运行结果：

    利用 ListInsert()函数改造头插尾插函数

    • 尾插函数改造版本
    1. void Listpushback(ListNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4. 	ListInsert(phead, x);
    5. }
    • 头插函数改造版本
    1. void Listpushfront(ListNode* phead, LTDataType x)
    2. {
    3. 	assert(phead);
    4. 	ListInsert(phead->next, x);
    5. }

    利用ListEarse()函数改造头删 尾删函数

    • 头删函数改造版本
    1. void Listpopfront(ListNode* phead)
    2. {
    3. 	assert(phead);
    4. 	//只剩哨兵位,不再头删
    5. 	assert(phead->next != phead);
    6.  
    7. 	ListEarse(phead->next);
    8. }
    • 尾删函数改造版本
    1. void Listpopback(ListNode* phead)
    2. {
    3. 	assert(phead);
    4.  
    5. 	//链表中只剩哨兵位的情况
    6. 	assert(phead->next != phead);
    7.  
    8. 	ListEarse(phead->prev);
    9. }

    计算双向链表长度

    1. int ListLength(ListNode* phead)
    2. {
    3. 	assert(phead);
    4.  
    5. 	int size = 0;
    6. 	ListNode* cur = phead->next;
    7. 	while (cur != phead)
    8. 	{
    9. 		++size;
    10. 		cur = cur->next;
    11. 	}
    12. 	return size;
    13. }

     

     

     

     

     

     

  • 相关阅读:
    VISUAL SVN 5.6.0以上破解使用天数
    人大金仓分析型数据库使用之创建和管理表空间
    Jetson Xavier NX远程桌面VNC使用
    livoxhapsdk2
    从求职惨败到阿里35w+offer，这位双非硕的经历太励志！
    有关于torch.autograd.grad
    代码随想录笔记_动态规划_337打家劫舍III
    Web逆向-某网络学院学习的”偷懒“思路分析
    群晖（Synology）NAS 后台安装 Docker 后配置 PostgreSQL
    Qt之解析HTML
  • 原文地址：https://blog.csdn.net/m0_58963318/article/details/133609175