2.2线性表的顺序表示

#include<cstdio>
#include<stdlib.h>
typedef int ElemType;

#define MaxSize 100

#define InitSize 100

//1.顺序表结构体定义
//1.1静态分配数组
typedef struct SqList {
	ElemType data[MaxSize];
	int length;
};
//1.2动态分配数组
typedef struct SeqList {
	ElemType *data;
	int length;
	int Size;
};

//2.顺序表基本操作(静态分配数组）
/*2.1初始化顺序表
	function：初始化顺序表相关参数
	input：顺序表
	output：无
*/
void InitList(SqList &L);

/*2.2求表长
	function：返回线性表L的长度，即L中数据元素的个数。
	input：顺序表
	output：线性表L的长度
*/
int Length(SqList L);

/*2.3按值查找操作（常用）
	function：在表L中查找具有给定关键字值的元素
	input：顺序表、关键字
	output：关键字的序号
*/
int LocateElem(SqList L, ElemType e);

/*2.4：按位查找操作
	function：获取表L 中第i 个位置的元素的值。
	input：顺序表、序号、关键字
	output：true：操作成功	false：操作失败
*/
bool GetElem(SqList L, int i,ElemType &e);

/*2.5：插入操作（常用）
	function：在表L 中的第i 个位置上插入指定元素e 。
	input：顺序表、位置序号、关键字
	output：true：操作成功	false：操作失败
*/
bool ListInsert(SqList &L, int i, ElemType e);

/*2.6：删除操作（常用）
	function：删除表L 中第i 个位置的元素，并用e 返回删除元素的值。
	input：顺序表、位置序号、关键字
	output：true：操作成功	false：操作失败
*/
bool ListDelete(SqList &L, int i, ElemType &e);

/*2.7：输出操作
	function：按前后顺序输出线性表L 的所有元素值。
	input：顺序表
	output：无
*/
void PrintList(SqList L);

/*2.8：判空操作
	function：若L 为空表，则返回true ，否则返回false 
	input：顺序表
	output：若L 为空表，则返回true ，否则返回false
*/
bool Empty(SqList L);

/*2.9：销毁操作
	function：销毁线性表，并释放线性表L 所占用的内存空间。
	input：顺序表
	output：true：操作成功	false：操作失败
*/
bool DestroyList(SqList &L);

/*2.10：补充
	交换位置i,j的元素
	查找前驱和后继元素
	合并列表
*/
void InitList(SqList &L)
{
	L.length = 0;
}

/*
	动态分配数组:
*/
bool InitList(SeqList &L) {
	L.data = (ElemType *)malloc(InitSize * sizeof(ElemType));
	if (!L.data) {
		return false;
	}
	L.length = 0;
	L.Size = InitSize;
	return true;
}


int Length(SqList L)
{
	return L.length;
}

int LocateElem(SqList L, ElemType e)
{	
	int i;
	for (i = 0; i < L.length; i++) {
		if (L.data[i] == e) {
			return i;
		}
	}
	//查找失败
	return -1;
}

bool GetElem(SqList L, int i,ElemType &e)
{
	if (i < 0 || i >= L.length) {
		return false;
	}
	e = L.data[i];
	return true;
}

bool ListInsert(SqList &L, int i, ElemType e)
{
	int j;
	if (i < 0 || i > L.length || L.length == MaxSize) {
		return false;
	}
	for (j = L.length - 1; j >= i; j--) {
		L.data[j + 1] = L.data[j];
	}
	L.data[i] = e;
	++(L.length);
	return false;
}

bool ListDelete(SqList &L, int i, ElemType &e)
{
	int j;
	if (i < 0 || i >= L.length) {
		return false;
	}
	e = L.data[i];
	for (j = i; j < L.length - 1; j++) {
		L.data[j] = L.data[j + 1];
	}
	--(L.length);
	return true;
}

void PrintList(SqList L)
{
	int j;
	if (L.length == 0) {
		printf("顺序表为空");
		return;
	}
	for (int j = 0; j < L.length; j++) {
		printf("第%d个元素的值为%d", j, L.data[j]);
	}
}

bool Empty(SqList L)
{
	if (L.length == 0) {
		return true;
	}
	else {
		return false;
	}
}

bool DestroyList(SqList &L)
{
	L.length =0;
	return true;
}
/*算法的基本思想
	功能：原地将R中保存的序列循环左移p个位置
	输入：para1：数组R		para2：位置p	para3：数组长度n
	输出：无
	算法思想：
		1.最简陋：一个一个挪位，直到挪够p个位置		8分
		2.精进：
			三次逆置
			算法Reverse：
				功能：将数组逆置
				输入：para1：left		para2：right	para3:数组R
				输出：无
*/
void function(int R[], int p, int n) {
	Reverse(0, p, R);
	Reverse(p + 1, n, R);
	Reverse(0, n, R);
}

void Reverse(int left, int right,int R[]) {
	while (left < right) {
		int temp = R[left];
		R[left] = R[right];
		left++;
		right--;
	}
}