数据结构之单链表的基础操作（详细讲解）

具体解析已经全放入代码中，有不懂的可以认真看注释。

#include <stdio.h>
#include <stdlib.h>//库函数malloc要

typedef struct LNode {
	int data;//数据域用来存放内容和数据的地方，看你要输入的数据而给类型
	struct LNode *next;  //相当于弄一个指向自己的指针，也叫结构体类型指针
} LNode, *LinkList; //LinkList为指向结构体LNode的指针类型

LinkList p, q; //在这里定义全局变量，因为后面基本用的到

void caozuo() {
	printf("-------------------------（1）单链表初始化-------------------------------\n");
	printf("-------------------------（2）改装头插法建立链表-------------------------------\n");
	printf("-------------------------（3）尾插法建立链表-------------------------------\n");
	printf("-------------------------（4）在第i个元素之前插入-------------------------------\n");
	printf("-------------------------（5）查找操作-------------------------------\n");
	printf("-------------------------（6）删除第i个元素-------------------------------\n");
	printf("-------------------------（7）头插法建立链表-------------------------------\n");

}

//1.初始化链表
//生成新的结点作为头结点，用头指针L指向头结点
//头结点的指针域置为空
//在这里设置有头结点的情况

void InitList(LinkList &L) {
	L = new LNode; //生成新结点L作为头结点，new+类型名为c++的用法，L设为LNode类型
	if (L->next == NULL) //在这里判断链表是否为空
		return ;
	L->next = NULL;
}

//3.单链表的插入
//将值为e的新结点插入到表的第i个位置
//查找结点a（i-1）个位置对应的结点，并让p指向这个结点
//生成一个新的结点*s存放插入的内容
//将新结点*s的指针域指向结点a（i）;
//将结点*p的指针的指针域指向新结点*s;
void ListInsert(LinkList &L, int i, int e) {
	//这个是生成个指针
	p = L; //p指向L相当于不用动L而用p复制L的作用去操作；p和L指向头结点，头结点是不存放数据的
	int j = 0; //这个是当前p指向的结点位置，用来控制循环的

	while (p != NULL && j < i - 1) { //在这里要循环找的原因就是链表是连续存储的，所以找的话也要连续寻找位置
		p = p->next; //p指向下一位结点
		j++;
	}
	if (p == NULL  ) {	//判断输入的i是否合法
		printf("插入失败，输入的位置为空\n");
		return ;
	}
	//下面是解读这个用法
	//sizeof(LNode):首先操作符sizeof计算结构体LNode所占的空间
	//malloc(sizeof(LNode)):malloc是用来给里面的大小内容开辟一个空间的
	//(LNode * )malloc(sizeof(LNode)):就是强制转换头部文件调用"#include <stdlib.h>"，malloc()函数返回类型为(void * )
	//由于 L 是指针变量，直接赋值肯定报错，所以要将malloc()函数的返回值，用(LNode * )强制装换为指针类型
	LNode *s = (LNode *)malloc(sizeof(LNode)); //这个是c语言的用法

	//LNode *s;这里是生成新的结点

	s->data = e;
	s->next = p->next;
	p->next = s;
	return ;


}

void dayin(LinkList L) {
	p = L->next; //也就是指向头结点的下一位，就是第一个结点
	//打印链表里面的内容就是p非空
	printf("当前链表内容为： \n");
	while (p != NULL) {
		printf("%d\t", p->data);
		p = p->next;
	}
	printf("\n");
}

//改装一下头插
//这直接改装插入的函数即可
void ListtouInsert(LinkList &L, int e) {
	//这个是生成个指针
	p = L; //p指向L相当于不用动L而用p复制L的作用去操作；p和L指向头结点，头结点是不存放数据的
	LNode *s = (LNode *)malloc(sizeof(LNode)); //这个是c语言的用法
	//LNode *s;这里是生成新的结点
	s->data = e;
	s->next = p->next;
	p->next = s;
	return ;


}

//2.标准头插法
//创建一个只有头结点的空链表
//进行循环输入数据域中，然后让p指向头结点的后面
//要明白，头插就是逆序的了
void ListtouInserth(LinkList &L, int i) {
	//L = new LNode;   //如果要这个，第二次运行，就会重置，就是第一次放入链表的内容都没有了
	//L->next = NULL; //先建立一个带头结点的空链表

	//先让p指向第一个结点然后让p依次指向每一位结点依次存储
	printf("请依次输入：\n");
	for (int j = 0; j < i; j++) {
		p = new LNode; //这里定义的是p结点，每次都要插入新的结点，因此每次都要生成新的结点p
		scanf("%d", &p->data); //存入数据域中
		//下面是每次都插入头结点的后面去

		p->next = L->next;
		L->next = p;
	}
}

//3.尾插操作
//从一个空表L开始，将新结点依次插入到链表的尾部，尾指针r指向链表的尾结点
//一开始时，r同L均指向头结点，每读入一个数据元素则申请一个新结点
//将新结点插入到尾结点后，r指向新结点
void CreateList(LinkList &L, int i) {
	q = L; //让尾指针指向头结点
	printf("依次输入内容：\n");
	for (int j = 0; j < i; j++) {
		p = new LNode; //这里可以看头插相似主要步骤在下面
		scanf("%d", &p->data);
		//********
		p->next = NULL; //让p结点的指针域置为空，因为p结点在这里将要作为尾结点，而尾结点要满足指针域为空
		q->next = p; //把p结点的地址赋给q指向的下一个指针域中，也就是连接起来
		q = p; //然后让q指向p重新指向尾结点

	}
}
//5.查找
//依次查找是否相等就可以了
void chazhao(LinkList L, int i) {
	p = L->next;
	int e = 1;
	while (p != NULL && p->data != i) {
		p = p->next;
		e++;
	}
	if (p == NULL)
		printf("查找失败，该元素并不在链表中\n");
	else
		printf("查找成功\n");
	printf("该元素位置为：%d\n", e);
}

//6.删除
//首先找到a（i-1）；然后用q指向要删除的第i位置结点
//令p->next指向a（i+1）
//释放结点ai的空间
void ListDelete(LinkList &L, int i, int e) {
	p = L;
	int j = 0;
	//找第i个要删除的位置
	while ((p->next) && (j < i - 1) ) { //这里的条件，用p->next的是为了防止i-1个位置为空
		p = p->next;
		j++;
	}
	if (!(p->next) || (j > i - 1)) {
		printf("输入内容不合法\n");
		return ;
	}
	q = p->next; //临时保存被删结点的地址以备释放
	e = q->data;
	printf("删除的元素为%d \n", e);

	p->next = q->next; //改变删除结点前驱结点的指针域
	delete q;//释放删除结点的空间
}
int main() {

	//printf("阿祥回炉重造单链表\n");
	//两个定义的法子
	//LNode *L;  //这个强调定义结点指针*L
	LinkList L;//定义一个链表的头指针，也可以把这个链表的名称为L链表

	//操作菜单
	caozuo();
	int n = 0;//用来控制操作的进行步骤
	int i = 0; //设置要插入的位置和取值操作的使用
	int e = 0; //用来输入插入的数值
	scanf("%d", &n);

	while (1) {
		switch (n) {
			case 1://初始化单链表
				InitList(L);
				printf("初始化成功\n");
				caozuo();
				scanf("%d", &n);
				break;
			case 2://头插法的方式。我这里的尾插和头插可以应用于插入玩法，既可以输入第i个位置插入，也可以固定头和尾插
				printf("输入要插入的长度\n");
				scanf("%d", &i);
				printf("依次输入内容：\n");
				for (int j = 0; j < i; j++) {
					scanf("%d", &e);
					ListtouInsert(L, e);
				}
				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;


			case 3 ://尾插入
				printf("输入要插入的长度\n");
				scanf("%d", &i);
				CreateList(L, i);
				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;

			case 4 ://任意位置插入
				printf("请输入你要插入的位置\n");
				scanf("%d", &i);

				printf("请输入你要插入的数值\n");
				scanf("%d", &e);

				ListInsert(L, i, e);
				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;

			case 5 ://查找第i个元素
				printf("请输入你要查找的数值\n");
				scanf("%d", &i);
				chazhao(L, i);

				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;

			case 6 ://删除第i个元素
				printf("请输入你要删除的元素的位置\n");
				scanf("%d", &i);
				ListDelete(L, i, e);

				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;
			case 7 ://头插初始化
				printf("输入初始化链表长度\n");
				scanf("%d", &i);
				ListtouInserth(L, i);

				dayin(L);
				caozuo();
				scanf("%d", &n);
				break;




		}
	}



	return 0;
}

代码运行图：

改装链表玩法

#include<stdio.h>
#include<iostream>
#include <stdlib.h>
using namespace std;//使用cin和cout的头文件 
typedef int ElemType; 
typedef int status; //自定义
#define OK 1
//定义一个链表
typedef struct LNode//表示结点 
{
	ElemType data;//这个类型也要定义
	 //int data;
	struct LNode *next;//自己定义自己结构体类型，相当于嵌套的结构体 
 } LNode,*LinKList;//LinKList意义何在 创造链表，LNode作为借点，链表由n个结点构成 

LNode *p,*r;//LNode用于定义指向单链中任意结点的指针变量 
//LinKList p,r;//表示的意义是p和r为指向某结点的指针变量；
//LinKList表示定义某个单链表的头指针； 
 

void houziquming()
{
	printf("欢迎光临108猴子乐园\n");
	printf("1号代表h\n");
	printf("2号代表qd\n");
	printf("3号代表o\n");
	printf("4号代表c\n");
	printf("5号代表w\n");
	printf("6号代表t\n");
	printf("7号代表m\n");
	printf("8号代表f\n");
	printf("\n");
}

void caozuo()
{
	printf("\n下面是猴子乐园玩法\n");
	printf("（1）捐款建猴子乐园\n");
	printf("（2）在前门养猴子\n");
	printf("（3）在后门养猴子\n");
	printf("（4）抓猴子出来玩 \n");
	printf("（5）在第i号猴子之前，养一个新的猴子\n");
	printf("（6）把第i号猴子宰了炖汤\n");
	printf("（7）找猴子\n");
	
}


//给链表初始化，即为空链表
//构造一个空链表， 
//atus InitList(LNdoe &L)/atus  这个类型要提前自定义 
status InitList(LinKList &L)
//int InitList(LinKList &L)//这个是不定义的情况 
{
	//status L=(status*)malloc(sizeof(status));//不会用这个 
	L=new LNode;//用new给链表一个动态空间 ；；
	//这个我终于搞明白了；LNode表示结构体类型名，相当于这个结构体，然后这个结构体代表的就是一个结点可以是头结点也可以是首元结点，也就是 L指向这个结点； 
	L->next=NULL;
	return OK; //这个在上面用define定义好 
	//return 1;
}


//头插
//包括创建一个带头结点的空链表
void toucha(LinKList &L,int n)
{
	//LNode *p;//这两个定义方法都没有问题 
	//LinKList p;
	L=new LNode;//建一个带头结点的空链表 
	//LinKList L=(LinkList)malloc(sizeof(LNode));//这个咋使用呢 
	L->next=NULL;//空链表，多余了这两个，上面已经初始化好了 
	for(int i=0;i<n;i++)
	{
		p=new LNode;//定义新的结点，然后输入想要的值放入新结点，然后插入 
		scanf("%d",&p->data);//注意这里需要地址 
		
		//下面这两步就是插入新结点的关键操作
		//一定要理解好，先链接尾部然后连接头部 
		p->next=L->next;//这个是把l指向的内容都放p->next的后面 
		L->next=p; //链接头部 
		
	 } //注意这里是逆序的
	 //咋解决逆序呢 
	
	
	
}


//打印，打印原理
//1.让指针p指向首元结点，2.进行一个条件为p的循环，也就是p不为空表的话一直执行下去
//3.循环里面直接打印首元结点的数据域 4.然后p继续指向下一个结点 
void dayin1(LinKList L)//这里不需要改变值，因此不需要地址引用
{
	p=L->next;
	printf("目前还有以下这几只猴子\n");
	while(p)
	{
		
		printf("%d号猴子   ",p->data);
		p=p->next;
	 } 
	 printf("\n\n");//隔一行 
 } 
 
 void dayin(LinKList L)//这里不需要改变值，因此不需要地址引用
{
	p=L->next;
	while(p)
	{
		printf("我是%d号猴子   ",p->data);
		p=p->next;
	 } 
	 printf("\n");//隔一行 
 } 
 //尾插思路
 //1.弄一个带头结点的空链表 2.定义一个新的结点r指向头结点L
 //3.进行循环 n个元素进行n次，在循环中再次生成新的结点，也就是要插入的结点
 //4.然后给结点的数据域赋值；5. 让新结点指针域为空，然后插入r尾指针
 //6.插入完后 r重新指向p再次成为尾结点 
 void weicha(LinKList &L,int n)
 {
 	L=new LNode;//弄一个带头结点的空链表 
	 L->next=NULL;
	 r=L; 
	 for(int i=0;i<n;++i)
	 {
	 	p=new LNode;
	 	scanf("%d",&p->data);//注意这里需要地址 
	 	p->next=NULL;
	 	r->next=p;
	 	r=p;
	 }
	  
 	
 	
 }
 //抓猴子思路，抓到的猴子得公布出来 
 //1.用新的指针p指向首元结点 ,定义一个计数器j；
 //2.弄一个while循环，从首元结点开始依次顺着链域next向下访问
 //3.直到p指向的为空（NULL）也就是最后的结点还是没有就结束循环或者当次j>n时候结束 
 int zhuahouzi(LinKList L,int n,int &e)
 {
 	p=L->next;
	 int j=1; 
	 while(p&&j<n) //两个情况让其结束循环，第一个是一遍下去，第二个提前找到 
 	{
 		p=p->next;//指向下一个结点
		 ++j; 
	 }
	 if(!p||j>n)//这个if我觉得没必要，因为while里面已经包括这种情况了； 
	 return 0;
 	e=p->data;
 	return 1;
 }
 
 //养猴子思路
 //1.先找到想要的第n号 ,就必须找i前面的元素，也就是n-1 ，找到后让p指向该结点
 //2.if判断是否合理，生成新的结点r，将新结点r的数据域赋值e，
 //3.链接结点就可以了，跟头插差不多 
 int  yanghouzi(LinKList &L,int n,int &e)
 {
 	p=L;
	 int j=0;
	 while(p&&(j<n-1))//寻找 
	 {
	 	p=p->next;
	 	++j;
	 }
 	if(!p||j>n-1)
	 return 0;
	 r=new LNode;
	 r->data=e;
	 r->next=p->next;
	 p->next=r;
	 return 1;
	  
 	
 }
 //宰猴子
 //1. 输入要删除的元素；2.与那个插入差不多，也要找到i-1个结点，然后指向那个结点
 //3.定义一个临时的指针保存想要删除的第i个元素的地址；
 //4.链接隔着一个结点两个的两个结点 
 int zaihouzi(LinKList &L,int n)
 
 {
 	p=L;
	int j=0;
	 while((p->next)&&(j<n-1))//这里为何是p->nexr而不是p呢？ 
	 {
	 	p=p->next;
		 ++j; 
	  } 
	  if(!(p->next)||(j<n-1))
	  return 0;
	  r=p->next;//存放地址，然后删除 
	  p->next=r->next;//这就是隔着一个结点链接起来 
	  //p->next=p->next->next;//这个也对 
	  delete r;
	  return 1; 
  } 
  
  //找猴子
  //1.依次找，先用指针指向首元结点
  //2.从首元结点依次查找，直到找到或者指针为空才结束
  //3.找到就返回p的地址
  int zhaohouzi(LinKList L,int n) 
  {
  	p=L->next;
  	int j=1;//记录序号 
  	while(p&&p->data!=n)
  	{
  		p=p->next;
		  ++j; 
	  }
	  if(p)
	  {
	  	return j;
	  }
	  else
	  return 0;
  }


int main()
{
	LinKList L;//这里为什么要用这个来定义呢，为啥不能用 LNode
	//LNode L;//这个咋定义才可以传过去用 
	 
	//LinKList p;//新结点 
	//LNode *p;
	//LinKList K;//结点 
	houziquming();
	caozuo();//打印一个分别有几个操作的提示 
	//InitList(L); //定义空链表
	//toucha(); 
	//jiedian(k);//定义结点 
	 
	//根据caozuo函数的提示来进行操作
	//先创建好链表
	//再给链表放值进去，也就是用插入法 
	//
//	InitList(L);//创建一个空链表 
	//这些放在一个while里面实现，定义一个输入值i，让其输入的值分别进入各自的操作
	int i,n,e;
	scanf("%d",&i);
	//cin>>i; //这里使用c++的输入方式，头文件要有#include<iostream>和 using namespace std;//使用cin和cout的头文件 
	while(1)//1表示条件恒为真，也就是循环不会停止 
	{
		//scanf("%d",&i);//放一个在这看看会咋样
		switch(i)
		{
		
			case 1://第一个操作为创建一个空链表
				 if(InitList(L))//判断这个函数是否成功，成功就是成功满足函数里面的条件创建了，输出提示就好了 
				 
				 {	printf("我爱猴子滴滴\n"); //这里的大括号要不要都行 
				 	//cout<<"我爱猴子滴滴"<<endl;
				 	printf("创建猴子乐园成功\n");
				}
				else
					{
					printf("我不爱  猴子\n");
					printf("创建失败\n");
					}
				caozuo();//创建完肯定得进行下一项，再次展示列表
				scanf("%d",&i);//再次输入想要进行第几步操作的值 
				break;// 跳出去 
				
			//有个问题，一个空点链表，怎么存值进去呢 
			case 2://第二个操作为头插法存储值进空链表里面
				printf("您要养多少只猴子\n");
				scanf("%d",&n);
				printf("分别输入你想养的猴子号数，以空格隔开:\n");
				//输入就是插入法，将数值插入空链表里面，也就是插入结点
				//所以你的整一个结点
				toucha(L,n);//长度n传进去
				//此时需要一个打印的函数，打印现在链表里面的内容
				dayin(L);//打印 
				caozuo();
				scanf("%d",&i);//再次输入想要进行第几步操作的值 
				 break;
			 
			 
			 case 3:
			 	printf("您要养多少只猴子\n");
			 	scanf("%d",&n);
				printf("分别输入你想养的猴子号数，以空格隔开:\n");
			 	weicha(L,n);//使用尾插进行建立链表的存储 
			 	dayin(L);
			 	caozuo();
			 	scanf("%d",&i);//再次输入想要进行第几步操作的值 
			 	break;
			  case 4://取值，链表顺序存取，一个一个找
			   printf("输入你想要抓走的猴子的号数\n");
			   scanf("%d",&n);
			   zhuahouzi(L,n,e);
				printf("您要找的猴子为%d号\n",e);
				dayin1(L);
				caozuo();
			 	scanf("%d",&i);//再次输入想要进行第几步操作的值 
			   break; 
			 case 5://插入猴子 在第i号猴子之前，养一个新的猴子
			 	printf("输入第几号的猴子之前养一个新的猴子\n");
			scanf("%d",&n);
			printf("输入新养的猴子的号数\n");
			scanf("%d",&e);
			yanghouzi(L,n,e);
			dayin(L);
			caozuo();
			scanf("%d",&i);
			break;
			case 6://宰猴子
			 printf("请输入想要宰的猴子的号数\n");
			 scanf("%d",&n);
			 zaihouzi(L,n);
			 printf("第%d号猴子已经被宰\n",e);
			 dayin1(L);
			 caozuo();
			 scanf("%d",&i);
				break;
			case 7:
				printf("请输入想要找的猴子的号数\n");
				scanf("%d",&n);
				zhaohouzi(L,n); 
				printf("您要找的猴子的号数为%d号\n",n);
				caozuo();
				scanf("%d",&i);
				break; 
			
			 
			
		}
	 } 
	//收工  2023.3.30 祥11 
	
	return 0;
}