顺序表（动态存储）的基本操作

顺序表的基础操作

        1.顺序表结构体定义

        2.顺序表初始化

        3.按位查找元素

        4.按值查找元素

        5.删除元素

        6.打印顺序表

        7.顺序表倒置

        8.销毁顺序表

        9.顺序表合并

顺序表比较简单，就不多做赘述了

/*1.顺序表（静态分配）
#include<stdio.h>
#define MaxSize 10  //定义线性表的最大长度
typedef struct {
	//ElemType data[MaxSize];  ElemType 是类型
	int data[MaxSize];  //定义一个静态数组来存储数据
	int length; //顺序表当前长度
}SqList;	//顺序表的类型定义
*/
//上面的静态分配不多做赘述了，我们直接来动态分配
//顺序表（动态分配）
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 100
//初始化顺序表
typedef struct SqList {
	int* data;
	int length;
}SqList;
//初始化顺序表
void InitSqList(SqList& L) { //动态数组
	L.data = (int*)malloc(sizeof(int) * MaxSize);
	for (int i = 0; i < MaxSize; i++) {//开辟线性表的存储空间
		L.data[i] = 0;
	}
	L.length = 0;//线性表长度为0
	printf("请输入该线性表的大小:\n");
	scanf_s("%d", &L.length);
	printf("请输入数据：\n");
	for (int i = 0; i < L.length; i++) {
		scanf_s("%d", &L.data[i]);
	}
	printf("创建成功！\n");
}
//1.按位查找元素
int GetElem(SqList& L, int i) {
	return L.data[i - 1];
}
//2.按值查找元素
int LocalElem(SqList& L, int e) {
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == e) {
			return i + 1;//输出该值在线性表的位置
		}
	}
}
//3.插入数据
bool ListInsert(SqList& L, int i, int e) {
	//判断i是否合法
	if (i<0 || i>L.length) {
		return false;
	}
	//判断存储空间是否已满
	if (L.length > MaxSize) {
		return false;
	}
	//从右到左依次遍历，第i个元素及其之后元素右移一位
	for (int j = L.length; j >= i; j--) {
		L.data[j] = L.data[j - 1];
	}
	L.data[i - 1] = e;
	L.length++;
	return true;
}
//4.删除元素
bool ListDelete(SqList& L, int i) {
	if (i<0 || i>L.length + 1) {
		return false;
	}
	if (L.length > MaxSize) {
		return false;
	}
	for (int j = i; j < L.length; j++) {
		L.data[j - 1] = L.data[j];
	}
	L.length--;
	return true;
}
//5.销毁线性表
void DestroyList(SqList& L) {
	if (L.length == 0) {
		printf("还未创建线性表！\n");
	}
	if (L.data) {
		L.data = NULL;
	}
	L.length = 0;
	printf("线性表已销毁！\n");
}
//6.输出顺序表
void ListShow(SqList L) {
	printf("顺序表：\n");
	for (int i = 0; i < L.length; i++) {
		printf("%d", L.data[i]);
	}
	printf("\n");
}
//7.倒置元素
bool ListReverse(SqList& L) {
	if (L.length<1 || L.length>MaxSize) {
		return false;
	}
	int i, temp;
	//从左到右依次遍历，遍历到L->length/2,每遍历一次数组的长度减1
	for (i = 0; i < L.length / 2; i++) {
		temp = L.data[i];//第i个元素赋给temp
		L.data[i] = L.data[L.length - i - 1];//第i个和数组最后一个交换
		L.data[L.length - i - 1] = temp;//最后把temp赋值给线性表的L->length-i-1
	}
}
//合并顺序表
void MergeSqList(SqList& La, SqList& Lb, SqList& Lc) {
	int i, j, k;
	i = j = k = 0;
	Lc.length = La.length + Lb.length;//顺序表Lc的长度是La和Lb的和
	Lc.data = (int*)malloc(sizeof(int)* Lc.length);//动态分配存储空间
	//C++的代码Lc.data = new int[Lc.length];
	while (i < La.length && j < Lb.length) {//判断i和j是否合法，即两个表都非空
		//La的第i个元素和Lb的第j个元素比较，谁小谁放进k，然后对应的i（或j）和k都要++。
		if (La.data[i] < Lb.data[j])	
			Lc.data[k++] = La.data[i++];
		else
			Lc.data[k++] = Lb.data[j++];
	}
	//若La有剩余则依次把La中的元素加入到Lc中
	while (i < La.length)
		Lc.data[k++] = La.data[i++];
	//若Lb有剩余则依次把Lb中的元素加入到Lc中
	while (j < Lb.length)
		Lc.data[k++] = Lb.data[j++];
}
int main() {
	SqList L;
	SqList La, Lb, Lc;
	int i, e;
	int command;
	while (1) {
		printf("*******************************\n");
		printf("下面是操作界面\n");
		printf("1.顺序表的初始化  2.按位查找元素\n");
		printf("3.按值查找元素    4.插入元素\n");
		printf("5.删除元素        6.输出元素\n");
		printf("7.元素倒置        8.销毁顺序表\n");
		printf("9.顺序表合并      10.退出\n");
		printf("*******************************\n");
		printf("请输入您要进行的操作:\n");
		scanf_s("%d", &command);
		switch (command)
		{
		case 1:
			//1.顺序表的初始化
			InitSqList(L);
			//ListShow(L);
			break;
		case 2:
			//2.按位查找元素
			printf("请输入要查找元素的位置\n");
			scanf_s("%d", &i);
			printf("该元素的数值为：%d\n", GetElem(L, i));
			break;
		case 3:
			//按值查找元素
			printf("请输入要查找元素的数值\n");
			scanf_s("%d", &e);
			printf("该元素的位置为：%d\n", LocalElem(L, e));
			break;
		case 4:
			//4.插入元素
			printf("请输入要插入的位置和数据元素：\n");
			scanf_s("%d %d", &i, &e);
			ListInsert(L, i, e);
			printf("插入后的线性表为：\n");
			//ListShow(&L);
			//printf("插入操作结束：\n");
			break;
		case 5:
			//5.删除元素
			printf("请输入要删除的元素的位置：\n");
			scanf_s("%d", &i);
			ListDelete(L, i);
			//ListShow(L);
			break;
		case 6:
			//6.输出元素
			ListShow(L);
			break;
		case 7:
			//7.元素倒置 
			printf("倒置后的顺序表为：\n");
			ListReverse(L);
			//ListShow(&L);
			break;
		case 8:
			//销毁线性表
			DestroyList(L);
			break;
		case 9:
			//创建La
			printf("La顺序表：\n");
			InitSqList(La);
			//创建Lb
			printf("Lb顺序表:\n");
			InitSqList(Lb);
			MergeSqList(La, Lb, Lc);
			ListShow(Lc);
			break;
		case 10:
			break;
		default:
			printf("输入错误\n");
			break;
		}
		ListShow(L);
	}
	return 0;
}