devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

单链表中的基本操作(详细代码图解+注释+算法步骤)_单链表的基本操作代码

作者：AllinToyou | 2024-05-28 08:44:01

赞

踩

单链表的基本操作代码

目录

一、单链表的定义和表示

二、单链表的存储结构

三、单链表中的操作

1.单链表的初始化

2.创建单链表(前插法创建单链表)

实现代码

 运行结果

3. 创建单链表(后插法创建单链表)

实现代码

运行结果

4.单链表的取值

实现代码

 运行结果

5.单链表的按值查找

实现代码

运行结果

6.单链表的插入

实现代码

 运行结果

7.单链表的删除

实现代码

 运行结果

8.查找单链表中某个元素的前驱

实现代码

运行结果

9.查找单链表中某个元素的后继

实现代码

运行结果

一、单链表的定义和表示

线性表链式存储结构的特点是：用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的，也可以是不连续的)。

二、单链表的存储结构

  1. //定义单链表的结构类型
  2. typedef int ElemType;
  3. //------单链表的存储结构-----// 
  4. typedef struct LNode
  5. {
  6. 	ElemType data;	     //结点的数据域
  7. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  8.  }LNode,*LinkList;   //LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型

三、单链表中的操作

  • InitList(LinkList &L)：单链表的初始化
  • CreateList_H(LinkList &L,int n)：前插法创建单链表——时间复杂度O(n）
  • CreateList_R(LinkList &L,int n)：后插法创建单链表——时间复杂度O(n）
  • GetElem(LinkList L,int i,ElemType &e)：单链表的取值——时间复杂度O(n）
  • ListInsert(LinkList &L,int i,ElemType e)：单链表的插入——时间复杂度O(n）
  • ListDelete(LinkList &L,int i)：单链表的删除——时间复杂度O(n）
  • LocateElem(LinkList L,ElemType e)：单链表的按值查找——时间复杂度O(n）
  • ListPrior(LinkList L,ElemType e,ElemType *pre)：查找单链表中某个元素的前驱——时间复杂度O(n）
  • ListNext(LinkList L,ElemType e,ElemType *next)：查找单链表中某个元素的后继——时间复杂度O(n）

1.单链表的初始化

  1. //------单链表的初始化-----//
  2.   //【算法步骤】//
  3. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  4. 	//2.头结点的指针域置空。
  5. Status InitList(LinkList &L)
  6. {
  7. 	//构造一个空的单链表L
  8. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  9. 	L->next=NULL;     //头结点的指针域置空
  10. 	return OK; 
  11.  }

2.创建单链表(前插法创建单链表)

  1. //------前插法创建单链表-----//
  2.   //【算法步骤】//
  3. 	//1.创建一个只有头结点的空链表。
  4. 	//2.根据待创建链表包括的元素个数n,循环n次执行以下操作：
  5. 	   //生成一个新结点*P； 
  6. 	   //输入元素值赋给新结点*p的数据域；
  7. 	   //将新结点*p插入到头结点之后；
  8. void CreateList_H(LinkList &L,int n)
  9. {
  10. 	//逆位序输入n个元素的值，建立带表头结点的单链表L
  11. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  12. 	L->next=NULL;    //先建立一个带头结点的空链表 
  13. 	for(int i=0;i<n;++i)
  14. 	{
  15. 		LinkList p=new LNode;  //生成新结点*p
  16. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  17. 		p->next=L->next;
  18. 		L->next=p;    //将新结点*p插入到头结点之后 
  19. 	 } 
  20.  }

实现代码

  1. //-------------前插法创建单链表------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------前插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.根据待创建链表包括的元素个数n,循环n次执行以下操作：
  33. 	   //生成一个新结点*P； 
  34. 	   //输入元素值赋给新结点*p的数据域；
  35. 	   //将新结点*p插入到头结点之后；
  36. void CreateList_H(LinkList &L,int n)
  37. {
  38. 	//逆位序输入n个元素的值，建立带表头结点的单链表L
  39. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  40. 	L->next=NULL;    //先建立一个带头结点的空链表 
  41. 	for(int i=0;i<n;++i)
  42. 	{
  43. 		LinkList p=new LNode;  //生成新结点*p
  44. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  45. 		p->next=L->next;
  46. 		L->next=p;    //将新结点*p插入到头结点之后 
  47. 	 } 
  48.  }
  49.  
  50. //------打印单链表函数-----//  
  51. void PrintList(LinkList &L)
  52. {	
  53. 	printf("当前单链表中所有元素为："); 
  54. 	LinkList p=L->next;
  55. 	if(p==NULL) return;
  56. 	else
  57. 	{
  58. 		while(p!=NULL)
  59. 		{
  60. 			if(p->next==NULL)     
  61. 			{
  62. 				printf("%d",p->data);
  63. 			}
  64. 			else
  65. 			{
  66. 				printf("%d->",p->data);
  67. 			}
  68. 			p=p->next;
  69. 		}   
  70. 	}
  71. 	printf("\n");
  72. } 
  73.  
  74. //------创建单链表函数------//
  75. void CreateList(LinkList &L) 
  76. {
  77. 	int n;
  78. 	printf("请输入要创建的单链表的长度：");
  79. 	scanf("%d",&n);
  80. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  81. 	CreateList_H(L,n);
  82. 	printf("单链表创建成功！\n");
  83. 	PrintList(L);
  84. 	
  85. }
  86.  
  87. //------主函数-----//
  88. int main()
  89. {	
  90. 	int n;
  91. 	LinkList L; 
  92. 	InitList(L);
  93. 	CreateList(L);
  94.  }

 运行结果

3. 创建单链表(后插法创建单链表)

  1. //------后插法创建单链表-----//
  2.   //【算法步骤】//
  3. 	//1.创建一个只有头结点的空链表。
  4. 	//2.尾指针r初始化，指向头结点。 
  5. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  6. 	   //生成一个新结点*P； 
  7. 	   //输入元素值赋给新结点*p的数据域；
  8. 	   //将新结点*p插入到尾结点*r之后；
  9. 	   //尾指针r指向新的尾结点*p。 
  10. void CreateList_R(LinkList &L,int n)
  11. {
  12. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  13. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  14. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  15. 	LinkList r=L;             //尾指针r指向头结点 
  16. 	for(int i=0;i<n;++i)
  17. 	{
  18. 		LinkList p=new LNode;  //生成新结点*p
  19. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  20. 		p->next=NULL;
  21. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  22. 		r=p;          //r指向新的尾结点*p 
  23. 	 } 
  24.  }

实现代码

  1. //-------------后插法创建单链表------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 } 
  52.  }
  53.  
  54. //------打印单链表函数-----//  
  55. void PrintList(LinkList &L)
  56. {	
  57. 	printf("当前单链表中所有元素为："); 
  58. 	LinkList p=L->next;
  59. 	if(p==NULL) return;
  60. 	else
  61. 	{
  62. 		while(p!=NULL)
  63. 		{	
  64. 			if(p->next==NULL)
  65. 			{
  66. 				printf("%d",p->data);
  67. 			}
  68. 			else
  69. 			{
  70. 				printf("%d->",p->data);
  71. 			}
  72. 			p=p->next;
  73. 		}
  74. 		
  75. 	}
  76. 	printf("\n");
  77. } 
  78.  
  79. //------创建单链表函数------//
  80. void CreateList(LinkList &L) 
  81. {
  82. 	int n;
  83. 	printf("请输入要创建的单链表的长度：");
  84. 	scanf("%d",&n);
  85. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  86. 	CreateList_R(L,n);
  87. 	printf("单链表创建成功！\n");
  88. 	PrintList(L);
  89. 	
  90. }
  91.  
  92. //------主函数-----//
  93. int main()
  94. {	
  95. 	int n;
  96. 	LinkList L; 
  97. 	InitList(L);
  98. 	CreateList(L);
  99.  }

运行结果

4.单链表的取值

  1. //-------------单链表的取值------------//
  2. Status GetElem(LinkList L,int i,ElemType &e)
  3. {
  4. 	//在带头结点的单链表L中根据序号i获取元素的值，用e返回L中第i个数据元素的值
  5. 	LinkList p=L->next;	   //初始化，p指向首元结点 
  6. 	int j=1; 			   //计数器初值赋为1
  7. 	while(p && j<i)
  8. 	{
  9. 		p=p->next;		  //指向下一个结点
  10. 		++j;	          //计数器j相应加1 
  11. 	 } 
  12. 	if(!p||j>i) return ERROR;  //i值不合法i>n或i<=0
  13. 	e=p->data;				   //取第i个结点的数据域 
  14. 	return OK; 
  15.  }

实现代码

  1. //-------------单链表的取值------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //-------------单链表的取值------------//
  55. Status GetElem(LinkList L,int i,ElemType &e)
  56. {
  57. 	//在带头结点的单链表L中根据序号i获取元素的值，用e返回L中第i个数据元素的值
  58. 	LinkList p=L->next;	   //初始化，p指向首元结点 
  59. 	int j=1; 			   //计数器初值赋为1
  60. 	while(p && j<i)
  61. 	{
  62. 		p=p->next;		  //指向下一个结点
  63. 		++j;	          //计数器j相应加1 
  64. 	 } 
  65. 	if(!p||j>i) return ERROR;  //i值不合法i>n或i<=0
  66. 	e=p->data;				   //取第i个结点的数据域 
  67. 	return OK; 
  68.  } 
  69.  
  70.  
  71.  
  72. //------打印单链表函数-----//  
  73. void PrintList(LinkList L)
  74. {	
  75. 	printf("当前单链表中所有元素为："); 
  76. 	LinkList p=L->next;
  77. 	if(p==NULL) return;
  78. 	else
  79. 	{
  80. 		while(p!=NULL)
  81. 		{	
  82. 			if(p->next==NULL)
  83. 			{
  84. 				printf("%d",p->data);
  85. 			}
  86. 			else
  87. 			{
  88. 				printf("%d->",p->data);
  89. 			}
  90. 			p=p->next;
  91. 		}	
  92. 	}
  93. 	printf("\n");
  94. } 
  95.  
  96. //------创建单链表函数------//
  97. void CreateList(LinkList &L) 
  98. {
  99. 	int n;
  100. 	printf("请输入要创建的单链表的长度：");
  101. 	scanf("%d",&n);
  102. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  103. 	CreateList_R(L,n);
  104. 	printf("单链表创建成功！\n");
  105. 	PrintList(L);
  106. }
  107.  
  108. //------单链表取值函数------//
  109. void GetList(LinkList &L)
  110. {
  111. 	int i,e;
  112. 	printf("请输入要取的数据元素的序号为：");
  113. 	scanf("%d",&i);
  114. 	bool flag=GetElem(L,i,e);
  115. 	if(flag)
  116. 	{
  117. 		printf("单链表中序号%d对应的数据元素%d取值成功！\n",i,e);
  118. 		PrintList(L);	
  119. 	}
  120. 	else
  121. 	{
  122. 		printf("单链表中序号%d对应的数据元素%d取值失败！\n",i,e);
  123. 	}	
  124.  } 
  125.  
  126. //------主函数-----//
  127. int main()
  128. {	
  129. 	int n;
  130. 	LinkList L; 
  131. 	InitList(L);
  132. 	CreateList(L);
  133. 	GetList(L);
  134.  }

 运行结果

5.单链表的按值查找

  1. //------单链表的按值查找-----//
  2.   //【算法步骤】// 
  3. 	//1.用指针P指向首元结点。
  4. 	//2.从首元结点开始依次顺着链域next向下查找，只要指向当前结点的指针p不为空,并且p所指向结点的数据域不等于给定值e,则循环执行以下操作：p指向下一个结点。
  5. 	//3.返回p。若查找成功，p此时即为结点的地址值，若查找失败，p的值即为NULL。
  6. bool LocateElem(LinkList L,ElemType e)
  7. {
  8. 	//在带头结点的单链表L中查找值为e的元素
  9. 	LinkList p=L->next;       //初始化，p指向首元结点
  10. 	while(p && p->data!=e)   //顺着链域向后扫描，直到p为空或p所指结点的数据域等于e 
  11. 		p=p->next;   //p指向下一个结点 
  12. 	return p;		 //查找成功返回值为e的结点地址p，查找失败p为NULL 
  13.  }

实现代码

  1. //-------------单链表的按值查找------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //------单链表的按值查找-----//
  55.   //【算法步骤】// 
  56. 	//1.用指针P指向首元结点。
  57. 	//2.从首元结点开始依次顺着链域next向下查找，只要指向当前结点的指针p不为空,并且p所指向结点的数据域不等于给定值e,则循环执行以下操作：p指向下一个结点。
  58. 	//3.返回p。若查找成功，p此时即为结点的地址值，若查找失败，p的值即为NULL。
  59. bool LocateElem(LinkList L,ElemType e)
  60. {
  61. 	//在带头结点的单链表L中查找值为e的元素
  62. 	LinkList p=L->next;       //初始化，p指向首元结点
  63. 	while(p && p->data!=e)   //顺着链域向后扫描，直到p为空或p所指结点的数据域等于e 
  64. 		p=p->next;   //p指向下一个结点 
  65. 	return p;		 //查找成功返回值为e的结点地址p，查找失败p为NULL 
  66.  } 
  67.  
  68. //------打印单链表函数-----//  
  69. void PrintList(LinkList L)
  70. {	
  71. 	printf("当前单链表中所有元素为："); 
  72. 	LinkList p=L->next;
  73. 	if(p==NULL) return;
  74. 	else
  75. 	{
  76. 		while(p!=NULL)
  77. 		{	
  78. 			if(p->next==NULL)
  79. 			{
  80. 				printf("%d",p->data);
  81. 			}
  82. 			else
  83. 			{
  84. 				printf("%d->",p->data);
  85. 			}
  86. 			p=p->next;
  87. 		}	
  88. 	}
  89. 	printf("\n");
  90. } 
  91.  
  92. //------创建单链表函数------//
  93. void CreateList(LinkList &L) 
  94. {
  95. 	int n;
  96. 	printf("请输入要创建的单链表的长度：");
  97. 	scanf("%d",&n);
  98. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  99. 	CreateList_R(L,n);
  100. 	printf("单链表创建成功！\n");
  101. 	PrintList(L);
  102. }
  103.  
  104. //------单链表查找函数------//
  105. void SearchList(LinkList &L)
  106. {
  107. 	int e;
  108. 	printf("请输入要查找的数据元素为：");
  109. 	scanf("%d",&e);
  110. 	bool flag=LocateElem(L,e);
  111. 	if(flag)
  112. 	{
  113. 		printf("单链表中元素%d查找成功！\n",e);
  114. 		PrintList(L);	
  115. 	}
  116. 	else
  117. 	{
  118. 		printf("单链表中元素%d查找失败！\n",e);
  119. 	}	
  120.  } 
  121.  
  122. //------主函数-----//
  123. int main()
  124. {	
  125. 	int n;
  126. 	LinkList L; 
  127. 	InitList(L);
  128. 	CreateList(L);
  129. 	SearchList(L);
  130.  }

运行结果

  

6.单链表的插入

  1. //------单链表的插入-----//
  2.   //【算法步骤】//
  3.   //将值为e的新结点插入到表的第i个结点的位置上，即插入到结点ai-1与ai之间，具体插入过程如图所示，步骤如下： 
  4. 	//1.查找结点ai-1并由指针p指向该结点。
  5. 	//2.生成一个新结点*s。 
  6. 	//3.将新结点*s的数据域置为e。 
  7. 	//4.将新结点*s的指针域指向结点ai。
  8. 	//5.将结点*p的指针域指向新结点*s。
  9. Status ListInsert(LinkList &L,int i,ElemType e)
  10. {
  11. 	//在带头结点的单链表L中第i个位置插入值为e的新结点 
  12. 	LinkList p=L;
  13. 	int j=0;
  14. 	while(p && (j<i-1)) 
  15. 	{
  16. 		p=p->next;   //查找第i-1个结点，p指向该结点 
  17. 		++j;
  18. 	}
  19. 	if(!p||j>i-1) return ERROR;  //i>n+1或者i<1
  20. 	LinkList s=new LNode;    //生成新结点*s 
  21. 	s->data=e;		//将结点*s的数据域置为e 
  22. 	s->next=p->next;//将结点*s的指针域指向结点ai 
  23. 	p->next=s;		//将结点*p的指针域指向结点*s 
  24. 	return OK; 	 
  25.  }

实现代码

  1. //-------------单链表的插入(先用后插法创建一个单链表，然后在单链表中第i个位置插入值尾e的新结点)------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //------单链表的插入-----//
  55.   //【算法步骤】//
  56.   //将值为e的新结点插入到表的第i个结点的位置上，即插入到结点ai-1与ai之间，具体插入过程如图所示，步骤如下： 
  57. 	//1.查找结点ai-1并由指针p指向该结点。
  58. 	//2.生成一个新结点*s。 
  59. 	//3.将新结点*s的数据域置为e。 
  60. 	//4.将新结点*s的指针域指向结点ai。
  61. 	//5.将结点*p的指针域指向新结点*s。
  62. Status ListInsert(LinkList &L,int i,ElemType e)
  63. {
  64. 	//在带头结点的单链表L中第i个位置插入值为e的新结点 
  65. 	LinkList p=L;
  66. 	int j=0;
  67. 	while(p && (j<i-1)) 
  68. 	{
  69. 		p=p->next;   //查找第i-1个结点，p指向该结点 
  70. 		++j;
  71. 	}
  72. 	if(!p||j>i-1) return ERROR;  //i>n+1或者i<1
  73. 	LinkList s=new LNode;    //生成新结点*s 
  74. 	s->data=e;		//将结点*s的数据域置为e 
  75. 	s->next=p->next;//将结点*s的指针域指向结点ai 
  76. 	p->next=s;		//将结点*p的指针域指向结点*s 
  77. 	return OK; 	 
  78.  } 
  79.  
  80. //------打印单链表函数-----//  
  81. void PrintList(LinkList L)
  82. {	
  83. 	printf("当前单链表中所有元素为："); 
  84. 	LinkList p=L->next;
  85. 	if(p==NULL) return;
  86. 	else
  87. 	{
  88. 		while(p!=NULL)
  89. 		{	
  90. 			if(p->next==NULL)
  91. 			{
  92. 				printf("%d",p->data);
  93. 			}
  94. 			else
  95. 			{
  96. 				printf("%d->",p->data);
  97. 			}
  98. 			p=p->next;
  99. 		}	
  100. 	}
  101. 	printf("\n");
  102. } 
  103.  
  104. //------创建单链表函数------//
  105. void CreateList(LinkList &L) 
  106. {
  107. 	int n;
  108. 	printf("请输入要创建的单链表的长度：");
  109. 	scanf("%d",&n);
  110. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  111. 	CreateList_R(L,n);
  112. 	printf("单链表创建成功！\n");
  113. 	PrintList(L);
  114. }
  115.  
  116. //------单链表插入函数------//
  117. void InsertList(LinkList &L)
  118. {
  119. 	int i,e;
  120. 	printf("请输入要插入的位置：");
  121. 	scanf("%d",&i);
  122. 	printf("请输入要在第%d个位置插入的数据元素：",i);
  123. 	scanf("%d",&e); 
  124. 	bool flag=ListInsert(L,i,e);
  125. 	if(flag)
  126. 	{
  127. 		printf("元素%d插入单链表成功！\n", e);
  128. 		PrintList(L);	
  129. 	}
  130. 	else
  131. 	{
  132. 		printf("元素%d插入单链表失败！\n",e);
  133. 	}	
  134.  } 
  135.  
  136. //------主函数-----//
  137. int main()
  138. {	
  139. 	int n;
  140. 	LinkList L; 
  141. 	InitList(L);
  142. 	CreateList(L);
  143. 	InsertList(L);
  144.  }

 运行结果

7.单链表的删除

  1. //------单链表的删除-----//
  2.   //【算法步骤】//
  3.   //将删除单链表的第i个结点ai，具体插入过程如图所示，步骤如下： 
  4. 	//1.查找结点ai-1并由指针p指向该结点。
  5. 	//2.临时保存待删除结点ai的地址在q中，以备释放。 
  6. 	//3.结点*p的指针域指向ai的直接后继结点。 
  7. 	//4.释放结点ai的空间。 
  8. Status ListDelete(LinkList &L,int i)
  9. {
  10. 	//在待头结点的单链表L中，删除第i个元素
  11. 	LinkList p=L;
  12. 	int j=0;
  13. 	while((p->next)&&(j<i-1))   //查找第i-1个结点，p指向该结点 
  14. 	{
  15. 		p=p->next;
  16. 		++j;
  17. 	 }
  18. 	 if(!(p->next)||(j>i-1)) return ERROR;  //当i>n或i<1时，删除位置不合理
  19. 	 LinkList q=p->next;       //临时保存被删结点的地址以备释放 
  20. 	 p->next=q->next;		   //改变删除结点前驱结点的指针域 
  21. 	 delete q;                 //释放删除结点的空间 
  22. 	 return OK; 
  23.  }

实现代码

  1. //-------------单链表的删除(先用后插法创建一个单链表，然后删除单链表的第i个结点ai)------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //------单链表的删除-----//
  55.   //【算法步骤】//
  56.   //将删除单链表的第i个结点ai，具体插入过程如图所示，步骤如下： 
  57. 	//1.查找结点ai-1并由指针p指向该结点。
  58. 	//2.临时保存待删除结点ai的地址在q中，以备释放。 
  59. 	//3.结点*p的指针域指向ai的直接后继结点。 
  60. 	//4.释放结点ai的空间。 
  61. Status ListDelete(LinkList &L,int i)
  62. {
  63. 	//在待头结点的单链表L中，删除第i个元素
  64. 	LinkList p=L;
  65. 	int j=0;
  66. 	while((p->next)&&(j<i-1))   //查找第i-1个结点，p指向该结点 
  67. 	{
  68. 		p=p->next;
  69. 		++j;
  70. 	 }
  71. 	 if(!(p->next)||(j>i-1)) return ERROR;  //当i>n或i<1时，删除位置不合理
  72. 	 LinkList q=p->next;       //临时保存被删结点的地址以备释放 
  73. 	 p->next=q->next;		   //改变删除结点前驱结点的指针域 
  74. 	 delete q;                 //释放删除结点的空间 
  75. 	 return OK; 
  76.  } 
  77.  
  78. //------打印单链表函数-----//  
  79. void PrintList(LinkList L)
  80. {	
  81. 	printf("当前单链表中所有元素为："); 
  82. 	LinkList p=L->next;
  83. 	if(p==NULL) return;
  84. 	else
  85. 	{
  86. 		while(p!=NULL)
  87. 		{	
  88. 			if(p->next==NULL)
  89. 			{
  90. 				printf("%d",p->data);
  91. 			}
  92. 			else
  93. 			{
  94. 				printf("%d->",p->data);
  95. 			}
  96. 			p=p->next;
  97. 		}	
  98. 	}
  99. 	printf("\n");
  100. } 
  101.  
  102. //------创建单链表函数------//
  103. void CreateList(LinkList &L) 
  104. {
  105. 	int n;
  106. 	printf("请输入要创建的单链表的长度：");
  107. 	scanf("%d",&n);
  108. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  109. 	CreateList_R(L,n);
  110. 	printf("单链表创建成功！\n");
  111. 	PrintList(L);
  112. }
  113.  
  114. //------单链表删除函数------//
  115. void DeleteList(LinkList &L)
  116. {
  117. 	int i;
  118. 	printf("请输入要删除的位置：");
  119. 	scanf("%d",&i);
  120. 	bool flag=ListDelete(L,i);
  121. 	if(flag)
  122. 	{
  123. 		printf("单链表中第%d个位置的元素删除成功！\n",i);
  124. 		PrintList(L);	
  125. 	}
  126. 	else
  127. 	{
  128. 		printf("单链表中第%d位置的元素删除失败！\n",i);
  129. 	}	
  130.  } 
  131.  
  132. //------主函数-----//
  133. int main()
  134. {	
  135. 	int n;
  136. 	LinkList L; 
  137. 	InitList(L);
  138. 	CreateList(L);
  139. 	DeleteList(L);
  140.  }

 运行结果

8.查找单链表中某个元素的前驱

  1. //-------------查找单链表中某个元素的前驱------------//
  2. Status ListPrior(LinkList L,ElemType e,ElemType *pre)
  3. {
  4. 	LinkList q=L->next;      //初始化，q指向首元结点
  5. 	if(!q) return ERROR;	//若链表为空
  6. 	LinkList p=q->next;	    //p指向第二个结点 
  7. 	while(p)
  8. 	{
  9. 		if(p->data==e)
  10. 		{
  11. 			*pre=q->data;
  12. 			return OK;
  13. 		}
  14. 		else
  15. 		{
  16. 			q=p;
  17. 			p=p->next;
  18. 		}
  19. 	 } 
  20. 	return ERROR;
  21. }

实现代码

  1. //-------------查找单链表中某个元素的前驱------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //-------------查找单链表中某个元素的前驱------------//
  55. Status ListPrior(LinkList L,ElemType e,ElemType *pre)
  56. {
  57. 	LinkList q=L->next;      //初始化，q指向首元结点
  58. 	if(!q) return ERROR;	//若链表为空
  59. 	LinkList p=q->next;	    //p指向第二个结点 
  60. 	while(p)
  61. 	{
  62. 		if(p->data==e)
  63. 		{
  64. 			*pre=q->data;
  65. 			return OK;
  66. 		}
  67. 		else
  68. 		{
  69. 			q=p;
  70. 			p=p->next;
  71. 		}
  72. 	 } 
  73. 	return ERROR;
  74. }
  75.  
  76. //------打印单链表函数-----//  
  77. void PrintList(LinkList L)
  78. {	
  79. 	printf("当前单链表中所有元素为："); 
  80. 	LinkList p=L->next;
  81. 	if(p==NULL) return;
  82. 	else
  83. 	{
  84. 		while(p!=NULL)
  85. 		{	
  86. 			if(p->next==NULL)
  87. 			{
  88. 				printf("%d",p->data);
  89. 			}
  90. 			else
  91. 			{
  92. 				printf("%d->",p->data);
  93. 			}
  94. 			p=p->next;
  95. 		}	
  96. 	}
  97. 	printf("\n");
  98. } 
  99.  
  100. //------创建单链表函数------//
  101. void CreateList(LinkList &L) 
  102. {
  103. 	int n;
  104. 	printf("请输入要创建的单链表的长度：");
  105. 	scanf("%d",&n);
  106. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  107. 	CreateList_R(L,n);
  108. 	printf("单链表创建成功！\n");
  109. 	PrintList(L);
  110. }
  111.  
  112. //------单链表查找前驱函数------//
  113. void PriorList(LinkList &L)
  114. {
  115. 	int e,pre; 
  116. 	printf("请输入要查找前驱的数据元素为：");
  117. 	scanf("%d",&e);
  118. 	int flag=ListPrior(L,e,&pre);
  119. 	if(flag)
  120. 	{
  121. 		printf("单链表中数据元素%d的前驱为: %d\n",e,pre);
  122. 		printf("查找成功！\n"); 
  123. 		PrintList(L);	
  124. 	}
  125. 	else
  126. 	{
  127. 		printf("查找失败！\n"); 
  128. 	}	
  129.  } 
  130.  
  131. //------主函数-----//
  132. int main()
  133. {	
  134. 	int n;
  135. 	LinkList L; 
  136. 	InitList(L);
  137. 	CreateList(L);
  138. 	PriorList(L);
  139.  }

运行结果

9.查找单链表中某个元素的后继

  1. //-------------查找单链表中某个元素的后继------------//
  2. Status ListNext(LinkList L,ElemType e,ElemType *next)
  3. {
  4. 	LinkList q=L->next;      //初始化，q指向首元结点
  5. 	if(!q) return ERROR;	//若链表为空
  6. 	LinkList p=q->next;	    //p指向第二个结点 
  7. 	while(p)
  8. 	{
  9. 		if(q->data==e)
  10. 		{
  11. 			*next=p->data;
  12. 			return OK;
  13. 		}
  14. 		else
  15. 		{
  16. 			q=p;
  17. 			p=p->next;
  18. 		}
  19. 	 } 
  20. 	return ERROR;
  21. }

实现代码

  1. //-------------查找单链表中某个元素的后继------------//
  2. #include <stdio.h>
  3. #include <iostream>
  4. #define OK 1
  5. #define ERROR 0
  6. using namespace std;
  7. typedef int Status;
  8. //定义单链表的结构类型
  9. typedef int ElemType;
  10. //------单链表的存储结构-----// 
  11. typedef struct LNode
  12. {
  13. 	ElemType data;	     //结点的数据域
  14. 	struct LNode *next;	//结点的指针域，指向下一个指针 
  15.  }LNode,*LinkList;      // LNode是结点，LinkList是链表，LinkList为指向结构体LNode的指针类型 
  16.  
  17. //------单链表的初始化-----//
  18.   //【算法步骤】//
  19. 	//1.生成新结点作为头结点，用头指针L指向头结点。
  20. 	//2.头结点的指针域置空。
  21. Status InitList(LinkList &L)
  22. {
  23. 	//构造一个空的单链表L
  24. 	L=new LNode;      //生成新结点作为头结点，用头指针L指向头结点  或L=(LinkList)malloc(sizeof(LNode))
  25. 	L->next=NULL;     //头结点的指针域置空
  26. 	return OK; 
  27.  } 
  28.  
  29. //------后插法创建单链表-----//
  30.   //【算法步骤】//
  31. 	//1.创建一个只有头结点的空链表。
  32. 	//2.尾指针r初始化，指向头结点。 
  33. 	//3.根据创建链表包括的元素个数n,循环n次执行以下操作：
  34. 	   //生成一个新结点*P； 
  35. 	   //输入元素值赋给新结点*p的数据域；
  36. 	   //将新结点*p插入到尾结点*r之后；
  37. 	   //尾指针r指向新的尾结点*p。 
  38. void CreateList_R(LinkList &L,int n)
  39. {
  40. 	//正位序输入n个元素的值，建立带表头结点的单链表L
  41. 	L=new LNode;      //或L=(LinkList)malloc(sizeof(LNode))
  42. 	L->next=NULL;    //先建立一个带头结点的空链表 	
  43. 	LinkList r=L;             //尾指针r指向头结点 
  44. 	for(int i=0;i<n;++i)
  45. 	{
  46. 		LinkList p=new LNode;  //生成新结点*p
  47. 		cin>>p->data;  //输入元素值赋给新结点*p的数据域
  48. 		p->next=NULL;
  49. 		r->next=p;    //将新结点*p插入到尾结点*r之后 
  50. 		r=p;          //r指向新的尾结点*p 
  51. 	 }
  52.  }
  53.  
  54. //-------------查找单链表中某个元素的后继------------//
  55. Status ListNext(LinkList L,ElemType e,ElemType *next)
  56. {
  57. 	LinkList q=L->next;      //初始化，q指向首元结点
  58. 	if(!q) return ERROR;	//若链表为空
  59. 	LinkList p=q->next;	    //p指向第二个结点 
  60. 	while(p)
  61. 	{
  62. 		if(q->data==e)
  63. 		{
  64. 			*next=p->data;
  65. 			return OK;
  66. 		}
  67. 		else
  68. 		{
  69. 			q=p;
  70. 			p=p->next;
  71. 		}
  72. 	 } 
  73. 	return ERROR;
  74. }
  75.  
  76. //------打印单链表函数-----//  
  77. void PrintList(LinkList L)
  78. {	
  79. 	printf("当前单链表中所有元素为："); 
  80. 	LinkList p=L->next;
  81. 	if(p==NULL) return;
  82. 	else
  83. 	{
  84. 		while(p!=NULL)
  85. 		{	
  86. 			if(p->next==NULL)
  87. 			{
  88. 				printf("%d",p->data);
  89. 			}
  90. 			else
  91. 			{
  92. 				printf("%d->",p->data);
  93. 			}
  94. 			p=p->next;
  95. 		}	
  96. 	}
  97. 	printf("\n");
  98. } 
  99.  
  100. //------创建单链表函数------//
  101. void CreateList(LinkList &L) 
  102. {
  103. 	int n;
  104. 	printf("请输入要创建的单链表的长度：");
  105. 	scanf("%d",&n);
  106. 	printf("请输入依次输入%d个数（空格隔开）：",n);
  107. 	CreateList_R(L,n);
  108. 	printf("单链表创建成功！\n");
  109. 	PrintList(L);
  110. }
  111.  
  112. //------单链表查找后继函数------//
  113. void NextList(LinkList &L)
  114. {
  115. 	int e,next; 
  116. 	printf("请输入要查找前驱的数据后继为：");
  117. 	scanf("%d",&e);
  118. 	int flag=ListNext(L,e,&next);
  119. 	if(flag)
  120. 	{
  121. 		printf("单链表中数据元素%d的后继为: %d\n",e,next);
  122. 		printf("查找成功！\n"); 
  123. 		PrintList(L);	
  124. 	}
  125. 	else
  126. 	{
  127. 		printf("查找失败！\n"); 
  128. 	}	
  129.  } 
  130.  
  131. //------主函数-----//
  132. int main()
  133. {	
  134. 	int n;
  135. 	LinkList L; 
  136. 	InitList(L);
  137. 	CreateList(L);
  138. 	NextList(L);
  139.  }

运行结果

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/636613
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号