线性表的动态分配顺序存储结构Word文档格式.docx
《线性表的动态分配顺序存储结构Word文档格式.docx》由会员分享，可在线阅读，更多相关《线性表的动态分配顺序存储结构Word文档格式.docx（12页珍藏版）》请在冰豆网上搜索。
}//Compare
voidVisit（ElemTypee）
在屏幕上输出e
printf（"
%d"
e）;
}//Visit
SqList.h
//顺序表头文件
//线性表的动态分配顺序存储结构
#defineLIST_INIT_SIZE100//线性表存储空间的初始分配量
#defineLISTINCREMENT10//线性表存储空间的分配增量
typedefstruct{
ElemType*elem;
//存储空间基址
intlength;
//当前长度
intlistsize;
//当前分配的存储容量
}SqList;
//顺序表的基本操作
StatusInitList_Sq（SqList&
）;
StatusDestroyList_Sq（SqList&
//声明顺序表的引用型操作
StatusListEmpty_Sq（SqList）;
intListLength_Sq（SqList）;
ElemTypePriorElem_Sq（SqList,ElemType,ElemType&
ElemTypeNextElem_Sq（SqList,ElemType,ElemType&
ElemTypeGetElem_Sq（SqList,int,ElemType&
intLocateElem_Sq（SqList,ElemType,pCompare）;
voidListTraverse_Sq（SqList,pVisit）;
//声明顺序加工型操作
StatusClearList_Sq（SqList&
StatusPutElem（SqList&
int,ElemType）;
StatusListInsert_Sq（SqList&
StatusListDelete_Sq（SqList&
int,ElemType&
voidUnion（SqList&
SqList）;
voidPurge（SqList&
voidMergeList_Sq（SqList,SqList,SqList&
SqList.cpp
//顺序表的操作
SqList.h"
StatusInitList_Sq（SqList&
L）
{//操作结果：
构造一个空线性表L
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
//申请分配存储空间
if（!
L.elem）exit（OVERFLOW）;
//存储分配失败
L.length=0;
//顺序表长度初始化为0
L.listsize=LISTINCREMENT;
//当前存储容量大小为INCREMENT
returnOK;
}//InitList_Sq
StatusDestroyList_Sq（SqList&
{
//初始条件：
顺序表L存在
//操作结果：
销毁顺序表L
L.elem）exit（ERROR）;
//顺序表不存在，函数调用失败
free（L.elem）;
//释放存储空间
L.listsize=0;
L.elem=NULL;
}//DestroyList_Sq
//顺序表的引用型操作
StatusListEmpty_Sq（SqListL）
查看顺序表L是否为空表，是则返回TRUE；
反之返回FALSE
if（L.length==0）
}//ListEmpty_Sq
intListLength_Sq（SqListL）
返回顺序表长度
returnL.length;
}//ListLength_Sq
ElemTypePriorElem_Sq（SqListL,ElemTypecur_e,ElemType&
pre_e）
若cur_e在顺序表中，且不是第一个元素，则用pre_e返回其前驱
//否则操作不可行
intpos=2;
//cur_e当前位置pos≥2
ElemType*p=L.elem+1;
//从顺序表第2个位置查找cur_e
while（pos++<
=L.length&
&
（*p++）!
=cur_e）;
//pos范围2≤pos≤L.Length
if（pos>
L.length）returnINFEASIBLE;
//到表结束未找到cur_e,操作不可行
else{
pre_e=（*--p）;
//pre_e为当前值cur_e的前驱
returnpre_e;
//返回前驱pre_e
}
}//PriorElem_Sq
ElemTypeNextElem_Sq（SqListL,ElemTypecur_e,ElemType&
next_e）
若cur_e在顺序表中，且不是最后一个元素，则用next_e返回其后继
intpos=1;
//cur_e当前位置pos≥2
ElemType*p=L.elem;
//从顺序表第1个位置查找cur_e
L.length&
//pos范围1≤pos＜L.Length
if（pos==L.length）returnINFEASIBLE;
//到表尾未找到cur_e,操作不可行
next_e=（*++p）;
returnnext_e;
}//NextElem_Sq
ElemTypeGetElem_Sq（SqListL,intpos,ElemType&
e）
顺序表L存在，且1≤pos≤L.Length
用e返回pos位置的值
if（pos<
1||pos>
L.length）returnERROR;
//pos取值范围1≤pos≤L.Length
e=*（L.elem+pos-1）;
returne;
//用e返回pos位置的值
}//GetElem
intLocateElem_Sq（SqListL,ElemTypee,pCompareequal）
若元素e在顺序表中存在，则返回其在顺序表中第一次出现的位置
//否则，操作不可行
//pos≥1
!
equal（*p++,e））;
//遍历顺序表查找第一个cur_e
L.length）
return0;
//到表结束时未找到元素e
else
returnpos;
//返回顺序表中出现e的第一个位置
}//LocateElem_Sq
voidListTraverse_Sq（SqListL,pVisitvisit）
//初始条件:
//操作结果:
遍历顺序表，在屏幕上显示顺序表元素
intpos;
for（pos=1;
pos<
=L.length;
pos++）visit（L.elem[pos-1]）;
\n"
}//ListTraverse_Sq
//加工型操作
StatusClearList_Sq（SqList&
线性表L已存在
将L重置为空表
//空表长度为0
}//ClearList_Sq
StatusPutElem_Sq（SqList&
L,intpos,ElemTypee）
顺序表L存在，且pos范围为1≤pos≤L.length
顺序表第pos个位置赋值为e
L.elem[pos-1]=e;
}//PutElem_Sq
StatusListInsert_Sq（SqList&
顺序表L存在，且pos范围为1≤pos≤L.length+1
将e插入到顺序表第pos个位置，顺序表长度加1
ElemType*newbase;
ElemType*p,*q;
L.length+1）returnINFEASIBLE;
//pos值不合法
if（L.length>
L.listsize）{//存储空间满，增加分配
newbase=（ElemType*）realloc（L.elem,
（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
//重新分配存储块
if（!
newbase）exit（OVERFLOW）;
L.elem=newbase;
//新基址
L.listsize+=LISTINCREMENT;
//表长加1
q=&
L.elem[pos-1];
//q指向需要右移的元素位置
for（p=&
L.elem[L.length-1];
p>
=q;
p--）*（p+1）=*p;
//右移元素
*q=e;
L.length++;
}//ListInsert_Sq
StatusListDelete_Sq（SqList&
L,intpos,ElemType&
将顺序表中第pos个位置的元素e删除，并用e返回
q=L.elem+pos-1;
//p指向被删除元素的位置）
e=*q;
//被删除元素赋值给e
=++q;
p--）*（p-1）=*p;
//左移元素
L.length--;
returne;
}//ListDelete_Sq
voidUnion（SqList&
La,SqListLb）//A∪B
inti;
intLa_Len,Lb_Len;
ElemTypee;
pCompareequal;
La_Len=ListLength_Sq（La）;
//即La_Len=La.length
Lb_Len=ListLength_Sq（Lb）;
//即Lb_Len=Lb.length
for（i=1;
i<
=Lb_Len;
i++）{
GetElem_Sq（Lb,i,e）;
//e=Lb.elem[i-1]
LocateElem_Sq（La,e,equal））
ListInsert_Sq（La,++La_Len,e）;
//插入La之后
}//union
voidPurge（SqList&
La,SqListLb）//提取A集合（纯化）
ElemTypee,en;
//Compare函数指针
InitList_Sq（La）;
//构造一个空顺序表
//取La当前长度
//取Lb当前长度
i++）{//遍历顺序表Lb
//e=Lb.elem[i-1];
equal（en,e））ListInsert_Sq（La,++La_Len,e）;
en=e;
//en=Lb.elem[i-1]
}//Purge
voidMergeList_Sq（SqListLa,SqListLb,SqList&
Lc）//合并升序序列
InitList_Sq（Lc）;
//构造一个空顺序表Lc
inti=1;
//i指示La位置
intj=1;
//j指示Lb位置
intLa_Len,Lb_Len,Lc_Len;
ElemTypeai,bj;
//暂存La、Lb中的元素
//取La、Lb、Lc当前长度
Lc_Len=ListLength_Sq（Lc）;
//将短顺序表取出与长顺序表进行排序，并插入Lc中
while（i<
=La_Len&
j<
=Lb_Len）{
GetElem_Sq（La,i,ai）;
//ai=La.elem[i-1];
GetElem_Sq（Lb,j,bj）;
//bj=Lb.elem[j-1];
//将小的值插入Lc
if（ai<
=bj）{
ListInsert_Sq（Lc,++Lc_Len,ai）;
i++;
}
else{
ListInsert_Sq（Lc,++Lc_Len,bj）;
j++;
=La_Len）{//如果La尚有元素未插入Lc，则全部插入
GetElem_Sq（La,i++,ai）;
ListInsert_Sq（Lc,++Lc_Len,ai）;
=Lb_Len）{//如果Lb尚有元素未插入Lc，则全部插入
GetElem_Sq（Lb,i++,bj）;
ListInsert_Sq（Lc,++Lc_Len,bj）;
}//MergeList_Sq
main.cpp
//main（检验基本操作的主程序）
voidmain（）
//定义试验变量
SqListL;
//初始化顺序表
InitList_Sq（L）;
初始化L后：
L.elem=%dL.length=%dL.listsize=%d\n"
L.elem,L.length,L.listsize）;
//在顺序表首部插入：
1，2，3，4，5
=5;
ListInsert_Sq（L,1,i）;
e=L.elem[0];
printf（"
第%d个元素为%d，此时L.elem=%dL.length=%dL.listsize=%d\n"
i,e,L.elem,L.length,L.listsize）;
//判空操作
顺序表L是否为空：
%d（1是0否）\n"
ListEmpty_Sq（L））;
//清空顺序表并判空
ClearList_Sq（L）;
//在顺序表尾端插入：
1，2，3，4，5，6，7，8
9;
ListInsert_Sq（L,i,i）;
e=L.elem[i-1];
//求表长操作
顺序表L长为%d\n"
ListLength_Sq（L））;
//删除操作
删除的第2个元素为%d\n"
ListDelete_Sq（L,2,e））;
//销毁顺序表
DestroyList_Sq（L）;
销毁L后：
L.elem=%uL.length=%dL.listsize=%d\n"
}
升级会员 