数据结构-双向链表

已于 2024-09-15 22:36:41 修改
阅读量690 收藏 14
点赞数 16
分类专栏： 数据结构 链表 文章标签： 数据结构
于 2024-09-13 16:31:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_69032433/article/details/142213809
版权


    双向链表 
        一个数据节点 保存的数据 
                    保存逻辑上的下一个(后继节点)
                    也保存逻辑上的上一个(前驱节点)

        不带头结点的双向链表
        带头结点的双向链表 

    代码实现:  "带头结点的双向链表"

        //数据元素的类型 
        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)根据用户输入的数据的顺序, 创建一个带头结点的双向链表
                将新链表返回,  然后再打印输出 

                BothwayLinkedListWithHead.c   /   BothwayLinkedListWithHead.h  

                    

DList * create_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.将新链表返回 
    return list;
}

           

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

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

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

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

        

                main.c  
                    #include "BothwayLinkedListWithHead.h"

                    int main()
                    {                          

                   

                    }


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

                    //头插法 

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

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

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

DList * create_sort_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;		//遍历指针 
			while( p )
			{
				if( p->data > pnew->data )
				{
					break; 	//找到了
				}
				p = p->next;
			}

			if( p == NULL )	//没找到 
			{
				//尾插法
				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.将新链表返回
	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;	//遍历指针 

	while( p )
	{
		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;
		}
	}

	//将新链表返回
	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;		//遍历指针 
	while( p )
	{
		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;	//遍历指针 

	//先释放每一个数据节点 
	while( p )
	{
		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 );
}
幸苦的马侬
关注
专栏目录
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3704
双向链表
数据结构-双向链表的基本操作 （c语言实现）
weixin_59799963的博客
10-19 3623
1.创造一个节点,函数实现 DListNode* BuyListNode(Datetype x) { DListNode*node = (DListNode*)malloc(sizeof(DListNode)); node->date = x; node->next = NULL; node->prev = NULL; return node; } 2. 初始化 DListNode* DListInit() { DListNode*plist = BuyListNod
数据结构 - 双向链表
weixin_73869209的博客
09-07 1274
如上图所示,双向链表中包含了两个指针,一个指向前驱结点,一个指向后继节点,其中头结点没有前驱节点,尾结点没有后继节点前驱: 前驱指的是当前节点的前一个节点，即在链表中位于当前节点之前的节点。它可以通过前向指针（previous pointer）来访问。后继: 后继指的是当前节点的后一个节点，即在链表中位于当前节点之后的节点。它可以通过后向指针（next pointer）来访问。这篇博客大家应重点关注链表的设计,代码这个东西面试考的更多的是单链表,大家刷题更多的也是单链表,双向链表相对于就没有那么重要了。
数据结构--双向链表
m0_62706197的博客
06-24 994
为了和前几篇文章的链表做比较，双向链表结构体也尽量定义相似的。// 前驱指针// 后驱指针。
数据结构-双向链表操作
有朋自远方来，不亦乐乎。
08-05 1287
先创建好一个双向链表：代码： 结果： （1）加表头假设新元素节点为 temp，表头节点为 head，则需要做以下 2 步操作即可： （2）加表中 （3）加表尾 2、双向链表删除节点 只需遍历链表找到要删除的结点，然后将该节点从表中摘除即可 3、双向链表查找节点 双向链表同单链表一样，都仅有一个头指针。因此，双链表查找指定元素的实现同单链表类似，都是从表头依次遍历表中元素。 4、双向链表修改节点 通过遍历找到存储有该数据元素的结点，直接更改其数据域即可。 完整代码：
漫话数据结构-双向链表及基本操作.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 495
/指向栈的指针int maxlen;//表示栈的最大长度int top;//栈顶元素的下标，用来指明栈顶的位置}s//数据域名//指针，指向栈下一个元素。
0基础跟德姆（dom）一起学AI Python进阶10-算法和数据结构
chrisfanallin的博客
09-11 1302
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值的上限。
数据结构—栈和队列
weixin_74889808的博客
09-12 693
选择一个空队列负责实现元素压栈，当要出栈的时候就把队列的除了队尾元素的其他元素都放到另一个队列中，将队尾元素出队列就是实现出栈。后面如果有压栈操作，依旧是将元素压入不为空的队列，即——两个队列总有一个是空的，用来放除了栈顶元素的其他元素。一个栈同样不能实现队列，模拟实现队列需要两个队列，一个栈负责入队列，一个队列负责出队列和获取队头元素。出队列：将栈s1中所有的元素弹出栈，并压栈到栈s2，栈s2的栈顶元素就是模拟队列的队头元素。一个队列不能实现栈，因为队列的特性是头出尾进，要两个队列才能够实现栈。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值