数据结构之[双链表的是实现]【保姆级讲解】

最新推荐文章于 2024-04-16 22:43:46 发布

cls-evd

最新推荐文章于 2024-04-16 22:43:46 发布

阅读量303

点赞数 6

分类专栏：数据结构文章标签：数据结构链表

本文链接：https://blog.csdn.net/qq_52433890/article/details/120912685

版权

数据结构专栏收录该内容

16 篇文章 2 订阅

订阅专栏

本文详细介绍了带头双向循环链表的数据结构及其核心操作，包括创建、初始化、插入、删除、查找等接口的实现。通过复用插入和删除接口，简化了头插、头删、尾插、尾删的操作。此外，还提供了检测链表状态和销毁链表的功能。通过实例展示了如何使用这些接口进行链表操作。

摘要由CSDN通过智能技术生成

上篇文章我们实现了链表中两大重要链表之一无头单项非循环链表，这次我们来实现带头双向循环链表。

话不多说上图：

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

废话不多说我们进入正题：

带头双向循环链表的实现

根据上图我们可以看出，该链表需要存储两个指针，所以我们在定义的时候就需要一前一后俩指针这里我们同样用结构体来实现该链表的节点（双链表我们一般以List称之）

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}ListNode;

根据该链表的逻辑结构的图可得，该链表存在一个头结点（头结点是在链表的开始结点之前附加一个结点），拥有这个头结点存在以下好处

（1）、由于开始结点的位置被存放在头结点的指针域中,所以在链表的第一个位置上的操作就和在表的其它位置上操作一致,无须进行特殊处理，也就是说不用像单链表使用二级指针

（2）、无论链表是否为空，其头指针是指向头结点的非空指针（空表中头结点的指针域空），因此空表和非空表的处理也就统一了。

所以，我们首先要创建一个节点，并对他进行初始化，使其成为一个头结点

创建新节点接口的实现

因为在链表使用过程中要频繁的创建节点，所以我们用一个接口来实现

ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->next = NULL;
	node->prev = NULL;
	node->data = x;
    return node;
}

初始化头结点的实现

这里我们认为头结点存的值为0，因为该链表是循环的，所以将phead->next指向他自己，

phead->prev同样指向他自己

ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

打印接口的实现

打印就是将该链表进行遍历，设置cur为除头结点的第一个节点，因为该链表是循环的，所以当cur=phead后遍历结束

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

尾插的实现

因为该链表是带头的，所以不需要传二级指针就可以实现

图解：

void ListPushBack(ListNode* phead, LTDataType x)
{
	assert(phead);  //保证头结点不为空
	ListNode* tail = phead->prev;
	ListNode* newnode = BuyListNode(x);

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

头插的实现

图解：

void ListPushFront(ListNode* phead, LTDataType x)
{
	assert(phead);
	ListNode* first = phead->next;
	ListNode* newnode = BuyListNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;
}

尾删的实现

思路：找到尾，将尾删除，原来尾的前一个成为新的尾，更改新尾与头结点的指向即可

void ListPopBack(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead); //保证不会只有一个头结点

	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;
	free(tail);

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

头删的实现

找到头删除即可

void ListPopFront(ListNode* phead)
{
	assert(phead);
	assert(phead->next != phead);

	ListNode* first = phead->next;
	ListNode* second = first->next;
	free(first);
	phead->next = second;
	second->prev = 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;
}

返回值是结构体类型的指针，使用时需要一个指针来接收它

如图使用

在某位置（pos）前插入的实现

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

}

删除某位置（pos）的实现

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

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

}

重点来了：在我们实现完删除任意位置的节点，与在任意位置前插入节点这两个接口之后，我们不仅发现，之前的头插头删尾插尾删都可以用这两个节点来实现

尾插只要保证pos是头结点即可

头插只要保证pos是phead指向的第一个节点

尾删保证pos是链表的尾部，也就是phead->prev

头删保证pos是phead指向的第一个节点

ListInsert(phead, x);  //尾插的复用
ListInsert(phead->next, x); //头插的复用
ListErase(phead->prev);  //尾删的复用
ListErase(phead->next);  //头删的复用

检测链表是否为空接口的的实现

检测链表是否为空，空则返回0，否则返回1

检查一下除头结点的第一个节点即可

int ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead ? 0 : 1;
}

检查链表有几个节点的实现

遍历一遍即可（加一个计数器）

int ListSize(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	int size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

销毁链表的实现

同样遍历一遍，将每个节点释放掉，最后再将头结点释放

void ListDestory(ListNode* phead)
{
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL; //置空不起作用，传的是一级指针，想要改变必须传二级
}

这里需要注意的是对头结点置空病不起作用，因为是要改变头结点的值，所以得传二级指针，但我们为了保证接口的一致性，采用以下方法解决

调用完后在对它进行置空

到此带头双向循环链表完全实现

最后我们不禁想到，如果我们要实现一个带头循环双向循环链表，最主要的核心就是实现插入和删除的接口，头删头插等，对插入与删除的接口进行复用即可

完整代码如下：

DList.h部分

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>

typedef int LTDataType;
typedef struct ListNode
{
	struct ListNode* next;
	struct ListNode* prev;
	LTDataType data;
}ListNode;

void ListPrint(ListNode*phead);
ListNode* BuyListNode(LTDataType x);
ListNode* ListInit();

//不需要传二级指针，因为是带头实现的
void ListPushBack(ListNode* phead, LTDataType x);
void ListPushFront(ListNode* phead, LTDataType x);
void ListPopBack(ListNode* phead);
void ListPopFront(ListNode*phead);

ListNode* ListFind(ListNode* phead, LTDataType x);
void ListInsert(ListNode*pos,LTDataType x);
void ListErase(ListNode*pos);

//检测链表是否为空，空则返回0，否则返回1
int ListEmpty(ListNode* phead);

//检测链表中节点的个数
int ListSize(ListNode* phead);

void ListDestory(ListNode* phead);

list.c部分

#include "Dlist.h"



ListNode* BuyListNode(LTDataType x)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));
	node->next = NULL;
	node->prev = NULL;
	node->data = x;
    return node;
}

ListNode* ListInit()
{
	ListNode* phead = BuyListNode(0);
	phead->next = phead;
	phead->prev = phead;

	return phead;
}

void ListPushBack(ListNode* phead, LTDataType x)
{
	/*assert(phead);
	ListNode* tail = phead->prev;
	ListNode* newnode = BuyListNode(x);

	tail->next = newnode;
	newnode->prev = tail;
	newnode->next = phead;
	phead->prev = newnode;*/

	ListInsert(phead, x);//复用
}

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

	
}

void ListPushFront(ListNode* phead, LTDataType x)
{
	/*assert(phead);
	ListNode* first = phead->next;
	ListNode* newnode = BuyListNode(x);
	phead->next = newnode;
	newnode->prev = phead;
	newnode->next = first;
	first->prev = newnode;*/

	ListInsert(phead->next, x); //复用

}
void ListPopBack(ListNode* phead)
{
	/*assert(phead);
	assert(phead->next != phead);

	ListNode* tail = phead->prev;
	ListNode* tailPrev = tail->prev;
	free(tail);

	tailPrev->next = phead;
	phead->prev = tailPrev; */

	ListErase(phead->prev);
}
void ListPopFront(ListNode* phead)
{
	/*assert(phead);
	assert(phead->next != phead);

	ListNode* first = phead->next;
	ListNode* second = first->next;
	free(first);
	phead->next = second;
	second->prev = phead;*/

	ListErase(phead->next);
}

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;
}
void ListInsert(ListNode* pos, LTDataType x)
{
	assert(pos);
	ListNode* prev = pos->prev;
	ListNode* newnode = BuyListNode(x);
	prev->next = newnode;
	newnode->prev = prev;
	newnode->next = pos;
	pos->prev = newnode;

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

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

}


int ListEmpty(ListNode* phead)
{
	assert(phead);
	return phead->next == phead ? 0 : 1;
}
int ListSize(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	int size = 0;
	while (cur != phead)
	{
		size++;
		cur = cur->next;
	}
	return size;
}

void ListDestory(ListNode* phead)
{
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
	phead = NULL; //置空不起作用，传的是一级指针，想要改变必须传二级
}

Test.c 部分

#define _CRT_SECURE_NO_WARNINGS 1
#include"Dlist.h"

void ListTest1()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListPushFront(plist, 0);
	ListPushFront(plist, 0);
	ListPushFront(plist, 0);
	ListPrint(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);
}

void ListTest2()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListNode* pos = ListFind(plist,3);
	if (pos)
	{
		printf("找到了\n");
	}
	else
	{
		printf("没找到\n");
	}
	ListInsert(pos, 400);
	ListPrint(plist);

}

void ListTest3()
{
	ListNode* plist = ListInit();
	ListPushBack(plist, 1);
	ListPushBack(plist, 2);
	ListPushBack(plist, 3);
	ListPushBack(plist, 4);
	ListPushBack(plist, 5);
	ListPrint(plist);
	ListPushFront(plist, 3);
	ListPushFront(plist, 3);
	ListPushFront(plist, 3);
	ListPushFront(plist, 3);
	ListPushFront(plist, 3);
	ListPushFront(plist, 3);
	ListPrint(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPopBack(plist);
	ListPrint(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	ListPopFront(plist);
	ListPrint(plist);
	
	ListDestory(plist);
	plist = NULL; //不传二级指针，在这里置空一下就可，推荐这种做法，保持接口的一致性

}

int main()
{
	ListTest3();

}

Test部分中的 ListTest1（）， ListTest2（）, ListTest3（）,都可运行

下面只做 ListTest3（）的演示

cls-evd

关注

6
点赞
踩
4

收藏

觉得还不错? 一键收藏
7
评论
数据结构之[双链表的是实现]【保姆级讲解】

上篇文章我们实现了链表中两大重要链表之一无头单项非循环链表，这次我们来实现带头双向循环链表。话不多说上图：带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。另外这个结构虽然结构复杂，但是使用代码实现以后会发现结构会带来很多优势，实现反而简单了，后面我们代码实现了就知道了。废话不多说我们进入正题：进行带头双向循环链表的实现根据上图我们可以看出，该链表需要存储两个指针，所以我们在定义的时候就需要一前一后俩指...
复制链接

扫一扫

专栏目录