数据结构顺序表

一、实验目的

1．深入了解线性表的顺序存储结构。

2．熟练掌握在顺序存储结构上进行插入、删除等操作的算法。

3．通过线性表结构解决现实中的一些问题。

二、实验内容

1. 线性表的顺序存储结构。

2. 顺序存储结构上进行插入、删除等操作的算法。

3. 通过线性表结构解决现实中的一些问题。

三、实验过程

1、实验题目

 [问题描述]

设计一个顺序表，要求：

（1）设计一个选择菜单。

（2）输入若干个元素，并在屏幕上输出显示。

（3）对建好的顺序表实现查找、插入、删除等操作，并把程序执行结果显示到屏幕上。

#include<stdio.h>
#include<stdlib.h>

#define Initsize 200

typedef struct Seqlist{
	int length;//当前顺序表长度
	int Maxsize;//顺序表最大长度
	int *data;//一个名为data的动态数组 
}Seqlist; 

//初始化顺序表 
void Initlist(Seqlist *L);

//增加顺序表的长度
void Increasesize(Seqlist *L);

//输入元素 
void WriteList(Seqlist *L); 

//顺序表的元素查找（按位查找）
bool GetElem(Seqlist *L);

//顺序表的元素查找(按值查找_)
void locateElem(Seqlist *L);

//顺序表的元素插入
bool ListInsert(Seqlist *L);

//顺序表的元素删除
bool ListDelete(Seqlist *L);

//顺序表的打印
bool PrintList(Seqlist *L);

//求顺序表的表长
int  Length(Seqlist *L);

//顺序表的销毁
void DestroyList(Seqlist *L);

//菜单
void Printview(); 


//1.初始化 
void Initlist(Seqlist *L)
{
	L->data=(int *)malloc(Initsize*sizeof(int));
	L->length=0;
	L->Maxsize=Initsize;
}

//2.输入元素 
void WriteList(Seqlist *L)
{
	
	printf("请输入你要创建的顺序表长度:");
	scanf("%d",&L->length);
	printf("请输入%d个你要创建的顺序表元素",L->length);
	for(int i=0;i<L->length;i++)
	{
		scanf("%d",&L->data[i]);
	}
	
 } 


//3.增长 
void Increasesize(Seqlist *L)
{
	int *p=L->data;
	int len;
	printf("请输入你要增加的顺序表的长度："); 
	scanf("%d",&len);
	L->data=(int *)malloc((L->Maxsize+len)*sizeof(int));
	for(int i=0;i<L->length;i++)
	{
		L->data[i]=p[i];
	 } 
	 L->Maxsize=L->Maxsize+len;
	 printf("当前顺序表的最大长度为%d\n",L->Maxsize); 
	free(p);
}

//4.按位查找 
bool GetElem(Seqlist *L)
{
	int x;
	printf("请输入你要查找第几个元素：");
	scanf("%d",&x);
	if(x<1||x>L->length+1)
	{
		printf("输入有误，查找失败！\n");
		return false;
	}
	printf("第%d个元素是%d\n",x,L->data[x-1]);
	return true;
	
}

//5.按值查找 
void locateElem(Seqlist *L)
{
	int x;
	int k=0;
	printf("请输入你要查找的元素是：");
	scanf("%d",&x);
	for(int i=0;i<L->length;i++)
	{
		if(x==L->data[i])
		{
			printf("找到了，是第%d个元素\n",i+1);
			k=1;
			break;
		}
	 } 
	 if(k==0)
	 printf("找不到元素%d，该元素不存在\n",x);
}

//6.插入元素 
bool ListInsert(Seqlist *L)
{
	int x,k;
	printf("请输入要插入顺序表的元素和元素位置：");
	scanf("%d%d",&x,&k);
	if(k<1||k>L->length+1)
	{
		printf("下标越界，无法插入\n");
		return false;
	 } 
	 if(L->length>L->Maxsize)
	 {
	 	printf("储存空间已满，插入失败\n");
	 	return false;
	 }
	 for(int j=L->length;j>=k;j--)
	 {
	 	L->data[j]=L->data[j-1];
	 }
	 L->data[k-1]=x;
	 L->length++;
	 printf("插入成功，插入元素是%d，插入位置是%d\n",x,k);
	 return true;
}

//7.删除元素 
bool ListDelete(Seqlist *L)
{
	int x,k;
	printf("请输入要删除的元素位置:");
	scanf("%d",&x);
	if(x<1||x>L->length+1)
	{
		printf("下标越界，删除失败\n");
		return false;
	}
	if(!L->data)
	{
		printf("空表，无法删除\n");
		return false;
	}
	k=L->data[x-1];
	for(int i=x;i<=L->length;i++)
	{
		L->data[i-1]=L->data[i];
	}
	L->length--;
	printf("删除成功，删除元素为%d，删除位置为%d\n",k,x);
	return true;
}

//8.打印 
bool PrintList(Seqlist *L)
{
	if(!L->data)
	{
		printf("空表，打印失败！\n");
		return false;
	}
else{
	printf("顺序表中的元素有：");
	for(int i=0;i<L->length;i++)
	{
		printf("%d ",L->data[i]);
	 } 
}
	 printf("\n");
	 return true;
}

//9.求长 
int  Length(Seqlist *L)
{
	if(L->length==0)
	return 0;
	printf("当前顺序表长度为%d\n",L->length);
	return L->length;
}

//10.释放 
void DestroyList(Seqlist *L)
{
	char x;
	printf("是否销毁循序表？Y/N\n");
	scanf("%c",&x);
	if(x=='Y')
	{
		L->length=0;
		L->Maxsize=0;
		free(L->data);
		printf("顺序表已销毁！\n"); 
		
	}
	
}

int main()
{
	Seqlist L;
	while(1)
	{
		int num;
		printf("请输入你要进行的操作:\n1.初始化顺序表 2.创建顺序表 3.增加顺序表长度\n");
		printf("4.按位查找元 5.按值查找元素 6.插入元素\n");
		printf("7.删除元素 8.打印顺序表 9.查看顺序表长\n");
		printf("10.销毁顺序表\n");
		
		scanf("%d",&num);
		switch(num)
		{
			case 1:Initlist(&L);printf("初始化成功！\n");break;
			case 2:WriteList(&L);printf("创建成功！\n");break;
			case 3:Increasesize(&L);printf("增加成功！\n");break;
			case 4:GetElem(&L);break;
			case 5:locateElem(&L);break;
			case 6:ListInsert(&L);break;
			case 7:ListDelete(&L);break;
			case 8:PrintList(&L);break;
			case 9:Length(&L);break;
			case 10:DestroyList(&L);break;
		}
	}
	return 0;
}
/* 声明函数时如果用结构体指针(Seqlist *L)传参，后面调用的时候就需要调用该指针的地址(&L),而且指针需要  L->成员变量 
例： void locateElem(Seqlist *L)，                locateElem(&L)                            L->length,L->data,L->Maxsize 
另一种情况， 声明函数时如果用 地址传参(Seqlist &L),后面调用就可以直接(L),  L.成员变量
例： void locateElem(Seqlist &L) ，                  locateElem(L)   ，      L.length,L.data,L.Maxsize  */

1.初始化

2.元素输入

3.增加顺序表长度

4.查找元素（按位）

5.元素查找（按值）

6.插入元素

7.元素删除

8.顺序表的打印

9.求顺序表的长度

10.销毁顺序表

运行结果

1. 顺序表的创建与初始化

1. 长度增加

1. 按位查找

1. 按值查找

1. 表长

1. 插入

1. 删除元素

越界测试