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

渡过晚枫

已于 2022-09-25 12:02:59 修改

阅读量1.7w

点赞数 56

分类专栏： [算法基础/初学者] [C/C++/初学者]

于 2022-05-21 15:42:38 首次发布

本文链接：https://blog.csdn.net/DuFengYa/article/details/124898609

版权

[C/C++/初学者] 同时被 2 个专栏收录

19 篇文章 7 订阅

订阅专栏

[算法基础/初学者]

12 篇文章 7 订阅

订阅专栏

建议新人收藏使用！

前言：

数据结构包括三个方面：

逻辑结构
存储结构
运算

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

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

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

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

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

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

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

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

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

typedef struct seqList
{
    int n;
    int maxLength;
    ElemType *element;
} SeqList;

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

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

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

顺序表的基本运算有：

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

头文件等：

/*
顺序表操作(顺序表是将所有的元素存放在一个一维数组里面，每个元素都连续存放）
*/
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;  //给int指定别名 

typedef struct seqList{
	int n;          //该长度表示顺序表的实际长度
	int maxLength;  //表示数组的长度
	ElemType * element; //表示指针类型,等价于 int * element;
}SeqList;

SeqList sq;  //结构体变量

函数的声明：

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

系统菜单：

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

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

//定义系统菜单√
void menu( )
{
	int op;
	printf("==================================\n");
	printf("------顺序表的基本操作-----\n");
	printf("0. 初始化顺序表√            \n");
	printf("1. 添加元素√                \n");
	printf("2. 插入元素√                \n");
	printf("3. 删除元素√                \n");
	printf("4. 修改元素√                \n");
	printf("5. 查找元素√                \n");
	printf("6. 升序排序元素√            \n");
	printf("7. 备份顺序表√              \n");
	printf("8. 结束操作√                \n");
	printf("9. 显示操作√                \n");
	printf("==================================\n");

	printf("请选择操作的菜单项:");
	scanf("%d",&op);
	switch(op){
	case 0:
		init(&sq,100);  //初始化操作
		break;
	case 1:
		add(&sq);       //添加操作
		break;
	case 2:
		insert(&sq);
		break;
	case 3:
		del(&sq);
		break;
	case 4:
		Change(&sq);  //修改操作
		break;
	case 5:
		Search(&sq); //查找操作
		break;
	case 6:
		Sort(&sq); //排序操作 
		break;
	case 7:
		baocun(&sq);  //备份操作
		break;
	case 8:
		exit(0); //结束操作
		break;
	case 9:
		Output(&sq); //显示操作
		break;
	default: 
		printf("你选择的菜单项不存在，请重新选择！\n"); 
		break;
	}
	system("pause");
	system("cls");
}

初始化：

语句： 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，也可能不是，但返回的指针不应该再次被引用。

//初始化系统√
void init(SeqList *L,int maxLen)
{
	//以下三个代表引用结构体中的成员

	L->maxLength=maxLen;  //指定了顺序表的最大长度
	L->n=0;               //表示顺序表的实际长度
	L->element=(ElemType *)malloc(sizeof(ElemType)*maxLen);

	if(L->element==NULL)
		printf("顺序表初始化失败!\n"); 
	else
		printf("顺序表初始化成功!\n");
}

添加元素：

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

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

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

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

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

//添加元素√
void add(SeqList *L) 
{
	ElemType x; //保存要添加的元素值
	printf("\n===========【添加元素】===============\n");
	printf("请输入要添加的元素值: ");
	scanf("%d",&x);

	if(L->n < L->maxLength)
	{
		L->element[L->n]=x;      //L->element代表数组名  L->n 代表下表，可以添加元素
		L->n++;                  //L->n在前，++在后
		printf("恭喜，元素添加成功!\n");
	}

	else if(L->n==L->maxLength)
	{
		printf("该顺序表已满，无法添加元素！\n");
	}
	
	else
	{
		printf("添加元素失败!\n");
	}
}

显示元素：

//显示元素√
void Output(SeqList *L)
{
	ElemType i;
	//定义一个指针用于遍历学生信息
	printf("\n===========【显示元素】===============\n");
	if(L->n>0)
	{
		printf("该顺序表中所有元素如下：\n");
		for(i=0;i<L->n;i++)
		{
			printf("%-4d",L->element[i]);
		}
	}

	else
	{
		printf("该顺序表是空表，无元素！");
	}
}

查找元素：

//查找元素√
void Search(SeqList *L)
{
	ElemType i,x,flag=0;	//f表示表示
	printf("\n===========【查找元素】===============\n");
	printf("请输入要查找的元素：");
	scanf("%d",&x);

	printf("\n");

	if(L->n>0)//定义一个指针用于遍历学生信息
	{
		for(i=0;i<L->n;i++)
		{
			if(L->element[i]==x)
			{
				flag=1;
				break;
			}
			
		}
	}
	else
	{
		printf("该顺序表是空表，无元素！");
	}

	if(flag)
	{
		printf("成功查找到元素%-4d\n",x);
	}
	else
	{
		printf("查找元素%-4d失败\n",x);
	}
	system("pause");
	system("cls");
}

修改元素：

//修改元素√
void Change(SeqList *L)
{
	ElemType i,j,x,y,flag=0;	//flag表示表示 ,j表示保存的下标,y表示修改好后的值
	printf("\n===========【修改元素】===============\n");
	printf("请输入要修改的元素：");
	scanf("%d",&x);

	printf("\n");

	if(L->n>0)//定义一个指针用于遍历学生信息
	{
		for(i=0;i<L->n;i++)
		{
			if(L->element[i]==x)
			{
				flag=1;
				j=i;
				break;
			}
		}
	}
	else
	{
		printf("该顺序表是空表，无元素！");
	}

	if(flag)
	{
		printf("请输入新的值：");
		scanf("%d",&y);
		if(L->n < L->maxLength)
		{
			L->element[j]=y;      //L->element代表数组名  L->n 代表下表，可以添加元素
			printf("恭喜，元素修改成功!\n");
		}
	}
	else
	{
		printf("修改%d元素失败\n",x);
	}
	system("pause");
	system("cls");
}

插入元素：

//插入元素√
int insert(SeqList * L)
{
	int j,i,x; //j表示下标,i表示插入元素的位置
	printf("\n===========【插入元素】===============\n");
	printf("请输入要插入的位置：");
		scanf("%d",&i);

	printf("请输入要插入的元素：");
		scanf("%d",&x);

	if(i<1||i>L->maxLength)
		return 0;
	else if(L->n == L->maxLength)
		return 0;
	else if(L->n <L->maxLength && i>=1&&i<=L->n)
	{
		for(j=L->n;j>=i;j--)  //将前面的元素依次移到后面去
			L->element[j]=L->element[j-1];
		L->element[i-1]=x; //插入新的元素值
		L->n++;

		return 1;
	}
}

元素排序：

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

//元素升序排序√
void Sort(SeqList *L)
{
	ElemType i,j,temp;
	printf("\n===========【元素排序】===============\n");
	printf("排序前的元素如下：\n");
	for(i=0;i<L->n;i++)
	{
		printf("%-4d",L->element[i]);
	} 

	for(i=0;i<L->n-1;i++)  //排序的总趟数：总数据量-1
	{
		for(j=0;j<L->n-1-i;j++)//每趟比较的次数：总数据量-1-趟数
		{
			if(L->element[j]>L->element[j+1])//比较两个元素，满足条件交换，改变符号可更改所排的顺序
			{
				temp=L->element[j];  //交换顺序
 
				L->element[j]=L->element[j+1];
 
				L->element[j+1]=temp;
			}
		}
	}
	printf("\n恭喜，排序成功！\n");
	printf("排序后的元素如下：\n");
	for(i=0;i<L->n;i++)
	{
		printf("%-4d",L->element[i]);
	} 
	printf("\n");

}

元素的删除：

//元素的删除√
void del(SeqList * L)
{
		int i, j,k,flag=0;  //k保存下标，flag用于表示信息是否删除成功
		int num2;
		printf("\n===========【删除元素】===============\n");
		printf("请输入要删除信息:");
		scanf("%d",&num2);
 
		for (i=0;i<L->n;i++)
		{
			if (L->element[i]==num2)
			{
				k=i;
				flag=1;
				break;
			}
		}
 
		if(flag=1)
		{
			for (j=k;j<L->n-1;j++)//要删除学生后面的学生往前移一位
			{
				L->element[j]=L->element[j+1];
			}
		}
		else if(flag!=1)
		{
			printf("该信息不存在!!!\n");
		}
		printf("删除成功\n");
		L->n--;
 
		system("pause");
		system("cls");
		menu();
}

元素备份：

//元素备份√
void baocun(SeqList *L)
{
	int i;
	FILE *fp;  //定义文件指针
 
	printf("\n===========【备份元素】===============\n");
 
	 if((fp=fopen("student.txt", "w"))==NULL); //以只写形式打开文件，若失败，则返回NULL，并新建一个文件
	 {
		 for (i=0;i<L->n;i++)
		 {
			 fprintf(fp, "%d\n", L->element[i]);
			 printf("保存成功！！！\n");
		 }
	 }
 
	 fclose(fp);  //关闭文件
	 system("pause");
	 system("cls");
 
	 menu();

}

main函数：

int main( )
{
	while(1)
	{
      menu( );
	}
	return 0;
}

渡过晚枫

关注

56
点赞
踩
464

收藏

觉得还不错? 一键收藏
打赏
10
评论
【数据结构（C语言）】顺序表的定义，实现初始化、创建、插入、增、删、改、查等基本操作（详细）

顺序表是在计算机内内存中以数组的形式保存的线性表，线性表的顺序存储是指用一组地址连续的存储单元依次存储线性表中的各个元素、使得线性表中在逻辑结构上相邻的数据元素存储在相邻的物理存储单元中，即通过数据元素物理存储的相邻关系来反映数据元素之间逻辑上的相邻关系，采用顺式存储结构的线性表通常称为顺序表。相对于链式存储结构而言，顺式存储结构显得更为简单。顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中。顺序表的基本运算有：初始化查找插入删除输.
复制链接

扫一扫