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

渡过晚枫

18876人浏览 · 2022-05-21 15:42:38

渡过晚枫 · 2022-05-21 15:42:38 发布

建议新人收藏使用！

前言：

数据结构包括三个方面：

逻辑结构
存储结构
运算

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

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

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

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

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

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

设线性表的第一个元素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;
}

GitCode 开源社区

旨在为数千万中国开发者提供一个无缝且高效的云端环境，以支持学习、使用和贡献开源项目。

更多推荐

[转载]在Windows环境下安装GNU Radio

转自：在Windows环境下安装GNURadio_恐弱智_新浪博客GNU Radio是用Python开发的，大部分开源的工程能够在Linux环境下运行良好，而Windows下却运行的很勉强，而且安装配置都很复杂。GNU Radio算是个例外了，不光提供了Windows的二进制安装，还有比较详细的说明。我是Python小白，所以折腾了好久才弄好，特意记录下来，免得以后再装还折腾。GNU Radio的