建议新人收藏使用！

目录

前言：

头文件等：

函数的声明：

系统菜单：

​编辑

初始化：

​编辑

添加元素：

​编辑

显示元素：

​编辑

查找元素：

​编辑

修改元素：

​编辑

插入元素：

​编辑

元素排序：

​编辑

元素的删除：

元素备份：

​编辑

main函数：

---

前言：

数据结构包括三个方面：

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

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

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

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

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

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

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

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

目录

头文件等：

系统菜单：

顺序表的初始化：

添加元素：

显示元素：

查找元素：

修改元素：

插入元素：

元素排序：

元素的删除：

元素备份：

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;
}