数据结构3 单向循环链表+双向链表

最新推荐文章于 2024-11-10 22:49:00 发布
最新推荐文章于 2024-11-10 22:49:00 发布
阅读量38 收藏
点赞数
文章标签： 数据结构 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_80969098/article/details/134812242
版权

一、双向链表

功能函数

#include "./03_doublelinklist.h"

//创建空的双向链表
doulist* creat_doublelinklist()
{
	doulist* head = (doulist*)malloc(sizeof(doulist));
	if( NULL == head)
	{
		printf("创建空的双向链表失败\n");
		return NULL;

	}
	memset(head,0,sizeof(doulist));
	head->next = NULL;
	head->pre = NULL;
	head->txt.len=0;
	return head;
}
//头插法
void insert_doublelinklistBYfront(doulist* head,dataType data)
{
	doulist* temp = (doulist*)malloc(sizeof(doulist));
	if(NULL == temp)
	{
		printf("新节点创建失败，插入失败\n");
		return;
	}
	temp->txt.data = data;
	temp->next = NULL;
	temp->pre = NULL;

	//特殊值，head后面没有数据
	if(NULL == head->next)
	{
		temp ->next = head ->next;
		head->next= temp;
		temp->pre=head;
	}else
	{
		temp->next = head->next;
		head->next = temp;
		temp->next->pre = temp;//head后面不是空的情况，head后面没有节点时
		temp->pre = head;
	}
	head->txt.len++;
	return;

}
//遍历
void bianli_doublelist(doulist* head)
{
	doulist* p = head;
	while(p->next != NULL)
	{
		p=p->next;
		printf("%d  ",p->txt.data);
	}
	printf("\n");
	return;
}
//尾插
void insert_doublelinklistBYrear(doulist* head,dataType data)
{
	doulist* temp = (doulist*)malloc(sizeof(doulist));
	if(NULL == temp)
	{
		printf("新节点创建失败，插入失败\n");
	}
	temp->txt.data=data;
	temp->next=NULL;
	temp->pre=NULL;


	doulist* p = head;
	while(p->next != NULL)
	{
		p=p->next;

	}
	temp->next = p->next;
	p->next=temp;
	temp->pre = p;
	head->txt.len++;
	return;

}
//中间插入
void insert_doublelinklistBYpos(doulist* head,dataType data,int pos)
{
	if(pos<1 || pos>head->txt.len)
	{
		printf("位置非法，插入失败\n");
		return;

	}
	doulist* temp = (doulist*)malloc(sizeof(doulist));
	if(NULL == temp)
	{
		printf("新节点创建失败，插入失败\n");
	}
	temp->txt.data=data;
	temp->next=NULL;
	temp->pre=NULL;
	doulist* p = head;
	for(int i = 0;i<pos-1;i++)
	{
		p=p->next;

	}
	if(NULL == p->next)
	{
		temp->next=p->next;
		p->next=temp;
		temp->pre=p;

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

		temp->next=p->next;
		p->next=temp;
	}
	head->txt.len++;
	return;

}
//头删
dataType delete_BYfront(doulist* head)
{
	if(NULL == head->next)
	{
		printf("链表为空删除失败\n");
		return (dataType)-1;

	}
	doulist* temp =head->next;
	if(NULL ==temp->next)//链表中只有一个有效节点
	{
		head->next = NULL;


	}else{
		head->next=temp->next;
		temp->next->pre = head;

	}

	dataType data1 = temp->txt.data;
	free(temp);

	head->txt.len--;
	return data1;

}
//尾删
dataType delete_BYrear(doulist* head)
{
	doulist* p = head;
	while(p->next != NULL)
	{
		p=p->next;

	}
	p->pre->next = NULL;
	dataType data = p->txt.data;
	free(p);
	return data;
	head->txt.len--;

}
//中间删
dataType delete_doulinklistBYmiddle(doulist* head,int pos)
{
	if(pos<1 || pos>head->txt.len)
	{
		printf("位置非法，插入失败\n");
		return (dataType)-1;

	}

	doulist* p =head;
	for(int i=0;i<pos;i++)
	{
		p=p->next;

	}
	if(p->next == NULL)
	{
		p->pre->next=NULL;
	}
	else
	{
		p->pre->next=p->next;
		p->next->pre=p->pre;

	}
	dataType data = p->txt.data;
	free(p);
	return data;



}

主函数

 #include "./03_doublelinklist.h"                                 
 int main(int argc, const char *argv[])                           
 {                                                                
     doulist* head = creat_doublelinklist();                      
 //头插法                                                         
     printf("头插入11,12,13,14,15为：\n");                        
     insert_doublelinklistBYfront(head,11);                       
     insert_doublelinklistBYfront(head,12);                       
     insert_doublelinklistBYfront(head,13);                       
     insert_doublelinklistBYfront(head,14);                       
     insert_doublelinklistBYfront(head,15);                       
                                                                  
 //遍历                                                           
     bianli_doublelist(head);                                     
 //尾插                                                           
     insert_doublelinklistBYrear(head,100);                       
     bianli_doublelist(head);                                     
 //中间插入                                                       
     insert_doublelinklistBYpos(head,1000,2);                     
     bianli_doublelist(head);                                     
 //头删                                                           
     dataType data = delete_BYfront(head);                        
     bianli_doublelist(head);                                     
 //尾删                                                           
     dataType data1= delete_BYrear(head);                         
     bianli_doublelist(head);                                     
 //中间删                                                         
     dataType data2 = delete_doulinklistBYmiddle(head,3);         
     printf("第三位删除的数据为：%d\n",data2);                    
     bianli_doublelist(head);                                     
     return 0;                                                    
 }

头文件

#ifndef __DOUBLELINKLIST_H__                                          
#define __DOUBLELINKLIST_H__                                          
#include "stdio.h"                                                    
#include "stdlib.h"                                                   
#include "string.h"                                                   
                                                                      
                                                                      
typedef int dataType;                                                 
typedef struct double_link                                            
{                                                                     
    union                                                             
    {                                                                 
        dataType data;                                                
        int len;                                                      
    }txt;                                                             
    struct double_link* next;                                         
    struct double_link* pre;                                          
}doulist;                                                             
doulist* creat_doublelinklist();                                      
//头插法                                                              
void insert_doublelinklistBYfront(doulist* head,dataType data);       
//遍历                                                                
void bianli_doublelist(doulist* head);                                
//尾插                                                                
void insert_doublelinklistBYrear(doulist* head,dataType data);        
//中间插入                                                            
void insert_doublelinklistBYpos(doulist* head,dataType data,int pos); 
//头删                                                                
dataType delete_BYfront(doulist* head);                               
//尾删                                                                
dataType delete_BYrear(doulist* head);                                
//中间删                                                              
dataType delete_doulinklistBYmiddle(doulist* head,int pos);

运行结果

二、单向循环链表

主函数

 #include "./13_looplist.h"                                 
 int main(int argc, const char *argv[])                     
 {                                                          
     //创建循环单链表                                       
     Loop* head = creant_looplist();                        
     //头插                                                 
     printf("头插10，20,30,40,50为：\n");                   
     insert_Byfront(head,10);                               
     insert_Byfront(head,20);                               
     insert_Byfront(head,30);                               
     insert_Byfront(head,40);                               
     insert_Byfront(head,50);                               
     //遍历                                                 
      bianli_looplist(head);                                
     //尾插                                                 
     printf("尾插11,12,13为：\n");                          
     insert_Bytail(head,11);                                
     insert_Bytail(head,12);                                
     insert_Bytail(head,13);                                
     bianli_looplist(head);                                 
     //头删                                                 
     printf("头删50后为：\n");                              
     dataType data = delete_looplistByfront(head);          
     bianli_looplist(head);                                 
     //尾删                                                 
     dataType data1 =  delete_looplistByrear(head);         
     printf("尾部删除数据为：%d\n",data1);                  
     bianli_looplist(head);                                 
     return 0;                                              
 }

功能函数

#include "./13_looplist.h"
//创建空的循环单链表
Loop* creant_looplist()
{
	//创建一个头结点
	Loop* head = (Loop*)malloc(sizeof(Loop));
	if(NULL == head)
	{
		printf("创建节点失败\n");
		return NULL;
	}
	head->txt.len=0;
	head->next=head;
	return head;
}
//头插
void insert_Byfront(Loop* head,dataType data)
{
	Loop* temp = (Loop*)malloc(sizeof(Loop));
	if(NULL == temp)
	{
		printf("创建节点失败\n");
		return;
	}
	temp->txt.data = data;
	temp->next = NULL;


	temp->next=head->next;
	head->next=temp;
	head->txt.len++;
	return;


}
//遍历
void bianli_looplist(Loop* head)
{
	Loop* p =head;
	while(p->next != head)
	{
		p=p->next;
		printf("%d  ",p->txt.data);
	}
	putchar(10);
	return;
}
//尾插
void insert_Bytail(Loop* head,dataType data)
{
	Loop* temp = (Loop*)malloc(sizeof(Loop));
	if(NULL == temp)
	{
		printf("创建节点失败\n");
		return;
	}
	temp->txt.data = data;
	temp->next = NULL;
	
	Loop* p =head;
	while(p->next != head)
	{
		p=p->next;
	}
	temp->next=head;
	p->next=temp;
	head->txt.len++;
	return;

}
//头删
dataType delete_looplistByfront(Loop* head)
{
	Loop* temp = head->next;
	head->next=temp->next;
	head->txt.len--;
	dataType data = temp->txt.data;
	free(temp);
	temp = NULL;
	return data;

}
//尾删
dataType delete_looplistByrear(Loop* head)
{
	if(head == head->next)
	{
		printf("链表为空，删除失败\n");
		return(dataType)-1;
	}

	Loop* p = head;
	while(p->next->next != head)
	{
		p=p->next;
	}
	dataType data = p->next->txt.data;
	free(p->next);
	p->next=head;
	head->txt.len--;
	return data;


}

头文件

 #ifndef __LOOPLIST_H__
 #define __LOOPLIST_H__
 #include "stdio.h"
 #include "stdlib.h"
 typedef int dataType;
 typedef struct loop_node
 {
     union
     {
         dataType data;
         int len;
     } txt;
     struct loop_node* next;
 }Loop;
 //创建空的循环单链表
 Loop* creant_looplist();
 
 //头插
 void insert_Byfront(Loop* head,dataType data);
 //遍历
 void bianli_looplist(Loop* head);
 //尾插                                          
 void insert_Bytail(Loop* head,dataType data);
 //头删
 
 dataType delete_looplistByfront(Loop* head);
 //尾删
 dataType delete_looplistByrear(Loop* head);
 
 #endif

运行结果

三、约瑟夫问题

joseph(约瑟夫)问题 约瑟夫(约瑟夫)问题)
1.设编号分别为:1，2， ...，n的n个人围坐一圈。
2.约定序号为k (1<k≤n)的人从1开始计数，数到m的那个人出列，
3.他的下一位又从1开始计数，数到m的那个人又出列，依次类推，直到所有人出列为止。
例如，8个人围坐一圈，约定从第3个人开始编号为1，数到第4个人出列。出列后原来第5个人计算为n=8，k=3,m=4，最终出队的结果是62743518
提示:单向循环链表，删除头结点 

 #include "./113_yuesefu_func.h"         
 int main(int argc, const char *argv[])  
 {                                       
                                         
     loop* head = creat_looplist();      
     insert_yueloop(head,1);             
     insert_yueloop(head,2);             
     insert_yueloop(head,3);             
     insert_yueloop(head,4);             
     insert_yueloop(head,5);             
     insert_yueloop(head,6);             
     insert_yueloop(head,7);             
     insert_yueloop(head,8);             
                                         
     bianli_loopyue(head);               
     delete_yueloop(head);               
     bianli_loopyue(head);               
     return 0;                           
 }                                       
                                         

#include "stdlib.h"
typedef int dataType;
typedef struct loop_yue
{
    union
    {
        dataType data;
        int len;
    }txt;
    struct loop_yue* next;

}loop;

                                                 
loop* creat_looplist();

void insert_yueloop(loop* head,dataType data);

void bianli_loopyue(loop* head);
void  delete_yueloop(loop* head);

#endif


 #include "./113_yuesefu_func.h"              
 //创建空的循环单链表                         
 loop* creat_looplist()                       
 {                                            
     loop* head = (loop*)malloc(sizeof(loop));
     if(NULL == head)                         
     {                                        
         printf("创建头结点失败\n");          
         return NULL;                         
     }                                        
     head->txt.len=0;                         
     head->next=head;                         
                                              
     return head;                             
 }                                            
 //插入数据                                   
 void insert_yueloop(loop* head,dataType data)
 {                                            
     loop* temp = (loop*)malloc(sizeof(loop));
     if(NULL == temp)                         
     {                                        
         printf("节点为空，插入失败\n");      
         return;                              
                                              
     }                                        
     temp->txt.data = data;                   
     temp->next = NULL;                       
                                              
     loop* p = head;                          
     while(p->next != head)                   
     {                                        
         p=p->next;                           
                                              
     }                                        
     temp->next=head;                         
     p->next=temp;                            
     head->txt.len++;                         
     return;                                  
                                              
                                              
                                              
                                              
 }                                            
 //遍历                                       
 void bianli_loopyue(loop* head)              
 {                                            
     loop* p = head;                          
     while(p->next != head)                   
     {                                        
         p=p->next;                           
         printf("%d  ",p->txt.data);          
                                              
     }                                        
     putchar(10);                             
     return;                                  
                                              
                                              
 }                                            
 //删除                                       
 void delete_yueloop(loop* head)              
 {                                            
     loop* move=head;                         
     loop* temp =NULL;                        
     while(move->next!=move)                  
     {                                        
                                              
         for(int i = 3;i<=head->txt.len;i++)  
         {                                    
             temp=move;                       
             move=move->next;                 
         }                                    
         temp->next=move->next;               
         move=move->next;                     
         printf("%d  ",move->txt.data);       
     }                                        
     return;                                  
                                              
                                              
 }


 

ldlyq
关注
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3295
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
【循环链表】数据结构——单向循环链表和双向循环链表操作&笔记
皮皮不调皮的博客
03-23 9179
一、单向循环链表 将单链表的首尾节点相连就形成了单向循环链表。 1、单向循环链表的节点 2、单向循环链表的结构 单向循环链表只有一个节点时： 二、双向循环链表 1、双向循环链表示意图 2、双向循环链表节点设计 struct d_node{ int data; //数据域 struct d_node *next; struct d_node *prev; }; 3、双向循环链表的一般性结构 1）只有头结点的情况 2）有多个节点的情况 4、双向循环链表头插法插入节点 步骤： 1）p-&
单向循环链表改成双向循环链表
weixin_46034571的博客
11-28 724
【代码】单向循环链表改成双向循环链表。
【C/数据结构与算法】：链表的实现（单向链表+双向链表）
2301_77900444的博客
03-17 1261
1.顺序表的问题和思考问题：中间/头部的插入删除，时间复杂度为O(N)。增容需要申请新空间，拷贝数据，释放旧空间,会有不小的消耗。增容一般是呈2倍的增长，势必会有一定的空间浪费。例如当前容量为100，满了以后增容到200，我们再继续插入了5个数据，后面没有数据插入了，那么就浪费了95个数据空间。思考：如何解决以上问题呢？下面给出了链表的结构来看看。
单向循环链表和双向循环链表的结构分析
派拉斯兔子的博客
10-23 1085
单向循环链表： 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 单向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表： 双向循环链表 –多个节点和只有一个节点的结构分析 双向循环链表直接体现为 双向和循环，一般的单链表只有节点数据data和next指向地址(应该也是引用的意思)，而在此需要增加前面部分的pre指向地址，同时还需要循环循环则在定义节点时可以解决，
链表（单向链表、双向链表、循环链表）
2303_82176667的博客
09-12 465
单向链表的每个节点包含一个数据字段和一个指向下一个节点的指针。// 定义元素类型为int// 节点存储数据// 指向下一个节点的指针// 定义LNode结构体和LinkList指针类型这是一个定义链表的数据结构。链表的节点LNode包含两个部分：一个用于存储数据的数组，以及一个指向下一个节点的指针next。// 定义元素类型为int// 节点存储数据// 指向前一个节点的指针// 指向下一个节点的指针// 定义DNode结构体和DLinkList指针类型// 定义元素类型为int。
数据结构——双向循环链表
qq_67611811的博客
08-28 2286
双向循环链表，在原单链表的基础上多了一个指向上一个结点的前驱指针prev，这样前后结点就不仅仅有了单向的从头至尾的指向顺序，也可以从后指向前，从末结点指向头结点。双向带头循环链表结构} DGR;加入前驱指针后，不管是对于链表数据的尾插尾删，或是头插头删，其时间复杂度都为O(1)，大大简化了链表遍历过程，而可以直接在链表首尾增减数据，因为一个链表的末节点可由头结点的前驱指针直接访问而不需要遍历至尾。为了简化文本描述，本章双向循环带头链表均简称为双向链表。...
【数据结构初阶】复杂链表复制+带头双向循环链表+缓存级知识
The porters of knowledge
11-09 1140
经典的链表结构，值得你端详一下
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5362
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
数据结构 day5 单向循环链表和双向循环链表
2203_75782206的博客
12-26 450
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
在JavaScript中，数据结构是构建复杂程序的基础，其中双向链表和双向循环链表是两种重要的线性数据结构。本文将深入探讨这两种链表的实现原理，并通过代码示例进行详细解析。 首先，双向链表（Doubly Linked List）...
《数据结构基础知识②》--单循环链表+双向链表+时间效率+比较
yyldeh的博客
03-27 2246
目录 一、单循环链表 1.概念 2.循环条件 3.尾指针表示循环链表 4.带尾指针的链表合并 二、双向链表 1.概念 2.双向循环链表 3.双向链表结构的对称性 4.双向链表的插入 5.双向链表的删除 三、单链表、循环链表、双向链表的时间效率比较 四、顺序表和链表的比较 1.链式存储结构的优缺点 2.存储密度 3.顺序表和链表比较 一、单循环链表 1.概念 2.循环条件 3.尾指针表示循环链表 4.带尾指针的链表合并 ...
二叉树遍历/算法&数据结构
2403_86942375的博客
11-10 672
其实很简单，根据遍历的顺序摆放遍历顺序和添加元素的顺序，(root.left, result)代表左子树，(root.right, result)代表右子树，(root.val)代表中节点。其实很简单，参数就是要目前遍历节点在哪，返回值也同理，终止条件就是指遍历到null的时候回溯，逻辑不要想复杂，根据顺序移动上述上个递归函数即可。前序（要理解遍历的核心，先把中节点塞入，然后根据栈去模拟，先加入右节点然后是左节点，移动到左节点继续加入）后序（就是前序遍历的左右调换顺序，然后再倒叙结果数组）
【初阶数据结构篇】二叉树OJ题
最新发布
braveact的博客
11-10 450
根节点与左右孩子的数值进行比较，如果相等依次递归左右子树，如果为空，或者两者对应的值相等，则返回true。🚀 分享给更多人：如果你觉得这篇文章对你有帮助，欢迎分享给更多对C++感兴趣的朋友，让我们一起进步！可以将该二叉树看成两个独立的二叉树，分别将“两个二叉树”的根节点传入，判断该是否为相同的二叉树。将两个数的根节点的值依次比较，依次递归两根节点的左子树，若根节点为空，直接返回。如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。期待你的三连，你的支持就是我创作的动力！
开放寻址法、链式哈希数据结构详细解读
m0_61840987的博客
11-06 941
开放寻址法在低负载因子时效率较高，而链式哈希在高负载因子下表现更稳定。
【数据结构】B树
藓类少女的博客
11-06 897
B树通常定义为一棵平衡的多路搜索树，并用一个整数 m 表示其阶数，即每个节点最多有 m 个子节点。每个节点最多包含 m - 1 个关键字和 m 个子节点。每个非根节点至少包含 ⌈m/2⌉−1 个关键字和 ⌈m/2⌉ 个子节点。根节点至少包含 1 个关键字，特殊情况除外（当树为空时，根节点没有关键字）。所有叶子节点都在同一层，即 B 树的高度是均匀的。每个节点的关键字从小到大排序，并且遵循左小右大的原则。每个关键字 k 的左子树的所有关键字都小于 k，右子树的所有关键字都大于 k。
希尔排序算法
a921876874的博客
11-06 972
希尔排序算法
python中常见的8种数据结构之一数组的应用
2301_81121233的博客
11-10 229
可能的类型码包括`b`（有符号整数）、`B`（无符号整数）、`u`（Unicode字符）、`h`（有符号短整数）、`H`（无符号短整数）、`i`（有符号整数）、`I`（无符号整数）、`l`（有符号长整数）、`L`（无符号长整数）、`f`（浮点数）、`d`（双精度浮点数）等。数组和列表的主要区别在于数组中的元素必须是同一种类型，而列表中的元素可以是任何类型。可以通过索引访问数组中的元素，也可以使用切片操作来获取数组的子集。3.音频处理：音频数据通常也以数组的形式存储，数组可以用来处理音频的采样值。
【01课_初识算法与数据结构】
weixin_42333261的博客
11-10 642
算法，个人理解就是计算一段逻辑，最简化，最快速的方式、方法每个函数，就包含了一定的算法，执行一定的计算逻辑。
循环链表详解：单向与双向循环链表及其应用
该资源主要介绍了循环链表的相关概念，包括单向循环链表和双向循环链表，并探讨了它们的结构特点、操作实现及应用。 在计算机科学中，循环链表是一种特殊的链式数据结构，它与普通单链表的主要区别在于最后一个节点...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值