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

【数据结构（C语言）】顺序表的定义，实现初始化、创建、插入、增、删、改、查等基本操作（详细）_c语言顺序表的初始化,插曲,删除,与查找

作者：很楠不爱3 | 2024-04-15 09:22:45

赞

踩

c语言顺序表的初始化,插曲,删除,与查找

建议新人收藏使用！

目录

前言：

头文件等：

函数的声明：

系统菜单：

​编辑

初始化：

​编辑

添加元素：

​编辑

显示元素：

​编辑

查找元素：

​编辑

修改元素：

​编辑

插入元素：

​编辑

元素排序：

​编辑

元素的删除：

元素备份：

​编辑

main函数：

前言：

数据结构包括三个方面：

  • 逻辑结构
  • 存储结构
  • 运算

数据的存储结构是数据及数据之间的关系在计算机内的表示形式。

而线性表有两种典型的存储结构：

  • 顺序存储结构
  • 链式存储结构

本节我们所学习的是顺序存储结构及顺序表。

线性表的顺序存储是指使用连续的存储空间，按照数据元素在线性表中的序号依次存储数据元素。

采用这种存储结构的线性表称为：顺序表。

设线性表的第一个元素a0在内存中的存储地址为loc(a0)，每个元素占用k个存储单元，则线性表中任意元素ai在内存的存储地址为：间。

只要给定loc(a0)和k，就可以确定线性表中任意一个元素的存储地址，换句话说，顺序表是一种随机存储结构。

线性表的顺序表示定义如下：

  1. typedef struct seqList
  2. {
  3.     int n;
  4.     int maxLength;
  5.     ElemType *element;
  6. } SeqList;

ElemType是自定义类型，类似于宏定义，可以根据自己的需求将其定义为所需的数据类型。

例如，在本节中，ElemType被定义为int型，即ElemType i的实际意义等同于int i。

该线性表在一维数组中的存储形式如下：

顺序表的基本运算有：

  • 初始化
  • 查找
  • 插入
  • 删除
  • 输出
  • 撤销
  • 主函数main

目录

头文件等：

系统菜单：

顺序表的初始化：

添加元素：

显示元素：

查找元素：

修改元素：

插入元素：

元素排序：

元素的删除：

元素备份：

main函数：

运行效果：

头文件等：

  1. /*
  2. 顺序表操作(顺序表是将所有的元素存放在一个一维数组里面，每个元素都连续存放）
  3. */
  4. #include<stdio.h>
  5. #include<stdlib.h>
  6. typedef int ElemType;  //给int指定别名 
  7.  
  8. typedef struct seqList{
  9. 	int n;          //该长度表示顺序表的实际长度
  10. 	int maxLength;  //表示数组的长度
  11. 	ElemType * element; //表示指针类型,等价于 int * element;
  12. }SeqList;
  13.  
  14. SeqList sq;  //结构体变量
  15.

函数的声明：

  1. //函数的声明
  2. void init(SeqList *L,int maxLen);  //初始化
  3. void add(SeqList *L);    //添加元素
  4. void Output(SeqList *L);  //显示元素
  5. void Search(SeqList *L); //查找元素
  6. void Change(SeqList *L); //修改元素
  7. void Sort(SeqList *L);   //元素升序排序
  8. int insert(SeqList * L);  //插入元素
  9. void del(SeqList * L);    //删除元素
  10. void baocun(SeqList *L);  //备份元素

系统菜单：

使用switch选择结构，通入键盘输入选项从而调用各个函数。

值得注意的是，因为需要使用结构体中的数据，故在调用该时需要添加结构体变量。

  1. //定义系统菜单√
  2. void menu( )
  3. {
  4. 	int op;
  5. 	printf("==================================\n");
  6. 	printf("------顺序表的基本操作-----\n");
  7. 	printf("0. 初始化顺序表√            \n");
  8. 	printf("1. 添加元素√                \n");
  9. 	printf("2. 插入元素√                \n");
  10. 	printf("3. 删除元素√                \n");
  11. 	printf("4. 修改元素√                \n");
  12. 	printf("5. 查找元素√                \n");
  13. 	printf("6. 升序排序元素√            \n");
  14. 	printf("7. 备份顺序表√              \n");
  15. 	printf("8. 结束操作√                \n");
  16. 	printf("9. 显示操作√                \n");
  17. 	printf("==================================\n");
  18.  
  19. 	printf("请选择操作的菜单项:");
  20. 	scanf("%d",&op);
  21. 	switch(op){
  22. 	case 0:
  23. 		init(&sq,100);  //初始化操作
  24. 		break;
  25. 	case 1:
  26. 		add(&sq);       //添加操作
  27. 		break;
  28. 	case 2:
  29. 		insert(&sq);
  30. 		break;
  31. 	case 3:
  32. 		del(&sq);
  33. 		break;
  34. 	case 4:
  35. 		Change(&sq);  //修改操作
  36. 		break;
  37. 	case 5:
  38. 		Search(&sq); //查找操作
  39. 		break;
  40. 	case 6:
  41. 		Sort(&sq); //排序操作 
  42. 		break;
  43. 	case 7:
  44. 		baocun(&sq);  //备份操作
  45. 		break;
  46. 	case 8:
  47. 		exit(0); //结束操作
  48. 		break;
  49. 	case 9:
  50. 		Output(&sq); //显示操作
  51. 		break;
  52. 	default: 
  53. 		printf("你选择的菜单项不存在，请重新选择！\n"); 
  54. 		break;
  55. 	}
  56. 	system("pause");
  57. 	system("cls");
  58. }

初始化：

语句：           L->element=(ElemType *)malloc(sizeof(ElemType)*maxLen);

可类比于：    L->element=(int *)malloc(sizeof(int)*100);

malloc（）函数的作用是：动态分配内存空间。

头文件：#include <stdlib.h>

其原型为：
void* malloc (size_t size);
【参数说明】size 为需要分配的内存空间的大小，以字节（Byte）计。
【函数说明】malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。
【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。
由于申请内存空间时可能有也可能没有，所以需要自行判断是否申请成功，再进行后续操作。
如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

  1. //初始化系统√
  2. void init(SeqList *L,int maxLen)
  3. {
  4. 	//以下三个代表引用结构体中的成员
  5.  
  6. 	L->maxLength=maxLen;  //指定了顺序表的最大长度
  7. 	L->n=0;               //表示顺序表的实际长度
  8. 	L->element=(ElemType *)malloc(sizeof(ElemType)*maxLen);
  9.  
  10. 	if(L->element==NULL)
  11. 		printf("顺序表初始化失败!\n"); 
  12. 	else
  13. 		printf("顺序表初始化成功!\n");
  14. }

添加元素：

在添加元素之前，首先需要对其进行判断，

即其中的元素实际长度n是否小于该一维数组的长度maxLength，

如果小于则可以添加元素，如果大于或等于一维数组元素的长度，就不能够继续添加了。

若元素的实际长度n小于一维数组的长度，就施行添加。

而所添加的元素的下标即为n，在添加后，n的值需要进行累加处理。

  1. //添加元素√
  2. void add(SeqList *L) 
  3. {
  4. 	ElemType x; //保存要添加的元素值
  5. 	printf("\n===========【添加元素】===============\n");
  6. 	printf("请输入要添加的元素值: ");
  7. 	scanf("%d",&x);
  8.  
  9. 	if(L->n < L->maxLength)
  10. 	{
  11. 		L->element[L->n]=x;      //L->element代表数组名  L->n 代表下表，可以添加元素
  12. 		L->n++;                  //L->n在前，++在后
  13. 		printf("恭喜，元素添加成功!\n");
  14. 	}
  15.  
  16. 	else if(L->n==L->maxLength)
  17. 	{
  18. 		printf("该顺序表已满，无法添加元素！\n");
  19. 	}
  20. 	
  21. 	else
  22. 	{
  23. 		printf("添加元素失败!\n");
  24. 	}
  25. }

显示元素：

  1. //显示元素√
  2. void Output(SeqList *L)
  3. {
  4. 	ElemType i;
  5. 	//定义一个指针用于遍历学生信息
  6. 	printf("\n===========【显示元素】===============\n");
  7. 	if(L->n>0)
  8. 	{
  9. 		printf("该顺序表中所有元素如下：\n");
  10. 		for(i=0;i<L->n;i++)
  11. 		{
  12. 			printf("%-4d",L->element[i]);
  13. 		}
  14. 	}
  15.  
  16. 	else
  17. 	{
  18. 		printf("该顺序表是空表，无元素！");
  19. 	}
  20. }

查找元素：

  1. //查找元素√
  2. void Search(SeqList *L)
  3. {
  4. 	ElemType i,x,flag=0;	//f表示表示
  5. 	printf("\n===========【查找元素】===============\n");
  6. 	printf("请输入要查找的元素：");
  7. 	scanf("%d",&x);
  8.  
  9. 	printf("\n");
  10.  
  11. 	if(L->n>0)//定义一个指针用于遍历学生信息
  12. 	{
  13. 		for(i=0;i<L->n;i++)
  14. 		{
  15. 			if(L->element[i]==x)
  16. 			{
  17. 				flag=1;
  18. 				break;
  19. 			}
  20. 			
  21. 		}
  22. 	}
  23. 	else
  24. 	{
  25. 		printf("该顺序表是空表，无元素！");
  26. 	}
  27.  
  28. 	if(flag)
  29. 	{
  30. 		printf("成功查找到元素%-4d\n",x);
  31. 	}
  32. 	else
  33. 	{
  34. 		printf("查找元素%-4d失败\n",x);
  35. 	}
  36. 	system("pause");
  37. 	system("cls");
  38. }

修改元素：

  1. //修改元素√
  2. void Change(SeqList *L)
  3. {
  4. 	ElemType i,j,x,y,flag=0;	//flag表示表示 ,j表示保存的下标,y表示修改好后的值
  5. 	printf("\n===========【修改元素】===============\n");
  6. 	printf("请输入要修改的元素：");
  7. 	scanf("%d",&x);
  8.  
  9. 	printf("\n");
  10.  
  11. 	if(L->n>0)//定义一个指针用于遍历学生信息
  12. 	{
  13. 		for(i=0;i<L->n;i++)
  14. 		{
  15. 			if(L->element[i]==x)
  16. 			{
  17. 				flag=1;
  18. 				j=i;
  19. 				break;
  20. 			}
  21. 		}
  22. 	}
  23. 	else
  24. 	{
  25. 		printf("该顺序表是空表，无元素！");
  26. 	}
  27.  
  28. 	if(flag)
  29. 	{
  30. 		printf("请输入新的值：");
  31. 		scanf("%d",&y);
  32. 		if(L->n < L->maxLength)
  33. 		{
  34. 			L->element[j]=y;      //L->element代表数组名  L->n 代表下表，可以添加元素
  35. 			printf("恭喜，元素修改成功!\n");
  36. 		}
  37. 	}
  38. 	else
  39. 	{
  40. 		printf("修改%d元素失败\n",x);
  41. 	}
  42. 	system("pause");
  43. 	system("cls");
  44. }

插入元素：

  1. //插入元素√
  2. int insert(SeqList * L)
  3. {
  4. 	int j,i,x; //j表示下标,i表示插入元素的位置
  5. 	printf("\n===========【插入元素】===============\n");
  6. 	printf("请输入要插入的位置：");
  7. 		scanf("%d",&i);
  8.  
  9. 	printf("请输入要插入的元素：");
  10. 		scanf("%d",&x);
  11.  
  12. 	if(i<1||i>L->maxLength)
  13. 		return 0;
  14. 	else if(L->n == L->maxLength)
  15. 		return 0;
  16. 	else if(L->n <L->maxLength && i>=1&&i<=L->n)
  17. 	{
  18. 		for(j=L->n;j>=i;j--)  //将前面的元素依次移到后面去
  19. 			L->element[j]=L->element[j-1];
  20. 		L->element[i-1]=x; //插入新的元素值
  21. 		L->n++;
  22.  
  23. 		return 1;
  24. 	}
  25. }

 

元素排序：

运用冒泡排序，对数据元素进行从小到大的操作。

  1. //元素升序排序√
  2. void Sort(SeqList *L)
  3. {
  4. 	ElemType i,j,temp;
  5. 	printf("\n===========【元素排序】===============\n");
  6. 	printf("排序前的元素如下：\n");
  7. 	for(i=0;i<L->n;i++)
  8. 	{
  9. 		printf("%-4d",L->element[i]);
  10. 	} 
  11.  
  12. 	for(i=0;i<L->n-1;i++)  //排序的总趟数：总数据量-1
  13. 	{
  14. 		for(j=0;j<L->n-1-i;j++)//每趟比较的次数：总数据量-1-趟数
  15. 		{
  16. 			if(L->element[j]>L->element[j+1])//比较两个元素，满足条件交换，改变符号可更改所排的顺序
  17. 			{
  18. 				temp=L->element[j];  //交换顺序
  19.  
  20. 				L->element[j]=L->element[j+1];
  21.  
  22. 				L->element[j+1]=temp;
  23. 			}
  24. 		}
  25. 	}
  26. 	printf("\n恭喜，排序成功！\n");
  27. 	printf("排序后的元素如下：\n");
  28. 	for(i=0;i<L->n;i++)
  29. 	{
  30. 		printf("%-4d",L->element[i]);
  31. 	} 
  32. 	printf("\n");
  33.  
  34. }

元素的删除：

  1. //元素的删除√
  2. void del(SeqList * L)
  3. {
  4. 		int i, j,k,flag=0;  //k保存下标，flag用于表示信息是否删除成功
  5. 		int num2;
  6. 		printf("\n===========【删除元素】===============\n");
  7. 		printf("请输入要删除信息:");
  8. 		scanf("%d",&num2);
  9.  
  10. 		for (i=0;i<L->n;i++)
  11. 		{
  12. 			if (L->element[i]==num2)
  13. 			{
  14. 				k=i;
  15. 				flag=1;
  16. 				break;
  17. 			}
  18. 		}
  19.  
  20. 		if(flag=1)
  21. 		{
  22. 			for (j=k;j<L->n-1;j++)//要删除学生后面的学生往前移一位
  23. 			{
  24. 				L->element[j]=L->element[j+1];
  25. 			}
  26. 		}
  27. 		else if(flag!=1)
  28. 		{
  29. 			printf("该信息不存在!!!\n");
  30. 		}
  31. 		printf("删除成功\n");
  32. 		L->n--;
  33.  
  34. 		system("pause");
  35. 		system("cls");
  36. 		menu();
  37. }

元素备份：

  1. //元素备份√
  2. void baocun(SeqList *L)
  3. {
  4. 	int i;
  5. 	FILE *fp;  //定义文件指针
  6.  
  7. 	printf("\n===========【备份元素】===============\n");
  8.  
  9. 	 if((fp=fopen("student.txt", "w"))==NULL); //以只写形式打开文件，若失败，则返回NULL，并新建一个文件
  10. 	 {
  11. 		 for (i=0;i<L->n;i++)
  12. 		 {
  13. 			 fprintf(fp, "%d\n", L->element[i]);
  14. 			 printf("保存成功！！！\n");
  15. 		 }
  16. 	 }
  17.  
  18. 	 fclose(fp);  //关闭文件
  19. 	 system("pause");
  20. 	 system("cls");
  21.  
  22. 	 menu();
  23.  
  24. }

 

main函数：

  1. int main( )
  2. {
  3. 	while(1)
  4. 	{
  5.       menu( );
  6. 	}
  7. 	return 0;
  8. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/很楠不爱3/article/detail/427014
推荐阅读
相关标签

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

  

闽ICP备14008679号