顺序表的常用操作实现及测试

顺序表的常用操作实现及测试：

1. 初始化并建立顺序表
2. 顺序表初始值输入
3. 按位置插入
4. 按位置删除
5. 按值查询
6. 按位置修改
7. 去除顺序表重复元素
8. 顺序表排序
9. 顺序表遍历及输出
10. 合并两个有序顺序表

代码（C语言）：

/*动态顺序表的常用操作实现及测试*/
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#define INITSIZE 100  //顺序表初始容量
#define INCREMENT 10  //顺序表动态增量

/*数据结构*/
typedef int ElemType; //顺序表元素类型
typedef struct        //顺序表结构体
{
	ElemType* elem;
	int length;
	int listsize;
}SqList;

/*函数声明*/
int InitSqList(SqList* L);                        //初始化
void InputSqList(SqList* L);                      //输入
void PrintSqList(SqList L);                       //遍历并输出
int InsertSqList(SqList* L, int i, ElemType e);   //插入
int DeleteSqList(SqList* L, int i, ElemType* e);  //删除
int LocateSqList(SqList L, ElemType e);           //按值查找
int ModifySqList(SqList* L, int i, ElemType e);   //按位置修改
void DuplicateRemoveSqList(SqList* L);            //去重
void SortSqList(SqList* L);                       //排序
int MergeSqList(SqList LA, SqList LB, SqList* L); //合并两个有序顺序表
void test01();                                    //测试1
void test02();                                    //测试2
void test03();                                    //测试3
void menu();                                      //主菜单

/*主函数*/
int main(void)
{
	menu();
	return 0;
}

/*函数实现*/
/*【1】初始化顺序表，成功返回1，失败返回0*/
int InitSqList(SqList* L)
{
	L->elem = (ElemType*)malloc(INITSIZE * sizeof(ElemType));
	if (!L->elem) return 0;
	L->length = 0;
	L->listsize = INITSIZE;
	return 1;
}

/*【2】输入顺序表各个元素的值*/
void InputSqList(SqList* L)
{
	int i = 0, n = 0;
	printf("请输入该线性表的元素个数：n=");
	scanf("%d", &n);
	while (n > L->listsize)
	{
		printf("超过了线性表的初始存储空间，请重新输入：\n");
		scanf("%d", &n);
	}
	L->length = n;
	printf("请依次输入该线性表各元素的值：");
	for (i = 0; i < n; i++) scanf("%d", &L->elem[i]);
}

/*【3】遍历并输出顺序表的各元素*/
void PrintSqList(SqList L)
{
	int i = 0;
	printf("该线性表的元素依次为：");
	for (i = 0; i < L.length; i++) printf("%d ", L.elem[i]);
	printf("\n");
}

/*【4】在线性表L的第i个位置之前插入新的元素e,成功则返回1，失败返回0*/
int InsertSqList(SqList* L, int i, ElemType e)
{
	int j = 0;
	if (i<1 || i>L->length + 1) return 0; //插入位置合法性校验
	if (L->length >= L->listsize)
	{
		ElemType* newbase = (ElemType*)realloc(L->elem, (L->listsize + INCREMENT) * sizeof(ElemType));
		if (!newbase) return 0;
		L->elem = newbase;
		L->listsize += INCREMENT;
	}
	for (j = L->length - 1; j >= i - 1; j--)
	{
		L->elem[j + 1] = L->elem[j];
	}
	L->elem[i - 1] = e;
	++(L->length);
	return 1;
}

/*【5】在顺序表L中删除第i个元素，并用e返回其值，若成功则返回1，否则返回0*/
int DeleteSqList(SqList* L, int i, ElemType* e)
{
	int j = 0;
	if (i<1 || i>L->length) return 0; //删除位置合法性校验
	*e = L->elem[i - 1];
	for (j = i; j < L->length; j++)
	{
		L->elem[j - 1] = L->elem[j];
	}
	--(L->length);
	return 1;
}

/*【6】在顺序表L中查找第i个值与e相等的元素的位置，若找到，则返回其在L中的位置，否则返回0*/
int LocateSqList(SqList L, ElemType e)
{
	int i = 0;
	while (i < L.length && L.elem[i] != e) i++;
	if (L.elem[i] == e) return i + 1;
	else return 0;
}

/*【7】在顺序表L中修改第i个位置的元素，若成功则返回1，否则返回0*/
int ModifySqList(SqList* L, int i, ElemType e)
{
	if (i<1 || i>L->length) return 0; //修改位置合法性校验
	L->elem[i - 1] = e;
	return 1;
}

/*【8】去除顺序表中的重复元素，相同元素保留靠后的*/
void DuplicateRemoveSqList(SqList* L)
{
	int i = 0, j = 0;
	ElemType e;
	for (j = 1; j < L->length; j++)
	{
		for (i = 0; i < j; i++)
		{
			if (L->elem[i] == L->elem[j])
			{
				DeleteSqList(L, i + 1, &e);
				j--;
			}
		}
	}
}

/*【9】对线性表各元素按从小到大进行冒泡排序*/
void SortSqList(SqList* L)
{
	int i = 0, j = 0;
	for (j = 0; j < L->length - 1; j++)
	{
		int flag = 0;
		for (i = 0; i < L->length - 1 - j; i++)
		{
			if (L->elem[i] > L->elem[i + 1])
			{
				ElemType temp = L->elem[i];
				L->elem[i] = L->elem[i + 1];
				L->elem[i + 1] = temp;
				flag = 1;
			}
		}
		if (flag == 0) break;
	}
}

/*【10】将两个递增顺序表LA和LB合并为新的递增顺序表L*/
int MergeSqList(SqList LA, SqList LB, SqList* L)
{
	int i = 0, j = 0, k = 0;
	L->listsize = LA.length + LB.length;
	L->elem = (ElemType*)malloc(L->listsize * sizeof(ElemType));
	if (!L->elem) return 0;
	while (i < LA.length && j < LB.length)
	{
		if (LA.elem[i] <= LB.elem[j]) L->elem[k++] = LA.elem[i++];
		else L->elem[k++] = LB.elem[j++];
	}
	while (i < LA.length) L->elem[k++] = LA.elem[i++];
	while (j < LB.length) L->elem[k++] = LB.elem[j++];
	L->length = k;
	return 1;
}

void test01()
{
	SqList L;
	int i = 0, status = 0;
	ElemType e;
	InitSqList(&L);              //初始化顺序表测试
	printf("顺序表L初始化成功！\n");
	InputSqList(&L);
	printf("输入待插入元素的值：");
	scanf("%d", &e);
	printf("输入插入位置：");
	scanf("%d", &i);
	status = InsertSqList(&L, i, e);     //插入测试
	if (status) PrintSqList(L);             //输出顺序表L
	else printf("位置不合法，插入失败！\n");
	printf("输入待删除元素的位置：");
	scanf("%d", &i);
	status = DeleteSqList(&L, i, &e);    //删除测试
	if (status)
	{
		printf("删除元素的值为：%d\n删除后：", e);
		PrintSqList(L);             //输出顺序表L
	}
	else printf("位置不合法，删除失败！\n");
	printf("输入待查找元素的值：");
	scanf("%d", &e);
	int position = LocateSqList(L, e); //按值查找测试
	if (position == 0) printf("该顺序表中不存在该元素！\n");
	else printf("该元素位置为：第%d个元素\n", position);
	printf("输入待修改元素的位置：");
	scanf("%d", &i);
	printf("输入修改后的值：");
	scanf("%d", &e);
	status = ModifySqList(&L, i, e);     //按位置修改测试
	if (status)
	{
		printf("修改后，");
		PrintSqList(L);             //输出顺序表L
	}
	else printf("位置不合法，修改失败！\n");
	system("pause");
}

void test02()
{
	SqList L;
	InitSqList(&L);             //初始化
	printf("顺序表L初始化成功！\n");
	InputSqList(&L);            //输入顺序表L
	PrintSqList(L);             //输出顺序表L
	DuplicateRemoveSqList(&L);  //去重
	printf("去除重复元素后：");
	PrintSqList(L);             //输出顺序表L
	system("pause");
}

void test03()
{
	SqList L1, L2, L;
	InitSqList(&L);             //初始化L1
	InitSqList(&L1);              //初始化L
	printf("顺序表L1初始化成功！\n");
	InputSqList(&L1);            //输入顺序表L1
	SortSqList(&L1);             //对L1排序
	InitSqList(&L2);             //初始化L2
	printf("顺序表L2初始化成功！\n");
	InputSqList(&L2);            //输入顺序表L2
	SortSqList(&L2);             //对L2排序
	printf("将L1和L2合并为新的递增顺序表L：\n");
	MergeSqList(L1, L2, &L);
	PrintSqList(L);              //输出顺序表L
	system("pause");
}

void menu()
{
	system("cls");
	int sel = 0;
	printf("1：建立顺序表，在顺序表上实现插入、删除、查找、修改、输出等操作\n");
	printf("2：去除顺序表中的重复元素\n");
	printf("3：对两个顺序表进行排序及合并操作\n");
	printf("4：退出\n");
	printf("输入你的选择：");
	scanf("%d", &sel);
	while (sel < 1 || sel>4)
	{
		printf("输入的选择不合法，请重新输入：");
		scanf("%d", &sel);
	}
	switch (sel)
	{
	case 1:
		test01();
		menu();
		break;
	case 2:
		test02();
		menu();
		break;
	case 3:
		test03();
		menu();
		break;
	case 4:
		exit(0);
	default:
		break;
	}
	system("pause");
}

执行结果：

测试1：

测试2：

测试3：