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

数据结构之线性表_线性表的特点

作者：AllinToyou | 2024-06-10 22:42:35

赞

踩

线性表的特点

一、线性表的定义与特点

1.定义

线性表是由n(n≥0)个同类型的数据元素构成的有限序列的线性结构。

2.特点

（1）同一性：线性表由同类数据元素组成，每一个数据元素必须属于同一个数据对象；

（2）有穷性：线性表由有限个数据元素组成，表长度就是表中数据元素的个数；

（3）有序性：线性表中相邻数据元素之间存在着序偶关系。

二、线性表的顺序存储

1.定义

线性表的顺序存储是指在内存中用一块地址连续的存储空间顺序存放线性表的各数据元素，使得线性表中在逻辑结构上相邻的数据元素存储在连续的物理存储单元中，即通过数据元素物理存储的连续性来反映数据元素之间逻辑上的相邻关系。

顺序表的结构体定义如下：

  1. typedef int ElementType;
  2. typedef struct
  3. {
  4. 	ElementType *array;   // 存放元素的数组
  5. 	int length;  // 当前长度
  6. 	int capacity;  // 数组容量
  7. }SqList;

2.主要操作的实现

（1）顺序表的创建

  1. // 构造一个空的顺序表
  2. SqList *createList(int capacity)
  3. {
  4. 	SqList *L;                            // 定义顺序表
  5. 	L=(SqList*)malloc(sizeof(SqList));    // 开辟一块内存空间给顺序表L
  6. 	L->length=0;              // 顺序表的长度为0
  7. 	L->capacity=capacity;    // 数组容量
  8. 	L->array=(ElementType*)malloc(capacity*sizeof(ElementType)); // 在顺序表L上为数组开辟空间
  9. 	
  10. 	return L;
  11. }

 （2）获得顺序表的数据元素

  1. int GetElement(SqList *L,int i,ElementType *e)
  2. {
  3. 	if(i<1||i>L->length)
  4. 	{
  5. 		return 0;
  6. 	}
  7. 	*e=L->array[i-1];
  8. 	return 1;
  9. }

 （3）顺序表的查找

顺序表的查找是指在顺序表中查找与给定值 e 相等的数据元素。下面采取从后向前查找的方式，若在顺序表 L 中找到与 e 相等的元素，则返回该元素在顺序表中的下标；否则，返回0。

  1. int find(SqList *L,ElementType e)
  2. {
  3. 	int i;
  4. 	i=L->length-1;
  5. 	while(i>=0&&L->array[i]!=e){
  6. 		i--;
  7. 	}
  8. 	if(i<0)
  9. 	{
  10. 		return 0;
  11. 	}
  12. 	return i;
  13. }

查找成功的平均比较次数为 (n+1)/2，时间复杂度为O(n) 。

（4）顺序表的插入

  1. int insertlist(SqList *L,int i,ElementType e)
  2. {
  3. 	int k;
  4. 	if(L->length>=L->capacity)   // 1.判断顺序表的存储空间是否满
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	if(i<1||i>L->length+1)     // 2.判断插入位置i是否合法
  9. 	{
  10. 		return 0;
  11. 	}
  12. 	for(k=L->length-1;k>=i-1;k--)
  13. 	{
  14. 		L->array[k+1]=L->array[k];    // 3.从最后一个元素开始向后移动
  15. 	}
  16. 	L->array[i-1]=e;      // 4.在第i个位置插入元素
  17. 	L->length++;         // 5.表长度加1
  18.  
  19. 	return 1;
  20. }

 在顺序表上做插入操作平均移动数据元素的次数为 n/2，时间复杂度为O(n) 。

（5）顺序表的删除

  1. int deletelist(SqList *L,int i,ElementType *e)
  2. {
  3. 	int k;
  4. 	if(i<1||i>L->length)    // 1.判断删除位置i是否合法
  5. 	{
  6. 		return 0;
  7. 	}
  8. 	*e=L->array[i-1];    // 删除的第i个元素
  9. 	for(k=i;k<L->length;k++)
  10. 	{
  11. 		L->array[k-1]=L->array[k];    // 2. 从i+1个元素开始向前移动
  12. 	}
  13. 	L->length--;
  14. 	return 1;
  15. }

在顺序表上做删除操作平均移动数据元素的次数为 (n-1)/2，时间复杂度为O(n) 。

3.应用实例

顺序表的合并，求两个顺序表中数据元素的并集

  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4.  
  5. #define SIZE 100
  6.  
  7. typedef int ElementType;
  8. typedef struct
  9. {
  10. 	ElementType *array;   // 存放元素的数组
  11. 	int length;  // 当前长度
  12. 	int capacity;  // 数组容量
  13. }SqList;
  14.  
  15. // 顺序表的创建
  16. SqList *createList(int capacity)
  17. {
  18. 	SqList *L;
  19. 	L=(SqList*)malloc(sizeof(SqList));
  20. 	L->length=0;
  21. 	L->capacity=capacity;
  22. 	L->array=(ElementType*)malloc(capacity*sizeof(ElementType));
  23. 	
  24. 	return L;
  25. }
  26.  
  27. // 获得顺序表的元素
  28. int GetElement(SqList *L,int i,ElementType *e)
  29. {
  30. 	if(i<1||i>L->length){
  31. 	return 0;
  32. 	}
  33. 	*e=L->array[i-1];
  34. 	return 1;
  35. }
  36.  
  37. // 顺序表的查找
  38. int find(SqList *L,ElementType e)
  39. {
  40. 	int i;
  41. 	i=L->length-1;
  42. 	while(i>=0&&L->array[i]!=e){
  43. 		i--;
  44. 	}
  45. 	if(i<0)
  46. 	{
  47. 		return 0;
  48. 	}
  49. 	return i;
  50. }
  51.  
  52. // 顺序表的插入
  53. int insertlist(SqList *L,int i,ElementType e)
  54. {
  55. 	int k;
  56. 	if(L->length>=L->capacity)   // 1.判断顺序表的存储空间是否满
  57. 	{
  58. 		return 0;
  59. 	}
  60. 	if(i<1||i>L->length+1)     // 2.判断插入位置i是否合法
  61. 	{
  62. 		return 0;
  63. 	}
  64. 	for(k=L->length-1;k>=i-1;k--)
  65. 	{
  66. 		L->array[k+1]=L->array[k];    // 3.从最后一个元素开始向后移动
  67. 	}
  68. 	L->array[i-1]=e;      // 4.在第i个位置插入元素
  69. 	L->length++;         // 5.表长度加1
  70.  
  71. 	return 1;
  72. }
  73.  
  74. // 顺序表的删除
  75. int deletelist(SqList *L,int i,ElementType *e)
  76. {
  77. 	int k;
  78. 	if(i<1||i>L->length)    // 1.判断删除位置i是否合法
  79. 	{
  80. 		return 0;
  81. 	}
  82. 	*e=L->array[i-1];    // 删除的第i个元素
  83. 	for(k=i;k<L->length;k++)
  84. 	{
  85. 		L->array[k-1]=L->array[k];    // 2. 从i+1个元素开始向前移动
  86. 	}
  87. 	L->length--;
  88. 	return 1;
  89. }
  90.  
  91. // 顺序表的长度
  92. int listlength(SqList *L)
  93. {
  94. 	return L->length;
  95. }
  96.  
  97. //按尾部插入法生成初始数据
  98. void Addlist(SqList *L)
  99. {
  100. 	int value;
  101. 	printf("请输入内容，-1结束\n");
  102. 	scanf("%d",&value);
  103. 	while(value!=-1)
  104. 	{
  105. 		insertlist(L,L->length+1,value);   // 顺序表的插入
  106. 		scanf("%d",&value);
  107. 	}
  108. }
  109.  
  110. //输出数据
  111. void Outputlist(SqList *L)
  112. {
  113. 	int i;
  114. 	for(i=0;i<L->length;i++)
  115. 	{
  116. 		printf("%d ",L->array[i]);
  117. 	}
  118. 	printf("\n");
  119. }
  120.  
  121. // 顺序表的合并：取并集
  122. void mergelist(SqList *L1,SqList *L2)
  123. {
  124. 	int L1_Len,L2_Len;
  125. 	int i;
  126. 	ElementType e;
  127.  
  128. 	L1_Len=listlength(L1);    // 顺序表的长度
  129. 	L2_Len=listlength(L2);
  130.  
  131. 	for(i=1;i<=L2_Len;i++)
  132. 	{
  133. 		GetElement(L2,i,&e);     // 获得顺序表的元素
  134. 		if(!find(L1,e))     // 在表L1中没找到该元素，则将该元素插入表L1中
  135. 		{
  136. 			insertlist(L1,L1->length+1,e);    // 顺序表的插入
  137. 		}
  138. 	}
  139. }
  140.  
  141. int main()
  142. {
  143. 	SqList *LA,*LB;
  144.  
  145. 	LA=createList(SIZE);
  146. 	LB=createList(SIZE);
  147.  
  148. 	printf("尾部插入法生成初始数据：\n");
  149.  
  150. 	Addlist(LA);
  151. 	printf("LA表中元素为：");
  152. 	Outputlist(LA);
  153.  
  154. 	Addlist(LB);
  155. 	printf("LB表中元素为：");
  156. 	Outputlist(LB);
  157.  
  158. 	mergelist(LA,LB);
  159. 	printf("LA和LB取并集后的元素为：");
  160. 	Outputlist(LA);
  161.  
  162. 	return 0;
  163. }

三、线性表的链式存储

1.定义

线性表的链式存储是指在线性表中逻辑上相邻的数据元素在物理位置上并不一定相邻，它是通过‘链’建立起数据元素之间的逻辑关系。

C语言描述单链表类型如下：

  1. typedef int ElementType;
  2. typedef struct Node
  3. {
  4. 	ElementType data;    // 数据域
  5. 	struct Node *next;   // 指针域
  6. }node;
  7. typedef struct Node *LinkList;

2.主要操作的实现

（1）单链表的创建

  1. /*===============================================================
  2. CreateLinkList函数功能：
  3. 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立链表
  4. ===================================================================*/
  5. void createlist(LinkList *L,int n,int a[])
  6. {
  7. 	LinkList p,r;
  8. 	int i;
  9.  
  10. 	(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点
  11. 	r=*L;
  12.  
  13. 	for(i=0;i<n;i++)
  14. 	{
  15. 		p=(LinkList)malloc(sizeof(node));   // 生成新结点
  16. 		p->data=a[i];
  17. 		r->next=p;
  18. 		r=p;
  19. 	}
  20. 	r->next=NULL;
  21. }

（2）单链表的输出

  1. /*===============================================================
  2. Outputlist函数功能：
  3. 依次输出链表L中的每个数据
  4. ===================================================================*/
  5. void Outputlist(LinkList L)
  6. {
  7. 	LinkList p;
  8. 	p=L->next;
  9. 	while(p!=NULL)
  10. 	{
  11. 		printf("%d ",p->data);
  12. 		p=p->next;
  13. 	}
  14. 	printf("\n");
  15. }

时间复杂度为O(n) 。

（3）单链表的查找

单链表的查找有按值查找和按序号查找两种方式。

  1. // 1.按值查找
  2. LinkList findvalue(LinkList L,ElementType x)
  3. {
  4. 	LinkList p;
  5. 	p=L->next;
  6. 	while(p!=NULL && p->data!=x)
  7. 	{
  8. 		p=p->next;
  9. 	}
  10. 	return p;
  11. }
  12. // 2.按序号查找
  13. LinkList locate(LinkList L,int i)
  14. {
  15. 	LinkList p;
  16. 	int k=0;
  17.  
  18. 	p=L;	
  19. 	while(p!=NULL && k<i)
  20. 	{
  21. 		p=p->next;
  22. 		k++;
  23. 	}
  24. 	return p;
  25. }

平均时间复杂度均为O(n) 。

（4）单链表结点的插入

  1. // 单链表结点的插入：第i个位置插入数值x
  2. int Insertlist(LinkList L,int i,ElementType x)
  3. {
  4. 	LinkList p,s;
  5. 	p=locate(L,i-1);  // 查找第i-1个结点，p指向该结点
  6. 	if(p==NULL || i<1)
  7. 	{
  8. 		return 0;
  9. 	}
  10. 	s=(LinkList)malloc(sizeof(node));
  11. 	s->data=x;
  12.  
  13. 	s->next=p->next;
  14. 	p->next=s;
  15.  
  16. 	return 1;
  17. }

（5）单链表结点的删除

单链表结点的删除有按值删除和按序号删除两种方式。

  1. // 1.按值删除
  2. int Deletevalue(LinkList L,ElementType x)
  3. {
  4. 	LinkList p,q;
  5. 	q=L;
  6. 	p=L->next;
  7.  
  8. 	while(p!=NULL && p->data!=x)
  9. 	{
  10. 		q=p;
  11. 		p=p->next;
  12. 	}
  13. 	if(p==NULL)
  14. 		return 0;
  15. 	else
  16. 	{
  17. 		q->next=p->next;
  18. 		free(p);
  19. 		return 1;
  20. 	}
  21. }
  22. // 2.按序号删除
  23. int Deletelocate(LinkList L,int i)
  24. {
  25. 	LinkList p,q;
  26. 	ElementType x;
  27.  
  28. 	p=locate(L,i-1);
  29. 	if(p==NULL || i<1 || p->next==NULL)
  30. 	{
  31. 		return 0;
  32. 	}
  33. 	q=p->next;
  34. 	p->next=q->next;
  35. 	x=q->data;
  36. 	printf("删除的值为：");
  37. 	printf("%d\n",x);
  38. 	free(q);
  39. 	return 1;
  40. }

 注意：一定要找到所删除结点的前驱结点。

删除算法的时间复杂度为O(n) 。

（6）以上单链表主要操作的全部程序

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. typedef int ElementType;
  4. typedef struct Node
  5. {
  6. 	ElementType data;
  7. 	struct Node *next;
  8. }node;
  9. typedef struct Node *LinkList;
  10.  
  11. /*===============================================================
  12. CreateLinkList函数功能：
  13. 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立链表
  14. ===================================================================*/
  15. void createlist(LinkList *L,int n,int a[])
  16. {
  17. 	LinkList p,r;
  18. 	int i;
  19.  
  20. 	(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点
  21. 	r=*L;
  22.  
  23. 	for(i=0;i<n;i++)
  24. 	{
  25. 		p=(LinkList)malloc(sizeof(node));   // 生成新结点
  26. 		p->data=a[i];
  27. 		r->next=p;
  28. 		r=p;
  29. 	}
  30. 	r->next=NULL;
  31. }
  32.  
  33. /*===============================================================
  34. Outputlist函数功能：
  35. 依次输出链表L中的每个数据
  36. ===================================================================*/
  37. void Outputlist(LinkList L)
  38. {
  39. 	LinkList p;
  40. 	p=L->next;
  41. 	while(p!=NULL)
  42. 	{
  43. 		printf("%d ",p->data);
  44. 		p=p->next;
  45. 	}
  46. 	printf("\n");
  47. }
  48.  
  49. // 单链表的查找:1.按值查找；2.按序号查找
  50. LinkList findvalue(LinkList L,ElementType x)
  51. {
  52. 	LinkList p;
  53. 	p=L->next;
  54. 	while(p!=NULL && p->data!=x)
  55. 	{
  56. 		p=p->next;
  57. 	}
  58. 	return p;
  59. }
  60.  
  61. LinkList locate(LinkList L,int i)
  62. {
  63. 	LinkList p;
  64. 	int k=0;
  65.  
  66. 	p=L;	
  67. 	while(p!=NULL && k<i)
  68. 	{
  69. 		p=p->next;
  70. 		k++;
  71. 	}
  72. 	return p;
  73. }
  74.  
  75. // 单链表结点的插入：第i个位置插入数值x
  76. int Insertlist(LinkList L,int i,ElementType x)
  77. {
  78. 	LinkList p,s;
  79. 	p=locate(L,i-1);
  80. 	if(p==NULL || i<1)
  81. 	{
  82. 		return 0;
  83. 	}
  84. 	s=(LinkList)malloc(sizeof(node));
  85. 	s->data=x;
  86.  
  87. 	s->next=p->next;
  88. 	p->next=s;
  89.  
  90. 	return 1;
  91. }
  92.  
  93. // 单链表的删除:1.按值删除；2.按序号删除
  94. int Deletevalue(LinkList L,ElementType x)
  95. {
  96. 	LinkList p,q;
  97. 	q=L;
  98. 	p=L->next;
  99.  
  100. 	while(p!=NULL && p->data!=x)
  101. 	{
  102. 		q=p;
  103. 		p=p->next;
  104. 	}
  105. 	if(p==NULL)
  106. 		return 0;
  107. 	else
  108. 	{
  109. 		q->next=p->next;
  110. 		free(p);
  111. 		return 1;
  112. 	}
  113. }
  114.  
  115. int Deletelocate(LinkList L,int i)
  116. {
  117. 	LinkList p,q;
  118. 	ElementType x;
  119.  
  120. 	p=locate(L,i-1);
  121. 	if(p==NULL || i<1 || p->next==NULL)
  122. 	{
  123. 		return 0;
  124. 	}
  125. 	q=p->next;
  126. 	p->next=q->next;
  127. 	x=q->data;
  128. 	printf("删除的值为：");
  129. 	printf("%d\n",x);
  130. 	free(q);
  131. 	return 1;
  132. }
  133.  
  134. int main()
  135. {
  136. 	int A[]={0};
  137. 	int i,j;
  138. 	int N;
  139. 	LinkList S;
  140. 	ElementType e;
  141. 	int select;
  142.  
  143. 	printf("请输入链表元素的个数：");
  144. 	scanf("%d",&N);
  145. 	for(i=0;i<N;i++)
  146. 	{
  147. 		scanf("%d",&A[i]);
  148. 	}
  149. 	createlist(&S,N,A);
  150. 	printf("单链表中元素为：");
  151. 	Outputlist(S);
  152. 	
  153. 	while(1)
  154. 	{
  155. 		printf("\n\n");
  156. 		printf("                    输入 1 在单链表中插入元素。\n");
  157. 		printf("                    输入 2 则按位置删除单链表中的元素。\n");
  158. 		printf("                    输入 3 则按值删除单链表中的元素。\n");
  159. 		printf("                    输入 4 则显示单链表。\n");
  160. 		printf("                    输入 5 则退出程序。\n");
  161.  
  162. 		printf("请选择输入操作：\n");
  163. 		scanf("%d",&select);
  164. 		switch(select)
  165. 		{
  166. 		case 1:{
  167. 			printf("请输入要插入的位置：\n");
  168. 			scanf("%d", &j);
  169. 			printf("请输入要插入的数值：\n");
  170. 			scanf("%d", &e);
  171. 			Insertlist(S,j,e);
  172. 			printf("插入后表中元素为：");
  173. 			Outputlist(S);
  174. 			   }
  175. 			break;
  176.  
  177. 		case 2:{
  178. 			printf("请输入要删除的位置：\n");
  179. 			scanf("%d", &j);
  180. 			Deletelocate(S,j);
  181. 			printf("删除后表中元素为：");
  182. 			Outputlist(S);
  183. 			   }
  184. 			break;
  185.  
  186. 		case 3:{
  187. 			printf("请输入要删除的值：\n");
  188. 			scanf("%d", &e);
  189. 			Deletevalue(S,e);
  190. 			printf("删除后表中元素为：\n");
  191. 			Outputlist(S);
  192. 				 }
  193. 			break;
  194. 		case 4:{
  195. 			printf("单链表中的元素为：\n");
  196. 			Outputlist(S);
  197. 				 }
  198. 			break;
  199. 		case 5:printf("已退出程序！\n");exit(-1);break;
  200. 		default:printf("输入错误，请重新输入！\n");break;
  201. 		}
  202. 	}
  203. 	return 0;
  204. }

3.应用实例

单链表的合并

例题1：有两个单链表LA和LB，它们的元素均为非递减有序序列。编写一个算法，将它们合并成一个单链表，要求合并后的单链表中的元素也是非递减有序序列，并且不需要额外申请结点空间。

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. typedef int ElementType;
  4. typedef struct Node
  5. {
  6. 	ElementType data;
  7. 	struct Node *next;
  8. }node;
  9. typedef struct Node *LinkList;
  10.  
  11. /*===============================================================
  12. CreateLinkList函数功能：
  13. 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立链表
  14. ===================================================================*/
  15. LinkList createlist(LinkList *L,int n,int a[])
  16. {
  17. 	LinkList p,r;
  18. 	int i;
  19.  
  20. 	(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点
  21. 	r=*L;
  22.  
  23. 	for(i=0;i<n;i++)
  24. 	{
  25. 		p=(LinkList)malloc(sizeof(node));   // 生成新结点
  26. 		p->data=a[i];
  27. 		r->next=p;
  28. 		r=p;
  29. 	}
  30. 	r->next=NULL;
  31. 	return *L;
  32. }
  33.  
  34. /*===============================================================
  35. Outputlist函数功能：
  36. 依次输出链表L中的每个数据
  37. ===================================================================*/
  38. void Outputlist(LinkList L)
  39. {
  40. 	LinkList p;
  41. 	p=L->next;
  42. 	while(p!=NULL)
  43. 	{
  44. 		printf("%d ",p->data);
  45. 		p=p->next;
  46. 	}
  47. 	printf("\n");
  48. }
  49.  
  50. // 单链表的查找:按值查找
  51. LinkList findvalue(LinkList L,ElementType x)
  52. {
  53. 	LinkList p;
  54. 	p=L->next;
  55. 	while(p!=NULL && p->data!=x)
  56. 	{
  57. 		p=p->next;
  58. 	}
  59. 	return p;
  60. }
  61.  
  62. // 单链表的合并：非递减有序序列
  63. void mergelist1(LinkList LA,LinkList LB)
  64. {
  65. 	LinkList pa,pb,pr;
  66. 	pa=LA->next;
  67. 	pb=LB->next;
  68.  
  69. 	LA->next=NULL;   // 此时LA为带头结点的空单链表
  70. 	pr=LA;   // pr为尾指针
  71.  
  72. 	while(pa!=NULL && pb!=NULL)
  73. 	{
  74. 		if(pa->data <= pb->data)
  75. 		{
  76. 			pr->next=pa;
  77. 			pr=pa;
  78. 			pa=pa->next;
  79. 		}
  80. 		else
  81. 		{
  82. 			pr->next=pb;
  83. 			pr=pb;
  84. 			pb=pb->next;
  85. 		}
  86. 	}
  87.  
  88. 	if(pa!=NULL)
  89. 		pr->next=pa;
  90. 	if(pb!=NULL)
  91. 		pr->next=pb;
  92.  
  93. 	free(LB);    // 释放空间
  94. }
  95.  
  96. int main()
  97. {
  98. 	LinkList La,Lb;
  99. 	int A[]={2,2,3};
  100. 	int B[]={1,3,3,4};
  101. 	int NA=sizeof(A) / sizeof(A[0]);
  102. 	int NB=sizeof(B) / sizeof(B[0]);
  103.  
  104. 	createlist(&La,NA,A);
  105. 	printf("序列A中的元素为：");
  106. 	Outputlist(La);
  107.  
  108. 	createlist(&Lb,NB,B);
  109. 	printf("序列B中的元素为：");
  110. 	Outputlist(Lb);
  111.  
  112. 	mergelist1(La,Lb);
  113. 	printf("序列A和序列B合并后的元素为：");
  114. 	Outputlist(La);
  115.  
  116. }

例题2：假设集合A用单链表LA表示，集合B用单链表LB表示，设计算法求这两个集合的差。

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3. typedef int ElementType;
  4. typedef struct Node
  5. {
  6. 	ElementType data;
  7. 	struct Node *next;
  8. }node;
  9. typedef struct Node *LinkList;
  10.  
  11. /*===============================================================
  12. CreateLinkList函数功能：
  13. 创建链表L, 并将给定数组a, 以及数组中元素个数n，尾部插入法建立链表
  14. ===================================================================*/
  15. LinkList createlist(LinkList *L,int n,int a[])
  16. {
  17. 	LinkList p,r;
  18. 	int i;
  19.  
  20. 	(*L)=(LinkList)malloc(sizeof(node));  // 建立头结点
  21. 	r=*L;
  22.  
  23. 	for(i=0;i<n;i++)
  24. 	{
  25. 		p=(LinkList)malloc(sizeof(node));   // 生成新结点
  26. 		p->data=a[i];
  27. 		r->next=p;
  28. 		r=p;
  29. 	}
  30. 	r->next=NULL;
  31. 	return *L;
  32. }
  33.  
  34. /*===============================================================
  35. Outputlist函数功能：
  36. 依次输出链表L中的每个数据
  37. ===================================================================*/
  38. void Outputlist(LinkList L)
  39. {
  40. 	LinkList p;
  41. 	p=L->next;
  42. 	while(p!=NULL)
  43. 	{
  44. 		printf("%d ",p->data);
  45. 		p=p->next;
  46. 	}
  47. 	printf("\n");
  48. }
  49.  
  50. // 单链表的查找:按值查找
  51. LinkList findvalue(LinkList L,ElementType x)
  52. {
  53. 	LinkList p;
  54. 	p=L->next;
  55. 	while(p!=NULL && p->data!=x)
  56. 	{
  57. 		p=p->next;
  58. 	}
  59. 	return p;
  60. }
  61.  
  62. // 单链表的合并：两个集合的差，A-B，即得到所有属于集合A而不属于集合B的元素
  63. void mergelist2(LinkList LA,LinkList LB)
  64. {
  65. 	LinkList pr,pa,temp;
  66. 	pr=LA;
  67. 	pa=LA->next;
  68. 	while(pa!=NULL)
  69. 	{
  70. 		if(findvalue(LB,pa->data)!=NULL)
  71. 		{
  72. 			temp=pa;     // temp为中间变量
  73. 			pr->next=temp->next;
  74. 			pa=temp->next;
  75. 			free(temp);
  76. 		}
  77. 		else
  78. 		{
  79. 			pr=pa;
  80. 			pa=pa->next;
  81. 		}
  82. 	}
  83. }
  84.  
  85. int main()
  86. {
  87. 	LinkList La,Lb;
  88. 	int A[]={2,2,3};
  89. 	int B[]={1,3,3,4};
  90. 	int NA=sizeof(A) / sizeof(A[0]);
  91. 	int NB=sizeof(B) / sizeof(B[0]);
  92.  
  93. 	createlist(&La,NA,A);
  94. 	printf("序列A中的元素为：");
  95. 	Outputlist(La);
  96.  
  97. 	createlist(&Lb,NB,B);
  98. 	printf("序列B中的元素为：");
  99. 	Outputlist(Lb);
  100.  
  101. 	mergelist2(La,Lb);
  102. 	printf("序列A与序列B的差为：");
  103. 	Outputlist(La);
  104.  
  105. }

四、总结

1.顺序存储结构与单链表结构的优缺点

（1）存储分配方式：

顺序存储结构用一段连续的存储单元依次存储线性表的数据元素；单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。

（2）时间性能：

查找：顺序表是一种随机存取结构，对表中任意一个结点都可以在O(1)时间内直接存取；单链表是一种顺序存取结构，对表中的结点需要从头指针顺着链查找才能取得，时间复杂度为O(n) 。

插入和删除：顺序存储结构需要平均移动表长一半的元素，时间复杂度为O(n)；单链表在计算出某位置的指针后，插入和删除的时间复杂度仅为O(1) 。

（3）空间性能：

顺序存储结构需要预先分配存储空间，分大了，容易造成空间浪费，分小了，容易发生溢出；单链表不需要预先分配存储空间，只要有就可以分配，元素个数也不受限制。

2.结论

若线性表需要频繁查找，很少进行插入和删除操作时，宜采用顺序存储结构；若需要频繁插入和删除时，宜采用单链表结构。
 

 

 

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

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

  

闽ICP备14008679号