顺序表_基本操作

顺序表的基本操作

以下内容为bo2-1.h文件

	/*
	 * 时间：2021.01.28
	 * 内容：顺序存储的线性表的基本操作(12个)
	 * 位置：
	 * 严书P25-P29 高书P11
	 */
	
	/*
	 * 顺序表的初始化伪算法：
	 * Status InitList(SqList &L)
	 * {//构造一个空的顺序表L
	 *		L.elem = new ElemType(MAXSIZE);	//为顺序表分配一个大小为MAXSIZE的数组空间
	 *		if(!L.elem)
	 *		{
	 *			exit(OVERFLOW);				//存储失败退出
	 *		}
	 *		L.length = 0;					//空表长度为0
	 *		retuen OK;
	 * }
	 */
	
	void InitList(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;
	}
	
	//注：
	//该函数在严书中未提及
	void DestroyList(SqList &L)
	{//初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L
		free(L.elem);	//释放L.elem所指的存储空间
		L.elem = NULL;	//L.elme不再指向任何存储单元
		L.length = 0;
		L.listsize = 0;
		
		return;
	}
	
	//注：
	//该函数在严书中未提及
	void ClearList(SqList &L)
	{//初始条件：顺序线性表L已存在。操作结果：将L重置为空表
			L.length = 0;
	
			return;
	}
	
	//注：
	//该函数在严书中未提及
	Status ListEmpty(SqList L)
	{//初始条件：顺序线性表L已存在。
	 //操作结果：若L为空表，则返回TRUE；否则返回FALSE
	 	if(L.length == 0)
		{
			return TRUE;
		}
		else
		{
			return FALSE;
		}
	}
	
	//注：
	//该函数在严书中未提及
	int ListLength(SqList L)
	{// 初始条件：顺序线性表L已存在。 操作结果：返回L中数据元素的个数
			return L.length;
	}
	
	/*
	 * 顺序表的取值伪算法
	 * Status GetElem(SqList L, int i, ElemType &e)
	 * {
	 * 		if(i<1 || i>L.length)
	 * 		{
	 * 			return ERROR;	//判断i值是否合理，若不合理，返回ERROR
	 * 		}
	 *
	 * 		e = L.elem[i - 1];	//elem[i - 1]单元存储第i个数据元素
	 *
	 * 		return OK;
	 * }
	 */
	
	Status GetElem(SqList L, int i, ElemType &e)
	{//初始条件：顺序线性表L已存在，1<=i<=ListLength(L)
	 //操作结果:用e返回L中第i个数据元素的值
		if(i < 1 || i > L.length)	//i不在表L的范围之内
		{
			return ERROR;
		}
		
		e = *(L.elem + i - 1);	//将表L的第i个元素的值赋给e
		
		return OK;
	}
	
	/*
	 * 顺序表的查找伪算法
	 * int LocateElem(SqList L, ElemType e)
	 * {//在顺序表L中查找值为e的数据元素，返回其序号
	 * 		for(i = 0; i < L.length; i++)
	 * 		{
	 * 			if(L.elem[i] == e)
	 * 			{
	 * 				return i+1;	//查找成功；返回序号i+1
	 * 			}
	 * 		}
	 *
	 * 		return 0;	//查找失败，返回0
	 * }
	 */
	
	int LocateElem(SqList L, ElemType e, Status(*compare)(ElemType, ElemType))
	{//初始条件：顺序线性表L已存在,compare()是数据元素判定函数(满足为1，否则为0)
	 //操作结果：返回L中第一个与e满足关系compare()的数据元素的位序。
	 //			 若这样的数据元素不存在，则返回值为0.	算法2.6
	
			int i = 1;	//i的初值为第一个元素的位序
			ElemType * p = L.elem;	//p的初值为第一个元素的存储位置
	
			while(i <= L.length && !compare(* p++, e))	//i未超出表的范围且未找到满足关系的数据元素
			{
				i++;
			}
	
			if(i <= L.length)	//找到满足关系的数据元素
			{
				return i;	//返回其位序
			}
			else	//未找到满足关系的数据元素
			{
				return 0;
			}
	}
	/*
	 * LocateElem()函数的部分解释(高书)
	 * LocateElem()函数也要调用一类函数compare()
	 * 由LocateElem()函数的声明可以看出：
	 * 要求这类函数具有两个形参，其类型均为ElemType;
	 * 函数的返回值为Status类型。
	 * 不仅如此，根据LocateElem()函数的说明(初始条件)，当compare()函数的两个形参满足给定条件时，返回值为1，否则为0.
	 * 只有满足这种条件的函数才能替代compare()函数的实参函数
	 */
	
	//注：
	//此函数在严书中未提及
	Status PriorElem(SqList L, ElemType cur_e, ElemType &pre_e)
	{//初始条件：顺序线性表L已存在
	 //操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱；
	 //			 否则操作失败，pre_e无定义
		
		int i = 2;	//从第二个元素开始
		ElemType * p = L.elem + 1;	//p指向第二个元素
	
		while(i <= L.length && *p != cur_e)	//i未超出表的范围且未找到值为cur_e的元素
		{
			p++;	//p指向下一个元素
			i++;	//计数加1
		}
	
		if(i > L.length)	//到表结束处还未找到值为cur_e的元素
		{
			return ERROR;
		}
		else	//找到值为cur_e的元素，并由p指向其
		{
			pre_e = * --p;	//p指向前一个元素(cur_e的前驱)，将所指元素的值赋给pre_e
			return OK;		//操作成功
		}
	}
	
	//注：
	//此函数在严书中未提及
	Status NextElem(SqList L, ElemType cur_e, ElemType &next_e)
	{//初始条件：顺序线性表L已存在
	 //操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
	 //			 否则操作失败，next_e无定义
		
		int i = 1;	//从第一个元素开始
		ElemType * p = L.elem;	//p指向第一个元素
	
		while(i < L.length && *p != cur_e)	//i未到表尾且未找到值为cur_e的元素
		{
			p++;	//p指向下一个元素
			i++;	//计数加1
		}
	
		if(i == L.length)	//到表尾的前一个元素还未找到值为cur_e的元素
		{
			return ERROR;	//操作失败
		}
		else	//找到值为cur_e的元素，并由p指向其
		{
			next_e = * ++p;	//p指向下一个元素(cur_e的后继)，将所指元素的值赋给next_e
			return OK;
		}
	}
	
	
	/*
	 * 顺序表的插入伪算法
	 * Status ListInsert(SqList &L, int i, ElemType e)
	 * {//在顺序表L中第i个位置之前插入新的元素e，i的值的合法范围是1 <= i <= L.length
	 *
	 * 		if( (i < 1) || (i > L.length + 1) )
	 * 		{
	 * 			return ERROR;	//i值不合法
	 * 		}
	 *
	 * 		if(L.length == MAXSIZE)
	 * 		{
	 * 			return ERROR;	//当前储存空间已满
	 * 		}
	 *
	 * 		for(j = L.length - 1; j >= i-1; j--)
	 * 		{
	 * 			L.elem[j + 1] = L.elem[j];	//插入位置及之后的元素后移
	 * 		}
	 *
	 * 		L.elem[i - 1] = e;	//将新元素e放入第i个位置
	 * 		++L.length;			//表长加1
	 *
	 * 		return OK;
	 *
	 * }
	 */
	
	Status ListInsert(SqList &L, int i, ElemType e)//算法2.4
	{//初始条件：顺序线性表L已存在，1 <= i <= ListLength(L) + 1
	 //操作结果：在L中第i个位置之前插入新的数据元素e,L的长度加1
	
		ElemType * newbase, *q, *p;
	
		if(i < 1 || i > L.length + 1)	//i值不合法
		{
			return ERROR;
		}
	
		if(L.length == L.listsize)	//当前储存空间已满，增加分配，修改
		{
			newbase = (ElemType *)realloc(L.elem, (L.listsize + LIST_INCREMENT) * sizeof(ElemType));
			/*
			 * 来源：优快云 博主：ai52learn 题名：realloc函数的使用
			 *
			 * realloc函数的使用：
			 *
			 * 原型：
			 * extern void*realloc(void *mem_address, unsigned int newsize);
			 *
			 * 语法：
			 * 指针名 = (数据类型 *)realloc(要改变内存大小的指针名, 新的大小)
			 * 新的大小可大可小，若小于原内存，可能会导致数据丢失
			 *
			 * 功能：
			 * 	先判断当前的指针是否由足够的连续空间，
			 * 	如果有，扩大mem_address指向的地址，并且将mem_address返回，
			 * 	如果空间不够，先按照newsize指定的大小分配空间，将原有数据从头到尾拷贝到新分配的内存区域，而后释放原来mem_address所指内存区域
			 * 	(注意：原来指针是自动释放，不需要使用free),
			 * 	同时返回新分配的内存区域的首地址。即重新分配储存器块的地址
			 */ 
	
			if(!newbase)	//存储分配失败
			{
				exit(OVERFLOW);
			}
	
			L.elem = newbase;	//新基址赋给L.elem
			L.listsize += LIST_INCREMENT;	//增加储存容量
		}
	
		q = L.elem + i - 1;	//q为插入位置
	
		for(p = L.elem + L.length - 1; p >= q; --p)	//插入位置及之后的元素右移(由表尾元素开始移)
		{
			*(p + 1) = *p;
		}
	
		*q = e;	//插入e
		L.length++;	//表长增1
	
		return OK;
	}
	
	/*
	 * 顺序表删除伪算法
	 * Status ListDelete(SqList &L, int i)
	 * {//在顺序表L中删除第i个元素，i值的合法范围是1 <= i <=L.length
	 * 		
	 * 		if((i < 1) || (i > L.length))	//i值不合法
	 * 		{
	 * 			return ERROR;
	 * 		}
	 *
	 * 		for(j = i; j <= L.length-1; j++)
	 * 		{
	 * 			L.elem[j-1] = L.elem[j];	//被删除元素之后的元素前移
	 * 		}
	 *
	 * 		--L.length;	//表长减1
	 *
	 * 		return OK；
	 * }
	 */
	
	Status ListDelete(SqList &L, int i, ElemType &e) //算法2.5
	{// 初始条件：顺序线性表L已存在，1 <= i <= ListLength(L)
	 // 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1
		
		ElemType *p, *q;
	
		if(i < 1 || i > L.length)	//i值不合法
		{
			return ERROR;
		}
	
		p = L.elem + i - 1;	// p为被删除元素的位置
		e = *p;	//被删除元素的值赋给e
		q = L.elem + L.length - 1;	//q为表尾元素的位置
	
		for(p++; p <= q; p++)	//被删除元素之后的元素左移(由被删除元素的后继元素开始移)
		{
			* (p-1) = * p;
		}
	
		L.length--;	// 表长减1
	
		return OK;
	}
	
	//注：
	//此函数在严书中未提及
	void ListTraverse(SqList L, void(* visit)(ElemType&))
	{// 初始条件：顺序线性表L已存在
	 //	操作结果：依次对L的每个数据元素调用函数visit()
	 //			  visit()的形参加&，表明课通过调用visit()改变元素的值
		
			ElemType * p = L.elem;	//p指向第一个元素
			int i;
	
			for(i = 1; i <= L.length; i++)	//从表L的第一个元素到最后一个元素
			{
				visit(* p++);	//对每个数据元素调用visit()
			}
	
			printf("\n");
		
			return;
	}
	
	/*
	 * ListTraverse()函数一些解释：(高书)
	 * 基本操作函数ListTraberse()还要调用visit()函数，并将visit()函数设为ListTraverse()的形参。
	 * 把函数vist()作为形参的原因，是要在ListTraverse()中根据情况调用不同的函数而不是一个固定的函数。
	 * 从作为形参的visit()函数得知，满足哪些条件的函数可以被ListTraverse()函数调用。
	 * 在函数类形参的声明中指定了visit()的函数类型，也就是函数返回值的类型(void).
	 * 在声明中还指定了vist()函数形参的个数(一个)和类型(ElemType&),都可以作为ListTraverse()函数的实参。
	 */
	
	
		```