拿捏循环链表

目录:

一:单链表(不带头单向不循环)与循环链表(带头双向循环)区别

二:循环链表初始化

三:循环链表头插

四:循环链表尾插

五:循环链表头删

六:循环链表尾删

七:循环链表查找

八:循环链表指定pos  位置的删除

九:循环链表指定pos  位置之前的插入

十:循环链表销毁

十一:结语


1:单链表(不带头单向不循环)与循环链表(带头双向循环)区别
1)结构上

循环链表多了给 前驱指针 pre 

拿捏循环链表_第1张图片

2)链表增删查改

有了pre这个指针,效率大大提升

2:循环链表初始化

讲到初始化,这里主要就是对哨兵位 (暂时称为:phead)进行设置

注意:哨兵位只是占一个位置,并不存储任何有效的数据

循环链表初始状态是空的:phead 自己成环

 拿捏循环链表_第2张图片

 对应代码:

phead -> next = phead ;

phead -> pre  = phead ;

那么问题就来了,在设计这个初始化函数的时候用一级指针还是二级指针

拿捏循环链表_第3张图片

想必,前期看过我的单链表的博客,自然会说二级指针呀:

 因为是对phead 这个指针进行改变所以是传二级指针。没毛病!不知道大家在做OJ题的时候,我们也涉及到对一级指针的改变,但是我们也可以返回这个一级指针,即可实现

ListNode* ListNodeInit()
{
	/*
	哨兵位:val 没有实际意义(自行赋值)
	初始化的目的就是对哨兵位进行设置
	因为整个接口都是用一级指针,若是初始化用二级指针有点不顺眼
	此函数返回哨兵位地址即可实现对哨兵位的初始化
	*/
	ListNode* phead = NULL;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	phead = newnode;
	phead->val = -1;
	phead->pre = phead->next = phead;//够成环
	return phead;
}
3:循环链表头插

头插:即在哨兵位的后面进行头插(若是链表为空,此时的头插也即是尾插)

头插分析:显然我们只需改变指针走向即可

注意指针先后问题

拿捏循环链表_第4张图片

 各位老铁康康这样的代码是否之正确:

phead-> next = newnode;

newnode-> next = phead-> next;

newnode-> pre = phead;

newnode->next-> pre = newnode;

 拿捏循环链表_第5张图片

此代码结合画图,来看, 显然这样是不对的,因为newnode-> next = phead-> next;这句代码让newnode 这个节点自己成环了,所以又怎么可能头插进去呢?

实质性原因是:当我们头插进来newnode 时,应该先执行

newnode-> next = phead->next;   //注意指针先后问题

phead->next->pre = newnode; //让原来头结点的 pre 指向newndoe

newnode-> pre = phead;

phead-> next = newnode;

	ListNode* newnode = BuyNode(x);
	newnode->next = phead->next;
	newnode->pre = phead;
	phead->next->pre = newnode;//原来第一个节点pre与新的头结点连接
	phead->next = newnode;//新的头结点

对于以上问题还可以这样解决:定义一个 next指针来保留一下原来的头结点

4:循环链表尾插

尾差之前我们需要先思考一个问题:对于单链表(不循环,不带头,单向)而言,每次尾插之前都需要遍历链表,来找尾结点

但是对于循环链表而言我们就不需要:找尾结点直接一步到位  phead-> pre

真的是没有对比就没有伤害,所以在这块,咱循环链表还是比较好搞滴

尾插分析:

拿捏循环链表_第6张图片

 这里只需改变指针走向即可

代码:

void ListNodePushBack(ListNode* phead,DataType x)
{
	assert(phead);
	/*
	1:找尾结点 phead->pre
	2:指针连接 
	*/
	ListNode* newnode = BuyNode(x);
	newnode->next = phead;
	newnode->pre = phead->pre;
	phead->pre->next = newnode;//原来尾结点与newnode进行连接
	phead->pre = newnode;//新的尾结点
	
}
5:循环链表头删

依然如此,按照“国际惯例”:找头结点  phead -> next 

删除之前先保留一下 第二个节点  

当把链表所以节点删除后(除哨兵位),会自动保存一个循环链表

拿捏循环链表_第7张图片

 代码见下:

void ListNodePopFront(ListNode* phead)
{
	assert(phead->next != phead);//不相等说明不为空
	ListNode* newFirst = phead->next->next;
	newFirst->pre = phead;

	phead->next = newFirst;//成为新的头结点
	//以下写法也对,但可读性差
	phead->next = phead->next->next;
	phead->next->pre = phead;


}
6:循环链表尾删

 既然谈到尾删,咱这里不得不提一嘴,单链表的尾删

单链表尾删逻辑:

1:链表不为空

2:只有一个节点:传二级指针

3:多个节点:传一级指针

4:找尾结点: 条件 tail -> next != NULL;

 咱就是说,是不是事很多。

相比较之下,循环链表就比较友好:找啥尾结点,直接一步到位  phead-> pre

直接改变指针走向即可。

老问题:保留一下尾结点的前一个节点 tailPre

void ListNodePopBack(ListNode* phead)
{
	assert(phead);
	/*
	空链表: 
	1:找尾结点 phead->pre
	2:成环:  改变新的尾结点与phead 直接的链接
	*/
	assert(phead->next != phead);//不相等说明链表不为空,为空不能删除

	ListNode* tail = phead->pre;
	ListNode* tailPre = tail->pre;
	phead->pre = tailPre;//新的尾结点
    tailPre->next = phead;
    free(tail);
}
7:循环链表查找

此函数可以实现2个功能:一个是查找;另一个是修改

逻辑:按值查找,若是存在,直接返回当前节点,否则返回 NULL

注意是从 第一个节点开始 而不是从哨兵位 开始

ListNode* Find(ListNode* phead, DataType x) //指定数据查找
{
	/*
	从第一个节点开始查找: phead->next
	依次遍历,若是存在返回节点
	否则返回NULL
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead )  //phead 是哨兵位
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//没有找到
}
8:循环链表指定pos  位置的删除

这个接口的逻辑其实说白了与尾删没啥不同

注意:pos 这个节点是查找函数返回的

void ListNodeErase(ListNode* pos)//指定位置删除  pos是查找函数返回的
{
	assert(pos);
	ListNode* posPre = pos->pre;
	ListNode* posNext = pos->next;
	posPre->next = posNext;
	posNext->pre = posPre;
	free(pos);
}
9:循环链表指定pos  位置之前的插入

void ListNodeInsert(ListNode* pos, DataType x)//指定位置之前插入
{
	/*
	1:找到pos 前一个节点  pos->pre
	2:注意避免节点找不到
	3:改变指针连接: posPre,newnode,pos
	*/
	assert(pos);//为空直接不玩了
	ListNode* newnode = BuyNode(x);
	ListNode* posPre = pos->pre;
	posPre->next = newnode;
	newnode->pre = posPre;
	newnode->next = pos;
	pos->pre = newnode;

}
10:循环链表销毁

这里的销毁就是一个节点一个节点进行删除

注意:包括哨兵位在内

void ListNodeDestroy(ListNode* phead)
{
	/*
	注意哨兵位也需要删除
	一个节点一个节点删除
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}

 各位老铁们,别走开,接下来的问题你值得一看,或许哪天自己面试会遇到类似问题呢?

拿捏循环链表_第8张图片

 前段时间看到过样一个问题:

有个求职者去面试:在他的简历上写着自己是比较熟练数据结构这个模块的。

面试官问了这样一个问题:你能否在10分钟之内,搞一个链表出来?

听到这,求职者心里多多少少是有点担忧“搞,是没有问题,但是这个时间能否在宽裕点……”

进过这种协商,时间定在15分钟

对于这个问题的答卷:很显然,这个求职者没有拿到100分

拿捏循环链表_第9张图片

屏幕前的各位铁子们,假设你是那个求职者,你又会如何回答好这份答卷?

是的,要是我,我一定会用循环链表来搞呀(因为面试官有没有指定具体是8中链表的哪一种)

你仔细想想:循环链表效率多高呀

对于一个链表的基本操作无非不就是:

头删头插

尾删,尾插

任意位置的插入和删除

不知道你是否考虑过这样问题:

循环链表的尾插,头插其实就是任意位置插入的一个特例

尾删,头删其实就是任意位置的删除的一个特例

 完整代码如下:
DList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"
void ListNodePrint(ListNode* phead)
{
	assert(phead);
	ListNode* cur = phead->next;
	printf("guard<==>");
	while (cur != phead)
	{
		printf("%d<==>", cur->val);
		cur = cur->next;
	}
	printf("\n");
}
ListNode* ListNodeInit()
{
	/*
	哨兵位:val 没有实际意义(自行赋值)
	初始化的目的就是对哨兵位进行设置
	因为整个接口都是用一级指针,若是初始化用二级指针有点不顺眼
	此函数返回哨兵位地址即可实现对哨兵位的初始化
	*/
	ListNode* phead = NULL;
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	phead = newnode;
	phead->val = -1;
	phead->pre = phead->next = phead;//够成环
	return phead;
}

ListNode* BuyNode(DataType x)
{
	ListNode* newnode = (ListNode*)malloc(sizeof(ListNode));
	if (newnode == NULL)
	{
		perror("malloc fail");
		return NULL;
	}
	newnode->val = x;
	newnode->next = NULL;
	newnode->pre = NULL;
	return newnode;
}
void ListNodePushBack(ListNode* phead,DataType x)
{
	assert(phead);
	/*
	1:找尾结点 phead->pre
	2:指针连接 
	*/
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead;
	//newnode->pre = phead->pre;
	//phead->pre->next = newnode;//原来尾结点与newnode进行连接
	//phead->pre = newnode;//新的尾结点
	ListNodeInsert(phead, x);//注意ListNodeInsert  这个函数功能是在pos 之前插入,所以要想实现尾插,需要传phead ,而不是phead->pre 

}
void ListNodePushFront(ListNode* phead, DataType x)
{
	/*
	注意phead不是头结点(第一个节点),phead 只是一个哨兵位,只占位置
	第一个节点:phead->next
	考虑指针先后问题,避免找不到第一个节点(链表不为空)
	*/
	assert(phead);
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead->next;
	//newnode->pre = phead;

	//phead->next = newnode;//新的头结点
	以上代码不对
	//ListNode* newnode = BuyNode(x);
	//newnode->next = phead->next;
	//newnode->pre = phead;
	//phead->next->pre = newnode;//原来第一个节点pre与新的头结点连接
	//phead->next = newnode;//新的头结点
	ListNodeInsert(phead->next, x);

}

void ListNodePopBack(ListNode* phead)
{
	assert(phead);
	/*
	空链表: 
	1:找尾结点 phead->pre
	2:成环:  改变新的尾结点与phead 直接的链接
	*/
	assert(phead->next != phead);//不相等说明链表不为空,为空不能删除
	ListNodeErase(phead->pre);

	//ListNode* tail = phead->pre;
	//ListNode* tailPre = tail->pre;
	//phead->pre = tailPre;//新的尾结点
 //   tailPre->next = phead;
	//free(tail);
}
void ListNodePopFront(ListNode* phead)
{
	assert(phead->next != phead);//不相等说明不为空
	ListNodeErase(phead->next);
	//ListNode* newFirst = phead->next->next;
	//newFirst->pre = phead;

	//phead->next = newFirst;//成为新的头结点
	以下写法也对,但可读性差
	//phead->next = phead->next->next;
	//phead->next->pre = phead;


}
ListNode* Find(ListNode* phead, DataType x) //指定数据查找
{
	/*
	从第一个节点开始查找: phead->next
	依次遍历,若是存在返回节点
	否则返回NULL
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead )  //phead 是哨兵位
	{
		if (x == cur->val)
		{
			return cur;
		}
		cur = cur->next;
	}
	return NULL;//没有找到
}

void ListNodeInsert(ListNode* pos, DataType x)//指定位置之前插入
{
	/*
	1:找到pos 前一个节点  pos->pre
	2:注意避免节点找不到
	3:改变指针连接: posPre,newnode,pos
	*/
	assert(pos);//为空直接不玩了
	ListNode* newnode = BuyNode(x);
	ListNode* posPre = pos->pre;
	posPre->next = newnode;
	newnode->pre = posPre;
	newnode->next = pos;
	pos->pre = newnode;

}

void ListNodeErase(ListNode* pos)//指定位置删除  pos是查找函数返回的
{
	assert(pos);
	ListNode* posPre = pos->pre;
	ListNode* posNext = pos->next;
	posPre->next = posNext;
	posNext->pre = posPre;
	free(pos);
}
void ListNodeDestroy(ListNode* phead)
{
	/*
	注意哨兵位也需要删除
	一个节点一个节点删除
	*/
	assert(phead);
	ListNode* cur = phead->next;
	while (cur != phead)
	{
		ListNode* next = cur->next;
		free(cur);
		cur = next;
	}
	free(phead);
}
DList.h
#pragma once
#include
#include
#include

typedef int DataType;
typedef struct DListNode 
{
	DataType val;
	struct DListNode* next;
	struct DListNode* pre;//前驱指针

}ListNode;
void  ListNodePrint(ListNode*phead);
ListNode* ListNodeInit();

void ListNodePushBack(ListNode* phead,DataType x);
void ListNodePushFront(ListNode* phead, DataType x);

void ListNodePopBack(ListNode* phead);
void ListNodePopFront(ListNode* phead);

ListNode* Find(ListNode* phead,DataType x); //指定数据查找(此函数可以实现2个功能:查找 + 修改)

void ListNodeInsert(ListNode* pos, DataType x);//指定位置之前插入,pos是查找函数返回的

void ListNodeErase(ListNode* pos);//指定位置删除

void ListNodeDestroy(ListNode* phead);
/*
面试题目: 10分钟之内写一个链表
注意:头删,尾删 都只是 ListNodeErase 这个函数一个特例
头插,尾插,同理,是ListNodeInsert 一个特例
所以 可以借用
*/

test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"List.h"

void TestPush()
{
	ListNode* plist = ListNodeInit();
	
	//ListNodeInit(&plist);
	//ListNodePushBack(plist, 1);
	//ListNodePushBack(plist, 2);
	//ListNodePushBack(plist, 3);
	ListNodePushFront(plist, 1);
	ListNodePushFront(plist, 2);
	ListNodePushFront(plist, 3);
	ListNodePushFront(plist, 4);
	ListNodePushFront(plist, 5);
	ListNodePushFront(plist, 6);
	ListNodePushFront(plist, 7);
	ListNodePrint(plist);


	ListNodePushBack(plist, 0);
	ListNodePrint(plist);
	ListNodeDestroy(plist);


}
void TestPop()
{
	//ListNode* plist = (ListNode*)malloc(sizeof(ListNode));
	//if (plist == NULL)
	//	return;
	//plist->val = -1;
	//plist->next = plist;
	//plist->pre = plist;
	//等价于以下代码
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	//ListNodePopFront(plist);
	//ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);

	ListNodePopBack(plist);
	ListNodePrint(plist);
	ListNodeDestroy(plist);

}
void Test()
{
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNode* pos = Find(plist, 3);
	if (pos != NULL)
	{
		ListNodeInsert(pos, 10);
		ListNodePrint(plist);
	}
	else
	{
		printf("操作失败\n");
	}
	ListNodeDestroy(plist);

}

void Test1()
{
	ListNode* plist = ListNodeInit();

	ListNodePushBack(plist, 1);
	ListNodePushBack(plist, 2);
	ListNodePushBack(plist, 3);
	ListNode* pos = Find(plist, 3);
	if (pos != NULL)
	{
		ListNodeErase(pos);
		ListNodePrint(plist);
	}
	else
	{
		printf("操作失败\n");
	}
	ListNodeDestroy(plist);

}

int main()
{
	TestPush();
	//TestPop();
	//Test();
	//Test1();
	return 0;
}
11:结语

以上就是我今日要为大家share的内容。其实说白了,循环链表的结构看似复杂,实际操作起来,非常简单。(就是多了一个 pre这样的一个前驱指针)。希望各位老铁们能够从这篇博客中学到一些知识,同时欢迎大家随时指正,那咱话不多说,你懂滴!

你可能感兴趣的:(链表,数据结构,c语言,c++,visual,studio,vscode,算法)