0719|数据结构day5（双向链表+双向循环链表）

已于 2023-07-20 19:09:25 修改
阅读量922 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2023-07-19 20:52:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Smallxu_/article/details/131812813
版权

目录

一、思维导图

二、作业

2.1 单向链表简单选择排序

2.2 单向链表按元素插入

2.3 单向链表按元素修改

三、双链表

 3.1 双向链表结构体建立

3.2 双向链表节点创建

3.3 双向链表头插

3.4 双向链表尾插

3.5 双向链表头删

3.6 双向链表尾删

3.7 双向链表遍历

3.8 双链表全部代码

四、双向循环链表

 4.1 双向循环链表结构体建立

4.2 双向循环链表节点创建

4.3 双向循环链表头插

4.4 双向循环链表尾插

4.5 双向循环链表头删

4.6 双向循环链表尾删

4.7 双向循环链表遍历

4.8 双向循环链表所有代码

一、思维导图

二、作业

2.1 单向链表简单选择排序

/*
 * function:    简单选择排序
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void paixu(Linklist L)
{
	//判断链表是否为空
	//判断链表只有有一个节点
	if( NULL==L || L->next==NULL )
	{
		return;
	}
	int i,j;
	int len=Len_linklist(L);
	Linklist p=L;
	Linklist k=NULL;
	for(i=0;i<len-1;i++)
	{
		Linklist q=p;
		k=q;
		for(j=i+1,p=L;j<len;j++,p=p->next)
		{
			if(q->data < p->data)
			{
				k=p;
			}
		}
		if(k != q)
		{
			datatype t=k->data;k->data=q->data;q->data=t;
		}
	}
}

2.2 单向链表按元素插入

/*
 * function:    按元素插入
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist insert_by_data(datatype key,datatype e,Linklist L)
{
	int insert_pos=search_by_data(key,L);
	if(insert_pos==-1)
		return L;
	L=insert_by_pos(insert_pos,e,L);
	return L;
}

2.3 单向链表按元素修改

/*
 * function:    按元素修改
 * @param [ in] 
 * @param [out] 
 * @return      
 */
Linklist modify_by_data(datatype key,datatype e,Linklist L)
{
	int modify_pos=search_by_data(key,L);
	if(modify_pos==-1)
		return L;
	L=modify_by_pos(modify_pos,e,L);
	return L;
}

三、双链表

        单向链表只可以向后遍历，使用起来不方便，那么引出双向链表，可以向前遍历。

 3.1 双向链表结构体建立

typedef char datatype[20];
typedef struct Node
{
	//数据域
	datatype data;
	//指针域：下一节点地址
	struct Node *next;
	//指针域：上一节点地址
	struct Node *prev;
}*DouleLink;

3.2 双向链表节点创建

/*
 * function:    申请节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink  create_node()
{
	DouleLink node=(DouleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
	strcpy(node->data,"");
	node->next=node->prev=NULL;
	return node;
}

3.3 双向链表头插

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_head(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	//
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}

3.4 双向链表尾插

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_rear(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//2.链表为空
	if(NULL==L)
	{	
		L=s;
		return L;
	}
	//3.已有多个节点
	//找到尾部节点
	DouleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}

3.5 双向链表头删

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_head(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}

3.6 双向链表尾删

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_head(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}

3.7 双向链表遍历

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DouleLink L)
{
	//1.如果为空
	if(NULL==L)
	{
		return;
	}
	//2.如果存在节点
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\n",L->data);
	//逆向遍历
	puts("逆向遍历:");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}

3.8 双链表全部代码

double_head.h

#ifndef __HEAD__H__
#define __HEAD__H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef char datatype[20];
typedef struct Node
{
	//数据域
	datatype data;
	//指针域：下一节点地址
	struct Node *next;
	//指针域：上一节点地址
	struct Node *prev;
}*DouleLink;

DouleLink insert_head(datatype e,DouleLink L);
void output(DouleLink L);
DouleLink insert_rear(datatype e,DouleLink L);
DouleLink delete_head(DouleLink L);
DouleLink delete_head(DouleLink L);
DouleLink delete_rear(DouleLink L);
#endif

double_main.c

#include "double_head.h"
int main(int argc, const char *argv[])
{
	DouleLink L=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter e:");
		scanf("%s",e);
	//	L=insert_head(e,L);
		L=insert_rear(e,L);
	}
	//循环输出
	output(L);
	//头删
	L=delete_head(L);	
	printf("头删后：\n");
	output(L);
	puts("");
	//尾删
	L=delete_rear(L);	
	printf("尾删后：\n");
	output(L);
	puts("");
	return 0;
}

double_test.c

#include "double_head.h"
/*
 * function:    申请节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink  create_node()
{
	DouleLink node=(DouleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
	strcpy(node->data,"");
	node->next=node->prev=NULL;
	return node;
}


/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_head(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	//
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DouleLink L)
{
	//1.如果为空
	if(NULL==L)
	{
		return;
	}
	//2.如果存在节点
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\n",L->data);
	//逆向遍历
	puts("逆向遍历:");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_rear(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//2.链表为空
	if(NULL==L)
	{	
		L=s;
		return L;
	}
	//3.已有多个节点
	//找到尾部节点
	DouleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_head(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}

/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_rear(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink rear=L;
	while(rear->next!=NULL)
		rear=rear->next;

	rear->prev->next=NULL;
	free(rear);
	rear=NULL;
	return L;
}

四、双向循环链表

        因为双向链表在找尾节点是，需要从第一个节点遍历到最后一个节点，时间复杂度高，而且单链表只能向后遍历，不可以向前，所以引出双向循环链表。双向循环链表最大特点是：不需要通过循环找到尾节点，相对方便。

 4.1 双向循环链表结构体建立

typedef char datatype[20];
typedef struct Node
{
	//数据域
	datatype data;
	//指针域
	struct Node *next;
	//指针域
	struct Node *prev;
}*DouleLink;

4.2 双向循环链表节点创建

/*
 * function:    申请节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink  create_node()
{
	DouleLink node=(DouleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
	strcpy(node->data,"");
	node->next=node->prev=NULL;
	return node;
}

4.3 双向循环链表头插

/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_head(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	//
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}

4.4 双向循环链表尾插

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_rear(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//2.链表为空
	if(NULL==L)
	{	
		L=s;
		return L;
	}
	//3.已有多个节点
	//找到尾部节点
	DouleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}

4.5 双向循环链表头删

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_head(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}

4.6 双向循环链表尾删

/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_rear(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink rear=L;
	while(rear->next!=NULL)
		rear=rear->next;

	rear->prev->next=NULL;
	free(rear);
	rear=NULL;
	return L;
}

4.7 双向循环链表遍历

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DouleLink L)
{
	//1.如果为空
	if(NULL==L)
	{
		return;
	}
	//2.如果存在节点
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\n",L->data);
	//逆向遍历
	puts("逆向遍历:");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}

4.8 双向循环链表所有代码

head.h

#ifndef __HEAD__H__
#define __HEAD__H__

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
typedef char datatype[20];

typedef struct Node
{
	//数据域
	datatype data;
	//指针域
	struct Node *next;
	//指针域
	struct Node *prev;
}*DouleLink;

DouleLink insert_head(datatype e,DouleLink L);
void output(DouleLink L);
DouleLink insert_rear(datatype e,DouleLink L);
DouleLink delete_head(DouleLink L);
DouleLink delete_head(DouleLink L);
DouleLink delete_rear(DouleLink L);
#endif

main.c

#include "double_head.h"
int main(int argc, const char *argv[])
{
	DouleLink L=NULL;
	int n;
	datatype e;
	printf("please enter n:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		printf("please enter e:");
		scanf("%s",e);
	//	L=insert_head(e,L);
		L=insert_rear(e,L);
	}
	//循环输出
	output(L);
	//头删
	L=delete_head(L);	
	printf("头删后：\n");
	output(L);
	puts("");
	//尾删
	L=delete_rear(L);	
	printf("尾删后：\n");
	output(L);
	puts("");
	return 0;
}

test.c

#include "double_head.h"
/*
 * function:    申请节点
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink  create_node()
{
	DouleLink node=(DouleLink)malloc(sizeof(struct Node));
	if(NULL==node)
	{
		return NULL;
	}
	strcpy(node->data,"");
	node->next=node->prev=NULL;
	return node;
}


/*
 * function:    头插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_head(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	//
	strcpy(s->data,e);
	if(NULL!=L)
	{
		s->next=L;
		L->prev=s;
	}
	L=s;
	return L;
}

/*
 * function:    循环输出
 * @param [ in] 
 * @param [out] 
 * @return      
 */
void output(DouleLink L)
{
	//1.如果为空
	if(NULL==L)
	{
		return;
	}
	//2.如果存在节点
	//正向遍历
	puts("正向遍历：");
	while(L->next!=NULL)
	{
		printf("%s\t",L->data);
		L=L->next;
	}
	printf("%s\n",L->data);
	//逆向遍历
	puts("逆向遍历:");
	while(L!=NULL)
	{
		printf("%s\t",L->data);
		L=L->prev;
	}
	puts("");
}

/*
 * function:    尾插
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink insert_rear(datatype e,DouleLink L)
{
	//1.创建新节点
	DouleLink s=create_node();
	if(NULL==s)
		return L;
	strcpy(s->data,e);
	//2.链表为空
	if(NULL==L)
	{	
		L=s;
		return L;
	}
	//3.已有多个节点
	//找到尾部节点
	DouleLink rear=L;
	while(rear->next!=NULL)
	{
		rear=rear->next;
	}
	rear->next=s;
	s->prev=rear;
	return L;
}

/*
 * function:    头删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_head(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink q=L->next;
	strcpy(L->data,q->data);
	L->next=q->next;
	if(q->next!=NULL)
		q->next->prev=L;
	free(q);
	q=NULL;
	return L;
}

/*
 * function:    尾删
 * @param [ in] 
 * @param [out] 
 * @return      
 */
DouleLink delete_rear(DouleLink L)
{
	//1.如果链表为空
	if(NULL==L)
		return L;
	//2.判断链表只有一个节点
	if(NULL==L->next)
	{
		free(L);
		L=NULL;
		return L;
	}
	//3.有多个节点
	DouleLink rear=L;
	while(rear->next!=NULL)
		rear=rear->next;

	rear->prev->next=NULL;
	free(rear);
	rear=NULL;
	return L;
}

徐艺桐
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构学习——双向链表
YiHeboy的博客
07-05 856
双向循环链表的创建及增删改查
数据结构小练习-线性表（下）
06-25
5. **循环链表**：循环链表的最后一个节点的指针指向第一个节点，形成一个环状结构。这种结构允许在链表的末尾进行插入和删除操作，而无需特殊处理。 6. **线性表的遍历**：无论是顺序表还是链表，遍历是基本操作之...
双链表的算法之插入节点
weixin_46571142的博客
12-23 1233
双链表的算法之插入节点 1.尾部插入和头部插入 #include <stdio.h> #include <stdlib.h> struct node { int data; //有效数据 struct node* pPrev; //前向指针，指向前一个节点 struct node* pNext; //后向指针，指向后一个节点 }; struct node* create_node(int data) { struct node*
0718|数据结构day4（链表+单链表+单向循环链表）
Smallxu_的博客
07-18 137
单链表的操作：单链表创建、单链表头插、单链表尾插、单链表头删、单链表尾删、单链表遍历、单链表任意位置插入、单链表任意位置删除、单链表任意位置修改、单链表任意位置查找、单链表任意元素插入、单链表任意元素删除、单链表任意元素修改、单链表任意元素查找、单链表逆置、单链表排序、单链表释放；单链表所有代码；单向循环链表（循环单链表、单向循环链表的结构体建立、单向循环链表节点创建、单向循环链表头插、单向循环链表的尾插、单向循环链表的头删、单向循环链表的尾删、单向循环链表的遍历、约瑟夫环）；循环单链表全部代码
数据结构 day5 单向循环链表 双向链表
weixin_55070858的博客
03-18 424
2:双向链表谁指谁 先后顺序没整明白 只能先复习单项参考单项链表的操作。
数据结构 day5 单向循环链表和双向循环链表
2203_75782206的博客
12-26 408
数据结构day5（双向循环链表）
Hellomino_的博客
04-21 76
分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。双向链表也叫双链表，是链表的一种，它的每个数据。
学习记录day16—— 数据结构 双向链表 循环链表
weixin_64918301的博客
07-22 463
1）就是从任意一个节点既能存储其前驱节点，又能存储后继节点2)结构体中增加一个指向前驱节点的指针3）头节点没有前驱，最后一个节点没有后继。
数据结构day06（单向循环链表、双向链表）
weixin_53762703的博客
08-29 478
【代码】数据结构day06（单向循环链表、双向链表）
数据结构 day 5 双链表循环功能
LeeJongSuk_Shin的博客
05-18 50
双向链表循环链表头插。双向链表循环链表头删。双向链表循环链表尾插。双向链表循环链表尾删。
结构和链表PPT学习教案.pptx
10-11
链表有多种类型，如单向链表、双向链表和循环链表。在C++中，实现链表通常涉及自定义节点类（Node）以及链表类（LinkedList），节点类包含数据和指向下一个节点的指针，链表类则提供添加、删除和遍历节点的方法。 ...
7DaysPerTopicChallenge-Day1-Linked-list
03-20
链表有多种类型，包括单向链表、双向链表和循环链表。在单向链表中，每个节点仅有一个指针指向下一个节点；双向链表则每个节点有两个指针，分别指向前一个和后一个节点；循环链表的最后一个节点指回链表的头节点，...
cpp代码-容器day1
07-14
在C++编程中，容器是STL（标准模板库）的核心组成部分，它们为程序员提供了高效的数据结构和操作这些数据的方法。本压缩包“cpp代码-容器day1”显然是一个学习C++容器的基础教程，其中包含了两个文件：`main.cpp`是...
图解大顶堆的构建、排序过程
sagima_sdu的博客
08-12 486
开始，
数据结构与算法--线索二叉树与哈夫曼树
wumingzei的博客
08-12 632
/ 标记枚举类型，Link表示指向孩子，Thread表示线索char data;// 结点数据域// 左右标记域// 左右孩子或线索// 定义线索二叉树结点类型哈夫曼树（最优二叉树）是带权路径长度WPL最小的二叉树。结点的权：将树中结点赋予一个有某种意义的数值。
【长度最小的子数组】python刷题记录
m0_73629042的博客
08-12 219
【代码】【长度最小的子数组】python刷题记录。
快速排序算法
最新发布
timer_017的博客
08-13 207
快速排序是一种高效的排序算法，其基本思想是通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，然后分别对这两部分继续进行排序，直到整个序列有序。
数据结构讲解：循环链表与双向链表操作
在数据结构与算法的学习中，循环链表和双向链表是两种重要的链式存储结构，它们扩展了单链表的功能，为数据操作提供了更多的便利。 5.1 带头结点的链表 带头结点的链表是在线性链表的第一个元素前增加一个特殊的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值