数据结构:单向链表的操作

最新推荐文章于 2024-05-17 00:58:36 发布
最新推荐文章于 2024-05-17 00:58:36 发布
阅读量37 收藏
点赞数
文章标签： 链表 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SYF_wdnmd/article/details/130277013
版权

1）预处理

#ifndef  __HEAD1_H__
#define  __HEAD1_H__

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

typedef char datatype;

typedef struct Node
{
	union{
		//数据域
		int len;
		datatype data;
	};
	//指针域:存储下一个节点的地址
	struct Node* next;
}*Linklist;


Linklist Create_head();
Linklist Create_Node();
void Insert_head(Linklist L,datatype e);
void Output(Linklist L);
void Insert_rear(Linklist L,datatype e);
void Delete_head(Linklist L);
void Delete_rear(Linklist L);
int Insert_pos(Linklist L,int pos,datatype e);
int Delete_pos(Linklist L,int pos);
int Search_pos(Linklist L,int pos);
int Revise_pos(Linklist L,int pos,datatype e);
Linklist Search_data(Linklist L,datatype e);
int Revise_data(Linklist L,datatype e,datatype k);
int Delete_data(Linklist L,datatype e);
int Insert_data(Linklist L,datatype e,datatype k);
void LinklistRev(Linklist L);
void LinklistSort(Linklist L);
void Free(Linklist L);


#endif

2）函数声明

#include"head1.h"

//堆区头节点创建申请空间
Linklist Create_head()
{ 
	Linklist L=(Linklist)malloc(sizeof(struct Node));
	if(L==NULL)
		return NULL;
	//头节点创建成功
	L->len=0;     	//数据域
	L->next=NULL; 	//指针域
	return L; 
}

//创建普通节点申请空间
Linklist Create_Node()
{
	Linklist p=(Linklist)malloc(sizeof(struct Node));
	if(p==NULL)
		return NULL ;
	//普通节点创建成功
	p->data=0; //新节点的数据域清0
	p->next=NULL;//新节点指针域为空
	return p;
}

//头插
void Insert_head(Linklist L,datatype e)
{
	if(L==NULL)
	{
		printf("头插失败\n");
		return ;
	}
	Linklist p=Create_Node();
	if(p==NULL)
		return ;
	//节点创建成功
	p->data=e;//为新节点数据域复制
	p->next=L->next;
	L->next=p;
	L->len++;
}

//单链表遍历
void Output(Linklist L)
{
	//遍历条件：判断链表是否创建，链表是否为空
	if(L==NULL||L->len==0)
	{
		printf("遍历失败");
		return ;
	}
	Linklist p=L;
#if 0
	fot(int i=0;i<L->len;i++)
	{
		p=p>next;
		printf("%c\t",p->data);
	}
#else
	while(p->next!=NULL) 	//while(p->next)
	{
		p=p->next;
		printf("%c\t",p->data);
	}
#endif
	putchar(10);
}

//尾插
void Insert_rear(Linklist L,datatype e)
{
	if(L==NULL)
	{
		printf("头插失败\n");
		return ;
	}
	//创建新节点
	Linklist p=Create_Node();
	if(p==NULL)
		return ;
	//找到最后一个节点
	Linklist s=L;
	while(s->next)
	{
		s=s->next;
	}
	//把新节点插入到最后一个节点的后面
	p->data=e ;
	s->next=p ;
	L->len++;
}

//头删:删除头结点的后继节点
void Delete_head(Linklist L)
{
	//判段链表是否为空,链表创建是否成功
	if(L==NULL||L->next==NULL)
		return;
	//删除
	Linklist p=L->next;
	L->next=p->next;
	free(p);
	p=NULL;
	L->len--;
}

//尾删:删除最后一个节点
void Delete_rear(Linklist L)
{
	//判段链表是否为空,链表创建是否成功
	if(L==NULL||L->next==NULL)
	{
		printf("尾删失败\n");
		return ;
	}
	//找到倒数第二个节点 
	Linklist p=L;
	for(int i=0;i<L->len-1;i++)
	{
		p=p->next;
	}	
	//释放最后一个节点
	free(p->next);
	p->next=NULL;
	L->len--;
}

//按位置插入
int Insert_pos(Linklist L,int pos,datatype e)
{
	//判断链表是否创建，链表是否为空，位置是否合理	
	if(L==NULL ||L->next==NULL ||pos<1 || pos>L->len+1)
	{
		printf("插入失败\n");
		return -1;
	}
	//找到pos-1位置，起名字p
	Linklist p=L;//p从头节点开始向后遍历
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;//向后移动
	}
	//在p和p->next之间插入新节点s
	Linklist s=Create_Node();
	if(s==NULL)
	{
		printf("新节点创建失败\n");
		return -1;
	}
	//s的数据域
	s->data=e;
	//s的指针域
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0;
}

//按位置删除
int Delete_pos(Linklist L,int pos)
{
	//判断位置删除的条件:单链表是否创建，是否为空，位置是否合理
	if(L==NULL ||L->next==NULL ||pos<1 || pos>L->len+1)
	{
		printf("删除失败\n");
		return -1;
	}
	//找到pos-1位置，起名字p
	Linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;//向后移动
	}
	Linklist s=p->next;
	p->next=s->next;
	free(s);
	s=NULL;
	L->len--;
	return 0;
}

//按位置查找
int Search_pos(Linklist L,int pos)
{
	//判断位置查找的条件:单链表是否创建，是否为空，位置是否合理
	if(L==NULL ||L->next==NULL ||pos<1 ||pos>L->len+1)
	{
		printf("查找失败\n");
		return -1;
	}
	Linklist p=L;
	for(int i=0;i<pos-1;i++)
	{
		p=p->next;//向后移动
	}
	printf("查找到的元素是:%c\n",p->data);	

}

//按位置修改
int Revise_pos(Linklist L,int pos,datatype e)
{
	//判断位置修改的条件:单链表是否创建，是否为空，位置是否合理
	if(L==NULL ||L->next==NULL ||pos<1 ||pos>L->len+1)
	{
		printf("修改失败\n");
		return -1;
	}
	Linklist p=L;
	for(int i=0;i<pos;i++)
	{
		p=p->next;
	}
	p->data=e;
	return 0;
}

//按元素查找
Linklist Search_data(Linklist L,datatype e)
{
	if(L==NULL||L->next==NULL)
	{
		printf("查找失败\n");
		return NULL;
	}
	Linklist p=L;
	for(int i=1;i<=L->len;i++)
	{
		p=p->next;
		if(p->data==e)
		{
			printf("%c在链表中\n",p->data);
			return p;
		}
	}
	return NULL;
}

//按元素修改
int Revise_data(Linklist L,datatype e,datatype k)
{
	Linklist p=Search_data(L,e);
	if(p==NULL)
	{
		printf("%c不存在，修改失败\n",e);
		return -1;
	}
	p->data=k;
	Output(L);
	return 0;
}

//按元素删除
int Delete_data(Linklist L,datatype e)
{
	if(L==NULL||L->next==NULL)
	{
		printf("删除失败\n");
		return -1;
	}
	Linklist p=L;
	//查找e是否存在
	for(int i=1;i<=L->len;i++)
	{
		p=p->next;
		if(p->data==e)
		{
			Delete_pos(L,i);
			printf("删除后的链表为:\n");
			Output(L);
			return 0;
		}
	}
	printf("删除失败\n");
	return -1;
}

//单链表在制定元素前插入
int Insert_data(Linklist L,datatype e,datatype k)
{
	if(L==NULL||L->next==NULL)
	{
		printf("插入失败\n");
		return -1;
	}
	Linklist p=Search_data(L,e);
	for(int i=1;i<L->len;i++)
	{
		p=p->next;//向后移动
	}
	//在p和p->next之间插入新节点s
	Linklist s=Create_Node();
	if(s==NULL)
	{
		printf("新节点创建失败\n");
		return -1;
	}
	//s的数据域
	s->data=k;
	//s的指针域
	s->next=p->next;
	p->next=s;
	L->len++;
	return 0;
}

//链表逆置
void LinklistRev(Linklist L)
{
	if(L==NULL||L->next==NULL)
	{
		return;
	}
	Linklist p=L->next;//使用p节点保存第一个节点
	L->next=NULL;
	while(p)
	{
		Linklist t=p;
		p=p->next;
		//把t头插在L头节点的后面
		t->next=L->next;
		L->next=t;
	}
	printf("逆置后的链表为:\n");
	Output(L);
}

//链表排序
void LinklistSort(Linklist L)
{
	Linklist p=L->next;
	L->next=NULL;
	while(p)
	{
		Linklist t=p;
		p=p->next;
		//头节点后面有其他节点
		Linklist q=L;
		while(q->next!=NULL && q->next->data<t->data)
		{
			q=q->next;
		}
		//头节点后面没有节点
		t->next=q->next;
		q->next=t;
	}
	Output(L);
}

//链表释放空间
void Free(Linklist L)
{
	if(L==NULL)
		return ;
	for(int i=0;i<L->len;i++)
	{
		Delete_head(L);
	}
	free(L);
	L=NULL;
}

3)主函数

#include"head1.h"

int main(int argc, const char *argv[])
{
	int n;
	//申请空间
	Linklist L=Create_head();
	//头插
	datatype e1;
	printf("请输入要头插节点的个数:");
	scanf("%d",&n);
	for(int i=0;i<n;i++)
	{
		scanf(" %c",&e1);
		Insert_head(L,e1);
	}
	//单链表遍历
	Output(L);
	//尾插
	datatype e2;
	printf("请输入要尾插节点的个数:");
	scanf(" %d",&n);
	for(int i=0;i<n;i++)
	{
		scanf(" %c",&e2);
		Insert_rear(L,e2);
	}
	Output(L);
	//头删
	Delete_head(L);
	printf("头删之后的链表为:\n");
	Output(L);
	//尾删
	Delete_rear(L);
	printf("头删之后的链表为:\n");
	Output(L);
	//按位置插入
	int pos;
	datatype e;
	printf("请输入插入的位置:");
	scanf("%d",&pos);
	printf("请输入要插入的值");
	scanf(" %c",&e);
	Insert_pos(L,pos,e);
	Output(L);
	//按位置删除
	printf("输入删除的位置:");
	scanf(" %d",&pos);
	Delete_pos(L,pos);
	printf("删除后的链表为:\n");
	Output(L);
	//按位置查找
	printf("输入查找的位置:");
	scanf(" %d",&pos) ;
	Search_pos(L,pos) ;
	//按位置修改
	printf("输入修改的位置:");
	scanf(" %d",&pos) ;
	printf("输入修改的数据元素:");
	scanf(" %c",&e) ;
	Revise_pos(L,pos,e);
	Output(L);
	//按元素查找
	printf("输入查找的元素:");
	scanf(" %c" ,&e);
	Linklist p=Search_data(L,e);
	if(p==NULL)
		printf("查找失败\n");
	else
		printf("%c在链表中\n",p->data);
	//按元素修改
	datatype k;
	printf("输入要修改的元素:") ;
	scanf(" %c" ,&e) ;
	printf("输入修改后的值:");
	scanf(" %c",&k);
	Revise_data(L,e,k);
	//按元素删除
	printf("请输入删除的元素:\n");
	scanf(" %c",&e);
	Delete_data(L,e);
	//在指定元素前插入
	printf("请输入被插入的元素:\n");
	scanf(" %c",&e);
	printf("请输入要插入的元素:\n");
	scanf(" %c",&k);
	Insert_data(L,e,k);
	Output(L);
	//链表逆置
	LinklistRev(L);
	//链表排序
	LinklistSort(L);
	//释放空间
	Free(L);

	
	return 0;
}

金色的晴天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构笔记：单向链表
12-22
分类目录——数据结构笔记 离散存储，手拉手，每一块有指向下一块的指针（形象描述，python中没有指针），就好像形成了一条链 一个元素包括两部分：value 和 next 链表与顺序表都是线性表 知识点补充 b = 20 a = 'a...
数据结构：单链表中在P结点前插入S结点
热门推荐
艾醒的博客
01-23 1万+
标题：数据结构：在P结点前插入S结点 在数据结构的习题中偶然看到了一个题目 已知在单链表中P不是首元结点也不是尾元结点，在P结点前插入S结点
无头结点单链表的插入删除语句
qq_43411563的博客
04-29 3500
已知L是无表头结点的单链表，且P结点既不是首元结点，也不是尾元结点。回答下题 1、在P结点后插入S结点的语句序列是 s->next = p->next;//1 p->next = s;//2 如下图所示 2、在P结点前插入S结点的语句序列是 （1）循序交换数据的情况 先在P结点之后插入S结点 定义一个中间变量将S和P的数据交换 s->next = p->nex...
数据结构相关
dy_Learning的专栏
07-10 833
一、线性表的链式存储及相关操作 C语言版 二、C语言实现双向链表的基本操作 三、面试题 1.       在一个单链表中p所指结点之前插入一个s (值为e)所指结点时，可执行如下操作： q=head; while (q->next!=p)  q=q->next; s= new  Node;   s->data=e; q->next=     ;    //填空 s->ne
链表知识点（二）【单链表的插入操作】
u012512762的专栏
10-18 1482
【原理讲解】在p之后要插入一个结点s，首先最开始p->next 为Q，对于单链表的插入，首先建后链，后建前链。建后链的过程中，p->next始终未Q。
如何实现单链表中结点的前插操作？
西小庄村高伟 的博客
06-04 4310
学过数据结构的小伙伴们都知道，如果想要对单链表进行插入操作，一般都需要寻找到要插入结点的前一个结点进行后插入操作，即 s->next = p->next; //s为插入结点，p为前一个结点 p->next = s; 但是如果要求给定一个结点p，要求在这个结点p之前前插一个结点s该怎么办呢，我们是无法找到结点p之前结点的指针的，所以按照正常的思路是无法进行插入的。 这时我们可以改变思路，偷天换日，巧妙解题，将 结点s 依旧插入 结点p 的之后， 再对结点s和p进行值交换，这样就完成了
数据结构：单向链表的反转
又蠢又笨的懒羊羊程序猿的博客
08-03 1008
文章目录单链表的反转1.头插法1.1思路1.2代码实现2.就地逆置法2.1思路2.2代码实现 单链表的反转 本文主要介绍头插法逆置和就地逆置法实现链表的反转 1.头插法 1.1思路 迭代方式的链表反转操作核心是从链表头到链表尾 首先让创建一个temp指针使其指向头节点的下一个节点，并将其取出 取出之后让新创建的reverseNode节点指向刚取出的节点，反复进行上述操作。需要注意的是每次取出节点之前，需要用另外一个指针暂存temp指向的节点的下一个节点，防止temp指针变化后找不到新的节点。 最后让初
数据结构：单向链表及其基本操作
JimmyC18的博客
08-28 837
1. 单向链表介绍 链表的定义：是一种物理存储结构上非连续、非顺序的存储结构，数据元素（结点）的逻辑顺序是通过链表中的指针链接次序实现的。 注：结点包含两个域：数据域和指针域； 链表的特点： 存储单元可以是可连续的，也可以是不连续的； 作插入和删除操作时，不需要移动元素，仅需修改指针； 不可随机存取； 单向链表：链表的每一个结点中只包含一个指针域，如下图所示： 其中，单向链表的第一个结点之前附设的结点，称为头结点head;链表的结点位置从0开始，例如第一个结点再链表中所对应的位置pos=0. 2
数据结构：单向链表源码
07-02
数据结构：单向链表源码，为了让读者有更好的体验，把源码上传上去，有任何问题，或者有任何bug可以直接私信我，我会及时回复，并且解决对应问题
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
数据结构：单向循环链表源码
07-04
数据结构：单向循环链表源码，为了让读者有更好的体验，把源码上传上去，有任何问题，或者有任何bug可以直接私信我，我会及时回复，并且解决对应问题
数据结构经典面试题——练习1
ax1274669874的博客
12-22 1392
1. 在一个单链表中p所指结点之前插入一个s (值为e)所指结点时，可执行如下操作： q=head; while (q->next!=p)  q=q->next; s= new  Node;   s->data=e; q->next=     ;    //填空 s->next=     ;    //填空 2.线性表的顺序存储结构是一种    的存储结构，而链式存储结构是一种
华中科技大学计算机学院2017年考研机试第三题
weixu1999的博客
04-28 1260
要求： 1.实现大数相加 2.数的长度不能事先确定 思路： 用链表实现变长 #include<stdio.h> #include<stdlib.h>typedef struct LNode { char data; struct LNode *next; //int count; }LNode, *LinkList;LinkList CreatList(Lin
数据结构单链表：指定结点的前插、后插操作
qq_45562742的博客
08-10 3642
指定结点的前插操作 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //在p结点之前插入元素e bool InsertPriorNode(LNode *p, int e){ if(p==NULL) return false; LNode *s = (LNode *)malloc(sizeof(LNode)); if(s==NULL)
数据结构--链表的基本操作
2301_78724721的博客
05-14 634
概念：链表是⼀种物理存储结构上⾮连续、⾮顺序的存储结构，数据元素的逻辑顺序是通过链表 中的指针链接次序实现的。链表也是线性表的一种。链表的结构跟⽕⻋⻋厢相似，淡季时⻋次的⻋厢会相应减少，旺季时⻋次的⻋厢会额外增加⼏节。只 需要将⽕⻋⾥的某节⻋厢去掉/加上，不会影响其他⻋厢，每节⻋厢都是独⽴存在的。⻋厢是独⽴存在的，且每节⻋厢都有⻋⻔。想象⼀下这样的场景，假设每节⻋厢的⻋⻔都是锁上的状 态，需要不同的钥匙才能解锁，每次只能携带⼀把钥匙的情况下如何从⻋头⾛到⻋尾？
数据结构——队列（链表实现）
babilunlaobanjiu的博客
05-11 338
原来 1 2 3 4 入队 出队两次， 变成 3 4 .
C++的数据结构(七）：哈夫曼树
全栈工程师Linda的博客
05-14 757
C++的数据结构(七）：哈夫曼树
数据结构之栈
paradiso989的博客
05-11 411
本文详细介绍了数据结构中的栈，并给出了C语言实现
【数据结构】堆（Heep）
最新发布
SWsunlight的博客
05-17 647
堆、堆的实现
数据结构----单向链表
03-27
单向链表是一种常见的数据结构，它由一系列节点组成，每个节点包含两部分：数据和指向下一...单向链表常用于需要频繁插入和删除操作的场景，比如实现栈、队列等数据结构，也可以用于实现其他高级数据结构，如图、树等。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值