C语言顺序表基本运算实现与优化

这段代码实现了顺序表的基本运算，包括初始化、插入、删除、查找、排序等功能。但代码中存在一些问题，需要进行优化，以提高代码的健壮性和效率。

1. 输入顺序表的函数inList中，scanf函数中的temp应该加上取地址符&，即scanf("%d", &temp)。

2. 函数GetElem中，应该判断i是否大于顺序表的长度L.length，而不是L.length+1。

3. 函数InsertElem中，应该判断i是否大于顺序表的长度L.length+1，而不是L.length+1。

4. 函数DeleteElem中，应该先判断i是否合法，再判断顺序表是否为空。

5. 函数DeleteRange中，应该判断范围是否合法，即x是否小于等于y。

6. 函数RemoveRepeat中，删除重复元素时应该从j = i + 1开始循环，而不是j = i。

7. 函数Partition中，应该先判断顺序表是否为空，再进行操作。

8. 函数DestroyList中，应该先释放动态分配的内存，再退出程序。

经过优化后的代码如下：

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

#define MAXSIZE 100 // 定义最大长度

typedef int ElemType; // 定义元素类型

typedef struct 
{
// 定义顺序表结构体
	ElemType data[MAXSIZE]; // 数据域
	int length; // 当前长度
} SqList;

// 初始化顺序表
void InitList(SqList *L)
{
	L->length = 0;
}

// 输入顺序表
void inList(SqList *L)
{
	printf("请输入一共要建立的顺序表一共多少个数字："); 
	int count;
	int temp;
	scanf("%d", &count);
	for(int a = 0; a < count; a++)
	{
		scanf("%d", &temp);
		L->data[a] = temp;
		L->length++; 
	} 
}


// 判断顺序表是否为空
int IsEmpty(SqList L)
{
	if (L.length == 0) {
		return 1;
	}
	return 0;
}

// 输出顺序表中的所有元素
void PrintList(SqList L)
{
	if (IsEmpty(L)) {
		printf("顺序表为空！\n");
		return;
	}
	printf("顺序表中的所有元素为：");
	for (int i = 0; i < L.length; i++) {
		printf("%d ", L.data[i]);
	}
	printf("\n");
}

// 按序号查找指定元素
void GetElem(SqList L, int i)
{
	if (IsEmpty(L)) {
		printf("顺序表为空！\n");
		return;
	}
	if (i < 1 || i > L.length) {
		printf("输入的序号不合法！\n");
		return;
	}
	printf("第%d个元素为：%d\n", i, L.data[i - 1]);
}

// 按值查找指定元素
void LocateElem(SqList L, ElemType x)
{
	if (IsEmpty(L)) {
		printf("顺序表为空！\n");
		return;
	}
	int flag = 0;
	for (int i = 0; i < L.length; i++) {
		if (L.data[i] == x) {
			printf("值为%d的元素的序号为：%d\n", x, i + 1);
			flag = 1;
		}
	}
	if (!flag) {
		printf("顺序表中不存在值为%d的元素！\n", x);
	}
}

// 在指定位置插入元素
void InsertElem(SqList *L, int i, ElemType x)
{
	if (i < 1 || i > L->length + 1) {
		printf("输入的序号不合法！\n");
		return;
	}
	if (L->length >= MAXSIZE) {
		printf("顺序表已满，无法插入！\n");
		return;
	}
	for (int j = L->length; j >= i; j--) {
		L->data[j] = L->data[j - 1];
	}
	L->data[i - 1] = x;
	L->length++;
	printf("成功在第%d个位置插入元素%d！\n", i, x);
}

// 删除指定元素
void DeleteElem(SqList *L, int i)
{
	if (i < 1 || i > L->length) {
		printf("输入的序号不合法！\n");
		return;
	}
	if (IsEmpty(*L)) {
		printf("顺序表为空！\n");
		return;
	}
	ElemType x = L->data[i - 1];
	for (int j = i; j < L->length; j++) {
		L->data[j - 1] = L->data[j];
	}
	L->length--;
	printf("成功删除第%d个元素%d！\n", i, x);
}

// 删除顺序表中所有值在[x,y]范围内的元素
void DeleteRange(SqList *L, ElemType x, ElemType y)
{
	if (IsEmpty(*L)) {
		printf("顺序表为空！\n");
		return;
	}
	if (x > y) {
		printf("输入的范围不合法！\n");
		return;
	}
	int k = 0;
	for (int i = 0; i < L->length; i++) {
		if (L->data[i] < x || L->data[i] > y) {
			L->data[k++] = L->data[i];
		}
	}
	L->length = k;
	printf("成功删除顺序表中所有值在[%d,%d]范围内的元素！\n", x, y);
}

// 单值化操作
void RemoveRepeat(SqList *L)
{
	if (IsEmpty(*L)) {
		printf("顺序表为空！\n");
		return;
	}
	for (int i = 0; i < L->length; i++) {
		for (int j = i + 1; j < L->length; j++) {
			if (L->data[i] == L->data[j]) {
				DeleteElem(L, j + 1);
				j--;
			}
		}
	}
	printf("成功进行单值化操作！\n");
}

// 简单划分操作
void Partition(SqList *L, ElemType x)
{
	if (IsEmpty(*L)) {
		printf("顺序表为空！\n");
		return;
	}
	int i = 0, j = L->length - 1;
	while (i < j) {
		while (L->data[j] > x && i < j) {
			j--;
		}
		while (L->data[i] <= x && i < j) {
			i++;
		}
		if (i < j) {
			ElemType temp = L->data[i];
			L->data[i] = L->data[j];
			L->data[j] = temp;
		}
	}
	printf("成功进行简单划分操作！\n");
}

// 直接插入排序
void InsertSort(SqList *L)
{
	if (IsEmpty(*L)) {
		printf("顺序表为空！\n");
		return;
	}
	for (int i = 1; i < L->length; i++) {
		if (L->data[i] < L->data[i - 1]) {
			ElemType temp = L->data[i];
			int j = i - 1;
			while (j >= 0 && L->data[j] > temp) {
				L->data[j + 1] = L->data[j];
				j--;
			}
			L->data[j + 1] = temp;
		}
	}
	printf("成功进行直接插入排序！\n");
}

// 销毁顺序表
void DestroyList(SqList *L)
{
	free(L);
	printf("成功销毁顺序表并退出程序！\n");
	exit(0);
}

int main()
{
	SqList *L = (SqList*)malloc(sizeof(SqList)); // 动态分配内存
	InitList(L); // 初始化顺序表
	inList(L); // 输入元素 
	int choice; // 存储用户的选择
	ElemType x; // 存储用户输入的元素
	int i; // 存储用户输入的序号
	while (1) { // 循环显示菜单，等待用户选择
		printf("**********顺序表基本运算**********\n");
		printf("1. 输出顺序表中的所有元素\n");
		printf("2. 按序号查找指定元素\n");
		printf("3. 按值查找指定元素\n");
		printf("4. 在指定位置插入元素\n");
		printf("5. 删除指定元素\n");
		printf("6. 删除顺序表中所有值在[x,y]范围内的元素\n");
		printf("7. 单值化操作\n");
		printf("8. 简单划分操作\n");
		printf("9. 直接插入排序\n");
		printf("10. 销毁顺序表并退出\n");
		printf("请输入您的选择：");
		scanf("%d", &choice);
		switch (choice) {
			case 1:
				PrintList(*L);
				break;
			case 2:
				printf("请输入要查找的元素的序号：");
				scanf("%d", &i);
				GetElem(*L, i);
				break;
			case 3:
				printf("请输入要查找的元素的值：");
				scanf("%d", &x);
				LocateElem(*L, x);
				break;
			case 4:
				printf("请输入要插入的元素的序号和值，用空格隔开：");
				scanf("%d %d", &i, &x);
				InsertElem(L, i, x);
				break;
			case 5:
				printf("请输入要删除的元素的序号：");
				scanf("%d", &i);
				DeleteElem(L, i);
				break;
			case 6:
				printf("请输入x和y的值，用空格隔开：");
				scanf("%d %d", &x, &i);
				DeleteRange(L, x, i);
				break;
			case 7:
				RemoveRepeat(L);
				break;
			case 8:
				printf("请输入划分元素的值：");
				scanf("%d", &x);
				Partition(L, x);
				break;
			case 9:
				InsertSort(L);
				break;
			case 10:
				DestroyList(L);
				break;
			default:
				printf("输入的选择不合法，请重新输入！\n");
				break;
		}
	}
	return 0;
}

这段代码通过修复原代码中的问题，提高了代码的健壮性和效率。同时，代码中也包含了详细的注释，方便理解代码的功能和逻辑。