数据结构-循环链表

于 2024-09-14 18:00:00 发布
阅读量636 收藏 12
点赞数 18
分类专栏： 数据结构 链表 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69032433/article/details/142235957
版权


    循环链表 

        单链表和双链表 
            如果遍历到最后一个节点, 需要返回到第一个节点, 则需要重新遍历一次 


        循环链表 "首尾相连"

            单链表: 
                最后一个节点的next 指向 第一个节点  -->  单向循环链表 

            双向链表 
                最后一个节点的next 指向 第一个节点 
                第一个节点的prev 指向 最后一个节点  -->  双向循环链表 


    1) 单向循环链表 

            构造: 
                typedef int ElemType;   //数据元素中 数据的类型
                typedef struct node             //数据元素的类型
                {
                    ElemType data;          //数据域  --> 存储数据 
                    struct node * next;     //指针域  --> 保存逻辑上的关系(下一个)
                } Node;

                //链表的头结点的类型 
                typedef struct List 
                {
                    Node * first;   //指向链表的第一个节点(head)
                    Node * last;    //指向链表的最后一个节点(tail)
                    int num;        //保存链表的数据元素的个数
                    //... 
                } List ;

            基本操作:  增删改查 

        
            注意: 
                1) 首尾相连 
                    if( list->num != 0 )    //链表不为空 
                    {
                        list->last->next  =  list->first;
                    }

                2)遍历时, 循环条件变为节点个数
                    int n = list->num;
                    while( n-- )    //遍历 
                    {
                    }

            练习: 
                1)根据用户输入的数据的顺序, 创建一个带头结点的单向循环链表
                    并将新链表返回, 然后再打印输出 

                    CircleLinkedListWithHead.c   /  CircleLinkedListWithHead.h 

List * create_Circle_list()
{
    //1.创建一个头结点, 并初始化
    List * list = (List*)malloc( sizeof(List) ); 
    list->first = NULL;	
    list->last = NULL;
    list->num = 0;

    ElemType d;
    while(1)
    {
    	//2.从键盘上获取数据  
    	scanf("%d", &d );
    	if( d == 0 )
    	{
			break;
    	}

		//创建新数据节点 并初始化
    	Node * pnew = (Node*)malloc( sizeof(Node) );
    	pnew->data = d;
    	pnew->next = NULL;

    	//3.把新节点 加入到链表中
    	if( list->first == NULL )  //从无到有
    	{
    		list->first = pnew;
    		list->last = pnew;
    	}
		else 	//从少到多
		{
			//尾插法
			list->last->next = pnew;
			list->last = pnew;

			//头插法
			//pnew->next = list->first;
			//list->first = pnew;
		}

		list->num ++;	//元素个数+1
		
	}

	//4.首尾相连 ☆☆☆
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
	}
	
    //5.将新链表返回(返回头结点)
    return list;
}
void print_list( List * list )
{
	if( list == NULL )
	{
		printf("list is NULL \n");
		return ;
	}

	Node * p = list->first;		//遍历指针 
	int n = list->num ;		
	while( n-- )
	{
		printf("%d ", p->data );
		p = p->next;
	}
	putchar('\n');

	printf("num = %d\n\n", list->num );
}

                    main.c  

                        #include "CircleLinkedListWithHead.h"

                        int main()
                        {

                        }


                2)根据用户输入的数据的顺序, 逆序创建一个带头结点的单链表 
                    并将新链表返回 

                        //头插法 


                3) 创建一个带头结点的升序链表 

List *create_sort_Circle_list()
{
	//1.创建一个头结点, 并初始化
    List * list = (List*)malloc( sizeof(List) ); 
    list->first = NULL;	
    list->last = NULL;
    list->num = 0;

    ElemType d;
    while(1)
    {
    	//2.从键盘上获取数据  
    	scanf("%d", &d );
    	if( d == 0 )
    	{
			break;
    	}

		//创建新数据节点 并初始化
    	Node * pnew = (Node*)malloc( sizeof(Node) );
    	pnew->data = d;
    	pnew->next = NULL;

    	//3.把新节点 加入到链表中
    	if( list->first == NULL )  //从无到有
    	{
    		list->first = pnew;
    		list->last = pnew;
    	}
		else 	//从少到多
		{
			//(找到第一个比它大的数的前面进行插入,没有找到就尾插)
			Node * p = list->first;		//遍历指针 
			Node * pre = NULL;			//记录p的前一个

			int n = list->num;	

			while( n-- )
			{
				if( p->data > pnew->data )
				{
					break;	//找到了
				}
				pre = p;
				p = p->next;
			}

			if( n == -1 )	//没有找到
			{
				//尾插 
				list->last->next = pnew;
				list->last = pnew;				
			}
			else 	//找到了
			{
				if( p == list->first )	//比第一个节点还要小,那么就头插
				{
					//头插
					pnew->next = list->first;
					list->first = pnew;
				}
				else 
				{
					//中间插入
					pre->next = pnew;
					pnew->next = p;
				}
			}
			
		}

		list->num ++;	//元素个数+1
		
	}
	
	//4.首尾相连 ☆☆☆
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
	}
	
    //5.将新链表返回(返回头结点)
    return list;
}


                
                4)在链表中查找所有值为x的节点, 将其全部删除 
                    若没有找到就不删除, 将新链表返回 

List * delete_all_x_node( List * list , ElemType x )
{
	if( list == NULL )
	{
		printf("list is NULL \n");
		return NULL;
	}

	//1.查找值为x的节点
	Node * p = list->first;		//遍历指针 
	Node * pre = NULL;			//记录p的前一个

	int n = list->num;
	
	while( n-- )	//遍历, 查找值为x的节点
	{
		if( p->data == x )
		{
			//找到了
			list->num --;	//元素个数 -1 
		
			//2.执行删除操作 
			if( p == list->first )	//删除第一个
			{
				list->first = list->first->next;
				p->next = NULL;
				free( p );

				if( list->num == 0 )	// list->first == NULL 
				{
					//把链表仅剩的一个节点都删除了
					list->last = NULL;
				}

				p = list->first;	
				
			}
			else if( p == list->last )		//删除最后一个
			{
				list->last = pre;
				pre->next = NULL;
				free( p );

				p = NULL;
				
			}
			else	//删除中间  
			{
				pre->next = p->next;
				p->next = NULL;
				free( p );

				p = pre->next;
			}
		}
		else 
		{
			pre = p;
			p = p->next;
		}
	}

	//3.首尾相连 ☆☆☆
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
	}
	
    //4.将新链表返回(返回头结点)
    return list;

}


                
                5)在链表中查找值为x的节点, 将所有值为x的节点的值 修改成a 
                    若没有找到就不修改, 将新链表返回 

List * update_node( List * list , ElemType x , ElemType a )
{
	if( list == NULL )
	{
		printf("list is NULL \n");
		return NULL;
	}

	Node * p = list->first;		//遍历指针 

	int n = list->num;
	
	while( n-- )
	{
		if( p->data == x )
		{
			p->data = a;
		}
		p = p->next;
	}

	return list;
}

                6)销毁一条链表 
                        遍历 先释放每一个数据节点
                            再释放头结点

                    

void destroy_list( List * list )
{
	if( list == NULL )
	{
		printf("list is NULL \n");
		return ;
	}

	Node * p = list->first;		//遍历指针 

	int n = list->num;
	
	while( n-- )
	{
		//遍历 先释放每一个数据节点
		list->first = list->first->next;
		p->next = NULL;
		free( p );

		p = list->first;
	}

	//再释放头结点
	list->num = 0;
	//list->first = NULL;	//上面的循环 已经把first置NULL了
	list->last = NULL;
	free( list );
}

    2)双向循环链表 

        构造: 
                //数据元素的类型 
                typedef int ElemType;       //数据元素中数据的类型
                typedef struct node 
                {
                    ElemType data;          //数据域 --> 存储数据 
                    struct node * next;     //指针域 --> 保存逻辑上的下一个
                    struct node * prev;                 //保存逻辑上的上一个
                } DNode;

                //头结点的类型 
                typedef struct List 
                {
                    struct node * first;      //指向链表的第一个节点
                    struct node * last;       //指向链表的最后一个节点
                    int num;            //记录链表中元素的个数 
                    //...
                } DList;

        基本操作: 
                增删改查 

        注意: 
            (1)首尾相连 
                if( list->num != 0 )    //链表不为空 
                {
                    list->last->next  =  list->first;
                    list->first->prev =  list->last;
                }

            (2)遍历时,循环条件变为节点个数
                int n = list->num;
                while( n-- )    //遍历 
                {
                }


        练习: 
            1) 根据用户输入的数据的顺序, 创建一个带头结点的双向循环链表
                将新链表返回,  然后再打印输出

                CircleBothwayLinkedListWithHead.c   /   CircleBothwayLinkedListWithHead.h  

                    

DList * create_Circle_bothway_list()
{
    //1.创建一个头结点, 并初始化
	DList * list = (DList *)malloc( sizeof(DList) );
	list->first = NULL;
	list->last = NULL;
	list->num = 0;

    ElemType d;
    while(1)
    {
	    //2.获取数据 
		scanf("%d", &d );
		if( d == 0 )
		{
			break;
		}
	    
	    //3.创建数据节点,并初始化 
		DNode * pnew = (DNode*)malloc( sizeof(DNode) );
		pnew->data = d;
		pnew->next = NULL;
		pnew->prev = NULL;
	    
	    //4.把新节点 加入到链表中 
		if( list->first == NULL )	//从无到有 
		{
			list->first = pnew;
			list->last = pnew;
		}
		else	//从少到多 
		{
			//尾插法 
			list->last->next = pnew;
			pnew->prev = list->last;
			list->last = pnew;

			//头插法
			//pnew->next = list->first;
			//list->first->prev = pnew;
			//list->first = pnew;
			
		}
		list->num ++;	//元素个数 +1 
	}

	//5.首尾相连 
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
		list->first->prev = list->last;
	}	

    //6.将新链表返回 
    return list;
}

                    

void print_list( DList * list )
{
	if( list == NULL )	//链表不存在 
	{
		printf("list is NULL \n");
		return ;
	}

	//正向
	DNode * p = list->first;	//遍历指针 

	int n = list->num;
	
	while( n-- )
	{
		printf("%d ", p->data );
		p = p->next;
	}
	putchar('\n');

	//倒序
	p = list->last;
	n = list->num;
	while( n-- )
	{
		printf("%d ", p->data );
		p = p->prev;
	}
	putchar('\n');

	printf("num = %d\n\n", list->num );
	
}

                main.c  
                    #include "CircleBothwayLinkedListWithHead.h"

                    int main()
                    {
                    }


            2)根据用户输入的数据的顺序, 逆序创建一个带头结点的双向链表
                将新链表返回,  然后再打印输出 

                    //头插法 

            3)根据用户输入的数据, 创建一个有序的带头结点的双向链表 (升序), 将新链表返回

                /*
                    分情况讨论:
                        比第一个还要小, 头插法
                        比最后一个还要大, 尾插法
                        中间插入, 找到第一个比它大的数的前面进行插入

                            注意: 中间插入时, 先赋值pnew的成员, 再去修复前后的关系 
                                                ☆☆☆
                */

DList * create_sort_Circle_bothway_list()
{
	//1.创建一个头结点, 并初始化
	DList * list = (DList *)malloc( sizeof(DList) );
	list->first = NULL;
	list->last = NULL;
	list->num = 0;

    ElemType d;
    while(1)
    {
	    //2.获取数据 
		scanf("%d", &d );
		if( d == 0 )
		{
			break;
		}
	    
	    //3.创建数据节点,并初始化 
		DNode * pnew = (DNode*)malloc( sizeof(DNode) );
		pnew->data = d;
		pnew->next = NULL;
		pnew->prev = NULL;
	    
	    //4.把新节点 加入到链表中
	    if( list->first == NULL )	//从无到有
	    {
			list->first = pnew;
			list->last = pnew;
	    }
	    else	//从少到多 
	    {
	    	/*
				分情况讨论:
					比第一个还要小, 头插法
					比最后一个还要大, 尾插法
					中间插入, 找到第一个比它大的数的前面进行插入
	    	*/
			DNode * p = list->first;		//遍历指针 
			
			int n = list->num;
			
			while( n-- )
			{
				if( p->data > pnew->data )
				{
					break; 	//找到了
				}
				p = p->next;
			}

			if( n == -1 )	//没找到 
			{
				//尾插法
				list->last->next = pnew;
				pnew->prev = list->last;
				list->last = pnew;
			}
			else	//找到了 
			{
				if( p == list->first )	
				{
					//头插法
					pnew->next = list->first;
					list->first->prev = pnew;
					list->first = pnew;
				}
				else 
				{
					//中间插入
					//注意: 先赋值pnew的成员, 再去修复前后的关系
					pnew->next = p;
					pnew->prev = p->prev;
					p->prev->next = pnew;
					p->prev = pnew;
				}
			}
	    }
		list->num ++;	//元素个数 +1
	    
	}

	//5.首尾相连 
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
		list->first->prev = list->last;
	}

	//6.将新链表返回
	return list;
}


     
            4)在双向链表中找到值为x的节点, 将其全部删除 
                如果没有找到 就不删除, 将新链表返回 

                    注意: 删除中间节点时, 先去修复前后的关系, 再去断开自身的连接  
                                                ☆☆☆

DList * delete_all_x_node( DList * list, ElemType x )
{
	if( list == NULL )	//链表不存在 
	{
		printf("list is NULL \n");
		return NULL;
	}

	//1.找到值为x的节点
	DNode * p = list->first;	//遍历指针 
	
	int n = list->num;

	while( n-- )
	{
		if( p->data == x )
		{
			//找到了,就删除(分情况讨论)
			list->num --;	//元素个数 -1 

			if( p == list->first )	//删除第一个节点 (要考虑只剩下一个节点的情况)
			{
				list->first = list->first->next;
				if( list->first != NULL )	// list->num != 0 
				{
					list->first->prev = NULL;
				}
				p->next = NULL;

				free( p );

				p = list->first;	//p从下一个开始再去找

				//当唯一的一个节点也删除了  	
				if( list->first == NULL )	// list->num == 0
				{
					list->last = NULL;
				}
			}
			else if( p == list->last )	//删除最后一个节点
			{
				list->last = list->last->prev;
				if( list->last != NULL )
				{
					list->last->next = NULL;
				}
				p->prev = NULL;

				free( p );
				
				p = NULL;	//已经删到末尾了,就不需要继续了
			}
			else 	//删除中间的节点
			{
				DNode * temp = p->next;

				//先去修复前后的关系, 再去断开自身的连接  
				p->prev->next = p->next;
				p->next->prev = p->prev;
				p->next = NULL;
				p->prev = NULL;

				free( p );

				p = temp;	//继续往下找
			}
			
		}
		else 
		{
			//没找到. 就继续往下找 
			p = p->next;
		}
	}

	//5.首尾相连 
	if( list->num != 0 )	//链表不为空
	{
		list->last->next = list->first;
		list->first->prev = list->last;
	}

	//将新链表返回
	return list;
}

            5)在双向链表中找到值为x的节点, 将所有值为x的节点的值 修改成a 
                没有找到就不修改, 将新链表返回 

DList * update_node( DList * list, ElemType x , ElemType a )
{
	if( list == NULL )	//链表不存在 
	{
		printf("list is NULL \n");
		return NULL;
	}

	DNode * p = list->first;		//遍历指针 

	int n = list->num;
	
	while( n-- )
	{
		if( p->data == x )	//找到了
		{
			p->data = a;
		}
		p = p->next;
	}

	return list;
}

            6)销毁一条双向链表
                    先释放每一个数据节点 
                    再去释放头结点

void destroy_list( DList * list )
{
	if( list == NULL )	//链表不存在 
	{
		printf("list is NULL \n");
		return ;
	}

	DNode * p = list->first;	//遍历指针 

	int n = list->num;

	//先释放每一个数据节点 
	while( n-- )
	{
		list->first = list->first->next;
		if( list->first != NULL )
		{
			//如果是删除最后一个节点时, first再往下走就已经为NULL了,
			//再去访问这个prev就会产生"段错误"
			list->first->prev = NULL;
		}
		p->next = NULL;

		free(p);

		p = list->first;
	}

    //再去释放头结点
    list->first = NULL;
    list->last = NULL;
    list->num = 0;
    free( list );
}

幸苦的马侬
关注
专栏目录
Java数据结构-循环链表的设计与实现
m0_52846268的博客
11-28 1059
循环链表： 循环链表是另一种形式的链式存储结构。它的特点是表中最后一个结点的指针域指向头结点，整个链表形成一个环。 单循环链表的实现—链表增删改查功能 代码实现： public class MyCircleLinkedList { private Node head;//头结点, 不存数据 private Node tail;//尾结点, 指向链表的最后一个节点 private int size; public MyCircleLinkedList() {
Java数据结构-循环链表的设计与实现(头歌平台，详细注释)
qwertf123的博客
09-25 1727
Java数据结构-循环链表的设计与实现
数据结构 -- 链表详解
hu_143的博客
04-27 2576
链表详解，重点讲解两种常用的链表，看到就是赚到！！！
数据结构-单向循环链表
没出过地球
06-11 2051
定义：单向环形链表是指在单链表的基础上，最后一个节点的指针域指向链表的第一个节点，从而构成一个闭合的环。结构：每个节点包含一个数据域和一个指针域。数据域用于存储数据，指针域用于指向下一个节点。在单向环形链表中，最后一个节点的指针域指向第一个节点，形成环状结构。
数据结构-循环双链表
lzlyxxn的博客
05-08 1497
循环链表，就是把链表给首尾相连，即尾结点的next指向L头结点，而循环双链表不仅尾结点指向头结点，且头结点的prior指向尾结点，判断为空时，只要看尾结点下一个是否指向头结点，循环链表的操作和链表的操作差别并不大。 循环双链表的创建、插入、删除 #include<iostream> #include<cstdlib> using namespace std; typedef int ElemType; typedef struct CNode{ ElemType data;
数据结构-循环链表-C语言实现循环链表功能-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 实现了以下功能： 创建无头循环链表 向循环链表中插入...
数据结构-循环链表-C语言实现约瑟夫圈-数据结构学习
05-26
C语言实现的数据结构中的循环链表 包含源码（.c文件），linux环境下编译生成的可执行文件，头文件，以及使用循环链表实现的约瑟夫圈的main.c文件 用于C语言以及数据结构的学习，熟练对循环链表边界的判定 此外循环...
漫话数据结构-双向链表及基本操作.pptx
11-03
"漫话数据结构-双向链表及基本操作"的讲座涵盖了双向链表的概念、构建、插入和删除操作，以及双向循环链表的特性。这些知识对于理解和掌握数据结构的基础至关重要，同时也是提升编程技能和解决实际问题能力的重要...
21_动态规划与数据结构结合
刘炫320的博客
09-11 569
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
数据结构 Java DS——分享部分链表题目 (2)
cjejwe的博客
09-10 971
关于JAVA的链表,笔者已经写了两篇博客来介绍了,今天给笔者们带来第三篇,也是分享了一些笔者写过的,觉得挺好的题目,链接也已经挂上了,笔者们可以去看看。
浙大数据结构：05-树7 堆中的路径
qq_74924951的博客
09-11 688
int size;}* Heap;int size;} *Heap;return H;int i;for (;for (;x;i < n;int f = 0;i < l;f = 1;return 0;
数据结构之红黑树的 “奥秘“
robin_suli的博客
09-09 1092
红黑树在经常进行增删的结构中性能比 AVL树更优，而且红黑树实现比较简单，所以实际运用中红黑树更多。红黑树不追求绝对平衡，其只需保 证最长路径不超过最短路径的2倍(相对平衡)每个结点上增加一个存储位表示结点的颜色。红黑树和AVL树都是高效的平衡二叉树。没有一条路径会比其他路径长出俩倍。先grandParent右旋。围绕红黑树上面的几条性质。
数据结构 - 栈
最新发布
kaneki_lh的博客
09-13 494
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
0基础跟德姆（dom）一起学AI Python进阶10-算法和数据结构
chrisfanallin的博客
09-11 1301
AI全流程带你玩 0基础带你学人工智能相关软件，讲解机器学习、深度学习、大模型等人工智能领域核心知识。 帮助想了解，或者正在AI赛道成长的你。
从零开始学数据结构系列之第六章《排序简介》
铁匠匠匠的博客
09-12 1058
​所谓排序，就是使一串数据，按照其中的某个或某些关键字的大小，递增或递减排列起来的操作。
数据结构应用实例(三)——赫夫曼编码
Blogs of zcy1221
09-10 1106
如果其有父节点，如果为父节点的左孩子，编码尾部添加 ‘0’，如果为右孩子，尾部添加 ‘1’，然后向根节点移动：当前节点变为其父节点，父节点变为父节点的父节点，进行相同操作。4、 进行 Huffman 编码时，由于是从叶子节点开始向前回溯到根节点，所以编码时从后向前进行，这样就避免了逆置编码；(2)在 F 中选取两棵根节点权值最小的树作为左右子树构造一棵新二叉树，其根节点的权值为两棵子树根节点权值之和；如果 num<=1，进行相关信息的显示，不进行 Huffman 编码；然后，统计出现过的字母个数 num；
《C++位域：在复杂数据结构中的精准驾驭与风险规避》
xy520521的博客
09-10 656
通过明确位域的用途和限制、避免跨平台依赖、小心赋值和读取、谨慎使用指针操作以及考虑内存对齐和布局等方法，可以正确地使用位域，发挥其优势，同时确保程序的正确性和稳定性。在 C++的广阔编程世界中，位域作为一种强大的工具，可以在复杂数据结构中实现高效的内存利用和特定的数据表示。只有这样，我们才能在复杂的数据结构中精准驾驭位域，避免未定义行为，为开发高质量的 C++程序奠定坚实的基础。例如，在图像编码中，可以使用位域来表示像素的颜色值，将红、绿、蓝三个颜色通道的值压缩到较少的位数中。尽量避免使用指针操作位域。
一天一道算法题day02
m0_74004434的博客
09-06 1838
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值