数据结构严蔚敏----动态顺序表基本操作12个

最新推荐文章于 2022-04-21 10:48:51 发布

欲掩一川

最新推荐文章于 2022-04-21 10:48:51 发布

阅读量452

点赞数 3

分类专栏：数据结构文章标签：数据结构严蔚敏动态顺序表

本文链接：https://blog.csdn.net/qq_41059755/article/details/85388774

版权

数据结构专栏收录该内容

8 篇文章 4 订阅

订阅专栏

编程语言：C
编译环境：Dev-C++
源代码：

//线性表的动态分配顺序存储结构
//12个基本操作
//1.Status InitList(SqList *L) 构造一个空的顺序表L
//  数组的基地址elem进行赋值(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType))，判断是否赋值成功，若失败，exit(OVERFLOW);
//  长度length赋初值0，存储总容量listsize赋初值LIST_INIT_SIZE，return OK;
//2.Status DestroyList(SqList *L) 销毁顺序表L，前提L存在
//  释放(free)数组基址，置为NULL，length和listsize置为0，return OK;
//3.Status ClearList(SqList *L) 将L重置为空表，前提L存在
//  length置为0，return OK;
//4.Status ListEmpty(SqList L) 探空，前提L存在
//  若length==0 return TRUE;否则return FALSE;
//5.int ListLength(SqList L) 返回长度，即L中数据元素的个数，前提L存在
//  return L.length;
//6.Status GetElem(SqList L,int i,ElemType *e) 用e返回L中第i个数据元素的值，前提L存在
//  先判断i是否在1和L.length之间，若不在，return ERROR;
//  令e指向数组elem下标为i-1的数据元素，return OK;
//7.int LocateElem(SqList L,ElemType e) 若e在L中存在，返回它的位置，否则返回0，前提L存在
//  令ElemType *p指向数组第一个数据元素，令int i=1; 
//  若i<=L.length&&*p!=e，i++，p++，最后若i>L.length，说明e在L中不存在，return 0;否则return i;
//8.Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e) 用pre_e返回L中cur_e的前驱元素，前提L存在
//  令ElemType *p指向数组第二个数据元素，令int i=2;如果cur_e恰好为第一个数据元素，它就没有前驱，所以cur_e恰好为第一个数据元素的可能性不用考虑 
//  若i<=L.length&&*p!=e，i++，p++，最后若i>L.length，说明cur_e在L中不存在，return ERROR;否则令*pre_e等于*(--p)，return OK;
//9.Status NextElem(SqList L,ElemType cur_e,ElemType *next_e) 用next_e返回L中cur_e的后继元素，前提L存在
//  令ElemType *p指向数组第一个数据元素，令int i=1; 
//  若i<=L.length&&*p!=e，i++，p++，最后若i>=L.length，说明cur_e在L中不存在或恰好为最后一个数据元素，return ERROR;否则令*next_e等于*(++p)，return OK; 
//10.Status ListInsert(SqList *L,int i,ElemType e) 在L中第i个位置之前插入新的数据元素e，L的长度加1，前提L存在
//   先判断i是否在1和L.length+1之间，若不在，return ERROR;
//   然后判断是否需要增加存储空间，若(*L).length>=(*L).listsize，则需要增加 
//                                 数组的新基址ElemType *newbase进行赋值(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType))
//                                 判断是否赋值成功，若失败，exit(OVERFLOW);
//                                 令(*L).elem=newbase;(*L).listsize+=LISTINCREMENT;
//   令ElemType *q指向数组第i个数据元素
//   令ElemType *p指向数组最后一个数据元素
//   若p>=q，*(p+1)=*p，p--，该循环用于进行后移操作
//   最后令*q=e;++(*L).length;return OK;
//11.Status ListDelete(SqList *L,int i,ElemType *e) 删除L的第i个数据元素，并用e返回其值，L的长度减1，前提L存在
//   先判断i>=1&&i<=(*L).length，若不是，return ERROR;此处也包含了L为空表不能进行删除的情况
//   令ElemType *q指向数组第i个数据元素，即待删除元素 
//   令ElemType *p指向数组最后一个数据元素
//   令*e=*q，在进行删除操作（即前移操作）之前必须将待删除的元素值赋给e，因为删除结束后就找不到了 
//   q++，若q<=p，*(q-1)=*q ，q++，该循环用于进行前移操作 
//   最后--(*L).length;return OK;
//12.Status ListTraverse(SqList L) 顺序表的遍历：依次访问表中每一个元素，前提L存在 
//   令ElemType *p指向数组第一个数据元素，令int i=1; 
//   若i<=L.length，printf("%d ",*p)，p++，i++ 
//   最后printf("\n");return OK; 
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
//函数结果状态代码
#define OK 1
#define ERROR 0
#define OVERFLOW -1
#define TRUE 1
#define FALSE 0

typedef int Status;
typedef int ElemType;
//线性表的动态分配存储结构
#define LIST_INIT_SIZE 10
#define LISTINCREMENT 5
typedef struct {
	ElemType *elem;//数组基址
	int length;//当前长度 
	int listsize;//当前存储空间 
}SqList; 
//1.构造一个空的顺序表L
Status InitList(SqList *L)
{
	(*L).elem=(ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType));
	if(!(*L).elem) exit(OVERFLOW);//判断
	(*L).length=0;
	(*L).listsize=LIST_INIT_SIZE;
	return OK; 
}  
//2.销毁顺序表L，前提L存在
Status DestroyList(SqList *L)
{
	free((*L).elem);
	(*L).elem=NULL;
	(*L).length=0;
	(*L).listsize=0;
	return OK;
}
//3.将L重置为空表，前提L存在
Status ClearList(SqList *L)
{
	(*L).length=0;
	return OK;
}
//4.探空，前提L存在
Status ListEmpty(SqList L)
{
	if(L.length==0)
	    return TRUE;
	else
	    return FALSE;
}
//5.返回长度，即L中数据元素的个数，前提L存在
int ListLength(SqList L)
{
	return L.length;
}
//6.用e返回L中第i个数据元素的值，前提L存在
Status GetElem(SqList L,int i,ElemType *e)
{
	if(i<1||i>L.length)
	    return ERROR;
	else
	{
	    *e=L.elem[i-1];
	    return OK;
    }
}
//7.若e在L中存在，返回它的位置，否则返回0，前提L存在
int LocateElem(SqList L,ElemType e)
{
	ElemType *p=L.elem;
	int i=1;
	while(i<=L.length&&*p!=e)
	{
		i++;
		p++;
	}
	if(i>L.length)
	    return 0;
	else
	    return i;
}
//8.用pre_e返回L中cur_e的前驱元素，前提L存在
Status PriorElem(SqList L,ElemType cur_e,ElemType *pre_e)
{
	ElemType *p=L.elem+1;
	int i=2;
	while(i<=L.length&&*p!=cur_e)
	{
		i++;
		p++;
	}
	if(i>L.length)
	    return ERROR;
	else
	{
	    *pre_e=*(--p);
	    return OK;
    }	    
}
//9.用next_e返回L中cur_e的后继元素，前提L存在
Status NextElem(SqList L,ElemType cur_e,ElemType *next_e)
{
	ElemType *p=L.elem;
	int i=1;
	while(i<=L.length&&*p!=cur_e)
	{
		i++;
		p++;
	}
	if(i>=L.length)
	    return ERROR;
	else
	{
		*next_e=*(++p);
		return OK;
	}
}
//10.在L中第i个位置之前插入新的数据元素e，L的长度加1，前提L存在
Status ListInsert(SqList *L,int i,ElemType e)
{
	if(i<1||i>(*L).length+1)
	    return ERROR;
	if((*L).length>=(*L).listsize)
	{
		ElemType *newbase=(ElemType *)realloc((*L).elem,((*L).listsize+LISTINCREMENT)*sizeof(ElemType));
		if(!newbase) exit(OVERFLOW);
		(*L).elem=newbase;
		(*L).listsize+=LISTINCREMENT;
	}
	ElemType *q=(*L).elem+i-1;
	ElemType *p=(*L).elem+(*L).length-1;
	while(p>=q)
	{
		*(p+1)=*p;
		p--;
	}
	*q=e;
	++(*L).length;
	return OK;
}
//11.删除L的第i个数据元素，并用e返回其值，L的长度减1，前提L存在
Status ListDelete(SqList *L,int i,ElemType *e)
{
	if(i<1||i>(*L).length)
	    return ERROR;
	ElemType *q=(*L).elem+i-1;
	ElemType *p=(*L).elem+(*L).length-1;
	*e=*q;
	q++;
	while(q<=p)
	{
		*(q-1)=*q;
		q++;
	}
	--(*L).length;
	return OK;
}
//12.顺序表的遍历：依次访问表中每一个元素，前提L存在
Status ListTraverse(SqList L)
{
	ElemType *p=L.elem;
	int i=1;
	while(i<=L.length)
	{
		printf("%d ",*p);
		i++;
		p++;
	}
	printf("\n");
	return OK;
}
int main()
{
	SqList L;
	int j,j1;
	ElemType e=0,e1=0;
	printf("测试第一个基本操作（构造空顺序表）\n");
	InitList(&L);
	printf("L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("\n\n测试第十个基本操作（插入数据元素）\n");
	for(j=1;j<=5;j++)
	    ListInsert(&L,1,j);
	printf("在表头依次插入1~5后，L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("此时顺序表中的元素为：");
	ListTraverse(L);
	printf("第十二个基本操作测试成功！\n");
	printf("\n\n继续测试第十个基本操作，这次主要测试增加分配是否正确\n");
	for(j=6;j<=11;j++)
	    ListInsert(&L,j,j);
	printf("在表尾依次插入6~11后，L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("此时顺序表中的元素为：");
	ListTraverse(L);
	printf("\n\n测试第三、第四个基本操作：\n");
	printf("顺序表是否为空（1为空，0为不空）：%d\n",ListEmpty(L));
	ClearList(&L);
	printf("表清空后，顺序表是否为空（1为空，0为不空）：%d\n",ListEmpty(L));
	printf("L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("\n\n在表尾依次插入1~18。\n");
	for(j=1;j<=18;j++)
	    ListInsert(&L,j,j);
	printf("L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("此时顺序表中的元素为：");
	ListTraverse(L);
	printf("\n\n测试第五个基本操作（返回数据元素个数）\n");
	printf("表中数据元素的个数为%d\n",ListLength(L));
	printf("\n\n测试第六个基本操作（返回第十八个、第十九个数据元素的值）\n");
	GetElem(L,18,&e);
	GetElem(L,19,&e1);
	printf("第十八个数据元素为%d,第十九个数据元素为%d\n",e,e1);
	printf("\n\n测试第七个基本操作\n");
	j=LocateElem(L,18);
	j1=LocateElem(L,19);
	printf("18的位序为%d,19的位序为%d\n",j,j1);
	printf("\n\n测试第八个基本操作\n");
	e=0;
	e1=0;
	PriorElem(L,1,&e);
	PriorElem(L,18,&e1);
	printf("1的前驱为%d,18的前驱为%d\n",e,e1);
	printf("\n\n测试第九个基本操作\n");
	e=0;
	e1=0;
	NextElem(L,1,&e);
	NextElem(L,18,&e1);
	printf("1的后继为%d,18的后继为%d\n",e,e1);
	printf("\n\n测试第十一个基本操作\n");
	e=0;
	ListDelete(&L,6,&e);
	printf("删除第六个数据元素：%d\n",e);
	printf("L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	printf("此时顺序表中的元素为：");
	ListTraverse(L);
	printf("\n\n测试第十二个操作\n");
	DestroyList(&L);
	printf("销毁顺序表后，L.elem=%d,L.length=%d,L.listsize=%d\n",L.elem,L.length,L.listsize);
	return 0;
}

运行结果：

欲掩一川

关注

3
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
数据结构严蔚敏----动态顺序表基本操作12个

//线性表的动态分配顺序存储结构//12个基本操作//1.Status InitList(SqList *L) 构造一个空的顺序表L// 数组的基地址elem进行赋值(ElemType )malloc(LIST_INIT_SIZEsizeof(ElemType))，判断是否赋值成功，若失败，exit(OVERFLOW);// 长度length赋初值0，存储总容量listsize赋初值L...
复制链接

扫一扫