SqList-CSDN博客

本文链接：https://blog.csdn.net/went2011/article/details/6865849
#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100		//线性表存储空间的初始分配量
#define LISTINCREMENT 10		//线性表存储空间的分配增量
#define ElemType int			//指定ElemType的类型

typedef struct {				
	/************************************************************************/
	/*定义线性顺序表的结构体                                                */
	/*Went 2011-10-3 21:02													*/
	/************************************************************************/
	ElemType *elem;				//存储空间基址
	int length;					//当前长度
	int listsize;				//当前分配的存储容量（以sizeof（ElemType）为单位）
}Sqlist;

int InitList_Sq(Sqlist &L) {
	/************************************************************************/
	/* 构造一个空的线性表L                                                  */
	/************************************************************************/
	L.elem = (ElemType *)malloc(LIST_INIT_SIZE * sizeof(ElemType));
	if (!L.elem)
		exit(OVERFLOW);			//存储分配失败
		L.length = 0;			//空表长度为0
		L.listsize = LIST_INIT_SIZE;
		return OK;
}//InitList_Sq

int DestroyList_Sq(Sqlist &L) {
	/************************************************************************/
	/* 初始条件：线性表L已存在                                              */
	/* 操作结果：销毁线性表L                                                */
	/************************************************************************/
	if (!L.elem)
		exit(OVERFLOW);
	free(L.elem);				//释放申请到的空间
	L.elem = NULL;
	L.length = 0;
	L.listsize = 0;
	return OK;
}//DestroyList_Sq

int ClearList_Sq(Sqlist &L) {
	/************************************************************************/
	/* 初始条件：线性表L已存在                                              */
	/* 操作结果：将L重置为空表                                              */
	/************************************************************************/
	L.length = 0;
	return OK;
}//ClearList_Sq

int ListEmpty_Sq(Sqlist L) {
	/************************************************************************/
	/* 初始条件：线性表L已存在                                              */
	/* 操作结果：若L为空表，则返回TRUE，否则返回FALSE                       */
	/************************************************************************/
	if (L.length == 0)
		return TRUE;
	else
		return FALSE;
}//ListEmpty_Sq

int ListLength_Sq(Sqlist L) {
	/************************************************************************/
	/* 初始条件：线性表L已存在                                              */
	/* 操作结果：返回L中数据元素个数                                        */
	/************************************************************************/
	return L.length;
}//ListLength_Sq

int GetElem_Sq(Sqlist L, int i, ElemType &e) {
	/************************************************************************/
	/* 初始条件:线性表L已存在，1《i《ListLength_Sq(L)                       */
	/* 操作结果:用e返回L中第i个数据元素的值                                 */
	/************************************************************************/
	if (i < 1 || i > L.length)
		return ERROR;
	e = L.elem[i - 1];
	return OK;
}//GetElem_Sq

int PriorElem_Sq(Sqlist L, typedef cur_e, typedef &pre_e) {
	/************************************************************************/
	/* 初始条件:线性表L已存在												*/
	/* 操作结果:若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱， */
	/* 否则操作失败，pre_e无定义											*/
	/************************************************************************/
	for(int i = 0; i < L.length; i++) {
		if (L.elem[i] == cur_e) {
			if (i == 0)				//i为第一个元素
				return ERROR;
			else {
				pre_e = L.elem[i - 1];
				return OK;
			}
		}
	}
	return ERROR;
}//PriorElem_Sq

int NextElem_Sq(Sqlist L, typedef cur_e, typedef &next_e) {
	/************************************************************************/
	/* 初始条件:线性表L已存在												*/
	/* 操作结果:若cur_e是L的数据元素，且不是最后一个，则用pre_e返回它的后继 */
	/* 否则操作失败，next_e无定义											*/
	/************************************************************************/
	for(int i = 0; i < L.length; i++) {
		if (L.elem[i] == cur_e) {
			if (i + 1 >= L.length)
				return ERROR;		//i为最后一个元素
			else {
				next_e = L.elem[i + 1];
				return OK;
			}
		}
	}
	return ERROR;
}//NextElem_Sq

int ListInsert_Sq(Sqlist &L, int i, typedef e) {
	/************************************************************************/
	/* 初始条件：线性表L已存在,1《i《ListLength(L)+1                        */
	/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1            */
	/************************************************************************/
	if (i < 1 || i > L.length + 1)
		return ERROR;
	if (L.length >= L.listsize) {
		//若空间不够则增加之
		if ((L.elem = (ElemType *)realloc(L.elem, sizeof(ElemType)
			*(L.listsize+LISTINCREMENT))) && L.elem==NULL)
			return OVERFLOW;
		L.listsize += LISTINCREMENT;
	}
	ElemType *q = &(L.elem[i - 1]);			//q为插入位置
	for(ElemType *p = &(L.elem[L.length - 1]); p >= q; --p)
		*(p + 1) = *p;						//插入位置及之后的元素右移
	*q = e;									//插入e
	++L.length;								//表长增1
	return OK;
}//ListInsert_Sq

int ListDelete_Sq(Sqlist &L, int i, typedef &e) {
	/************************************************************************/
	/* 初始条件：线性表L已存在且非空，1《i《ListLength(L)                   */
	/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1            */
	/************************************************************************/
	if (i < 1 || i > L.length)
		return ERROR;
	ElemType *q = &(L.elem[i - 1]);			//q为被删除元素的位置
	e = *q;
	ElemType *p = &(L.elem[L.length - 1]);	//表尾元素位置
	for(++q; p >= q; ++q)
		*(q - 1) = *q;						//被删除元素之后的元素左移
	--L.length;								//表长减1
	return OK;
}//ListDelete_Sq

int visit(ElemType e) {
	printf("%d ", e);
	return OK;
}

int ListTraverse(Sqlist L, int (*visit)(ElemType)) {
	/************************************************************************/
	/* 初始条件：线性表L已存在							                    */
	/* 操作结果：依次对L的每个数据元素调用函数visit()。直到visit()失败      */	
	/************************************************************************/
	int i = 1;
	while(i <= L.length) {
		if (visit(L.elem[i - 1]))
			i ++;
		else
			return ERROR;
	}
	printf("\n");
	return OK;
}

int main() {
	/************************************************************************/
	/* 测试                                                                 */
	/************************************************************************/
	Sqlist L;
	int order, temp, result;
	while(scanf("%d", &order) && order != -1) {
		switch(order) {
			//InitList a list
			case 0 : temp = InitList_Sq(L);
				     if (temp == OVERFLOW)
						 printf("OVERFLOW\n");
					 else
						 printf("InitList Successfully!\n");
					 break;
			//Destroy a list
			case 1 : temp = DestroyList_Sq(L);
					 if (temp == OVERFLOW)
						 printf("OVERFLOW\n");
					 else
						 printf("Destroy Successfully!\n");
					 break;
			//Clear a list
			case 2 : temp = ClearList_Sq(L);
					 if (temp == OK)
						 printf("Clear Successfully!\n");
					 else
						 printf("ERROR occured in ClearList_Sq(L)!\n");
					 break;
			//If it is empty
			case 3 : temp = ListEmpty_Sq(L);
					 if (temp == TRUE)
						 printf("The SqList is empty\n");
					 else
						 printf("The SqList is not empty\n");
					 break;
			//The length of a list
			case 4 : result = ListLength_Sq(L);
					 if (result == ERROR)
						 printf("ERROR occured in ListLength_Sq(L)\n");
					 else
						 printf("ListLength is %d\n", result);
					 break;
			//Get the specified element
			case 5 : temp = GetElem_Sq(L, 1, result);
					 if (temp == ERROR)
						 printf("ERROR occured in GetElem_Sq(...)\n");
					 else
						 printf("The specified element is : %d\n", result);
					 break;
			//Get the prior elememt
			case 6 : temp = PriorElem_Sq(L, 2, result);
					 if (temp == ERROR)
						 printf("ERROR occured in PriorElem_Sq(...)\n");
					 else
						 printf("The prior element is : %d\n", result);
					 break;
			//Get the next element
			case 7 : temp = NextElem_Sq(L, 1, result);
					 if (temp == ERROR)
						 printf("ERROR occured in NextElem_Sq(...)\n");
					 else
						 printf("The next element is : %d\n", result);
					 break;
			//Insert the list
			case 8 : temp = ListInsert_Sq(L, 1, 1);
					 if (temp == ERROR)
						 printf("ERROR occured in ListInsert_Sq(...)\n");
					 else if (temp == OVERFLOW)
						 printf("OVERFLOW\n");
					 else
						 printf("List insert successfully\n");
					 break;
			//Delete an element
			case 9 : temp = ListDelete_Sq(L, 1, result);
					 if (temp == ERROR)
						 printf("ERROR occured in ListDelete_Sq(...)\n");
					 else
						 printf("Delete successfully\n");

			//Traverse the list
			case 10 : temp = ListTraverse(L, visit);
					 if (temp == ERROR)
						 printf("ERROR occured in ListTraverse(...)\n");
					 break;
		}
	}
	return 0;
}