数据结构教材代码Word格式文档下载.docx
《数据结构教材代码Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《数据结构教材代码Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。
=La_len）{
GetElem（La,i++,ai）;
while（j<
=Lb_len）{
GetElem（Lb,j++,bj）;
}//MergeList
StatusInitList_Sq（SqList&
L）{//算法2.3
//构造一个空的线性表L。
L.elem=（ElemType*）malloc（LIST_INIT_SIZE*sizeof（ElemType））;
L.elem）returnOK;
//存储分配失败
L.length=0;
//空表长度为0
L.listsize=LIST_INIT_SIZE;
//初始存储容量
returnOK;
}//InitList_Sq
StatusListInsert_Sq（SqList&
L,inti,ElemTypee）{//算法2.4
//在顺序线性表L的第i个元素之前插入新的元素e，
//i的合法值为1≤i≤ListLength_Sq（L）+1
ElemType*p;
if（i<
1||i>
L.length+1）returnERROR;
//i值不合法
if（L.length>
=L.listsize）{//当前存储空间已满，增加容量
ElemType*newbase=（ElemType*）realloc（L.elem,
（L.listsize+LISTINCREMENT）*sizeof（ElemType））;
newbase）returnERROR;
L.elem=newbase;
//新基址
L.listsize+=LISTINCREMENT;
//增加存储容量
ElemType*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
}//ListInsert_Sq
StatusListDelete_Sq（SqList&
L,inti,ElemType&
e）{//算法2.5
//在顺序线性表L中删除第i个元素，并用e返回其值。
//i的合法值为1≤i≤ListLength_Sq（L）。
ElemType*p,*q;
if（i<
1||i>
L.length）returnERROR;
p=&
//p为被删除元素的位置
e=*p;
//被删除元素的值赋给e
q=L.elem+L.length-1;
//表尾元素的位置
for（++p;
p<
++p）*（p-1）=*p;
//被删除元素之后的元素左移
--L.length;
//表长减1
}//ListDelete_Sq
intLocateElem_Sq（SqListL,ElemTypee,
Status（*compare）（ElemType,ElemType））{//算法2.6
//在顺序线性表L中查找第1个值与e满足compare（）的元素的位序。
//若找到，则返回其在L中的位序，否则返回0。
inti;
i=1;
//i的初值为第1个元素的位序
p=L.elem;
//p的初值为第1个元素的存储位置
=L.length&
!
（*compare）（*p++,e））
=L.length）returni;
elsereturn0;
}//LocateElem_Sq
voidMergeList_Sq（SqListLa,SqListLb,SqList&
Lc）{//算法2.7
//已知顺序线性表La和Lb的元素按值非递减排列。
//归并La和Lb得到新的顺序线性表Lc，Lc的元素也按值非递减排列。
ElemType*pa,*pb,*pc,*pa_last,*pb_last;
pa=La.elem;
pb=Lb.elem;
Lc.listsize=Lc.length=La.length+Lb.length;
pc=Lc.elem=（ElemType*）malloc（Lc.listsize*sizeof（ElemType））;
Lc.elem）
exit（OVERFLOW）;
pa_last=La.elem+La.length-1;
pb_last=Lb.elem+Lb.length-1;
while（pa<
=pa_last&
pb<
=pb_last）{//归并
if（*pa<
=*pb）*pc++=*pa++;
else*pc++=*pb++;
=pa_last）*pc++=*pa++;
//插入La的剩余元素
while（pb<
=pb_last）*pc++=*pb++;
//插入Lb的剩余元素
StatusGetElem_L（LinkList&
L,inti,ElemType&
e）{//算法2.8
//L为带头结点的单链表的头指针。
//当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR
LinkListp;
p=L->
next;
intj=1;
//初始化，p指向第一个结点，j为计数器
while（p&
j<
i）{//顺指针向后查找，直到p指向第i个元素或p为空
p=p->
if（!
p||j>
i）returnERROR;
//第i个元素不存在
e=p->
data;
//取第i个元素
}//GetElem_L
StatusListInsert_L（LinkList&
L,inti,ElemTypee）{//算法2.9
//在带头结点的单链线性表L的第i个元素之前插入元素e
LinkListp,s;
p=L;
intj=0;
j<
i-1）{//寻找第i-1个结点
}
p||j>
i-1）returnERROR;
//i小于1或者大于表长
s=（LinkList）malloc（sizeof（LNode））;
//生成新结点
s->
data=e;
next=p->
//插入L中
p->
next=s;
}//LinstInsert_L
StatusListDelete_L（LinkList&
e）{//算法2.10
//在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
LinkListp,q;
while（p->
next&
i-1）{//寻找第i个结点，并令p指向其前趋
（p->
next）||j>
//删除位置不合理
q=p->
next=q->
//删除并释放结点
e=q->
free（q）;
}//ListDelete_L
voidCreateList_L（LinkList&
L,intn）{//算法2.11
//逆位序输入（随机产生）n个元素的值，建立带表头结点的单链线性表L
L=（LinkList）malloc（sizeof（LNode））;
L->
next=NULL;
//先建立一个带头结点的单链表
for（i=n;
i>
0;
--i）{
p=（LinkList）malloc（sizeof（LNode））;
data=random（200）;
//改为一个随机生成的数字（200以内）
next=L->
next=p;
}//插入到表头
}//CreateList_L
voidMergeList_L（LinkList&
La,LinkList&
Lb,LinkList&
Lc）{
//算法2.12
//已知单链线性表La和Lb的元素按值非递减排列。
//归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
LinkListpa,pb,pc;
pa=La->
pb=Lb->
Lc=pc=La;
//用La的头结点作为Lc的头结点
while（pa&
pb）{
if（pa->
data<
=pb->
data）{
pc->
next=pa;
pc=pa;
pa=pa->
else{pc->
next=pb;
pc=pb;
pb=pb->
next=pa?
pa:
pb;
//插入剩余段
free（Lb）;
//释放Lb的头结点
}//MergeList_L
第6章二叉树
StatusInOrderTraverse（BiTreeT,Status（*Visit）（ElemType））{
//算法6.2
//采用二叉链表存储结构，Visit是对数据元素操作的应用函数。
//中序遍历二叉树T的非递归算法，对每个数据元素调用函数Visit。
stackS;
BiTreep;
InitStack（S）;
Push（S,T）;
//根指针进栈
while（!
StackEmpty（S））{
while（GetTop（S,p）&
p）Push（S,p->
lchild）;
//向左走到尽头
Pop（S,p）;
//空指针退栈
StackEmpty（S））{//访问结点，向右一步
Visit（p->
data））returnERROR;
Push（S,p->
rchild）;
}//InOrderTraverse
//算法6.3
p=T;
while（p||!
if（p）{Push（S,p）;
lchild;
}//非空指针进栈，继续左进
else{//上层指针退栈，访问其所指结点，再向右进
rchild;
BiTreeCreateBiTree（BiTree&
T）{//算法6.4
//按先序次序输入二叉树中结点的值（一个字符），空格字符表示空树，
//构造二叉链表表示的二叉树T。
charch;
scanf（"
%c"
&
ch）;
if（ch=='
#'
）T=NULL;
else{
（T=（BiTNode*）malloc（sizeof（BiTNode））））returnERROR;
T->
data=ch;
//生成根结点
CreateBiTree（T->
//构造左子树
//构造右子树
returnT;
}//CreateBiTree
StatusInOrderTraverse_Thr（BiThrTreeT,Status（*Visit）（ElemType））{
//算法6.5
//T指向头结点，头结点的左链lchild指向根结点，头结点的右链lchild指向
//中序遍历的最后一个结点。
中序遍历二叉线索链表表示的二叉树T，
//对每个数据元素调用函数Visit。
BiThrTreep;
p=T->
//p指向根结点
while（p!
=T）{//空树或遍历结束时，p==T
LTag==Link）p=p->
//访问其左子树为空的结点
RTag==Thread&
rchild!
=T）{
Visit（p->
data）;
//访问后继结点
//p进至其右子树根
}//InOrderTraverse_Thr
StatusInOrderThreading（BiThrTree&
Thrt,BiThrTreeT）{//算法6.6
//中序遍历二叉树T，并将其中序线索化，Thrt指向头结点。
（Thrt=（BiThrTree）malloc（sizeof（BiThrNode））））exit（OVERFLOW）;
Thrt->
LTag=Link;
RTag=Thread;
//建头结点
rchild=Thrt;
//右指针回指
T）Thrt->
lchild=Thrt;
//若二叉树空，则左指针回指
lchild=T;
pre=Thrt;
InThreading（T）;
//算法6.7：
中序遍历进行中序线索化
pre->
RTag=Thread;
//最后一个结点线索化
rchild=pre;
}//InOrderThreading
voidInThreading（BiThrTreep）{//算法6.7
if（p）{
InThreading（p->
//左子树线索化
p->
lchild）//建前驱线索
{p->
LTag=Thread;
lchild=pre;
pre->
rchild）//建后继线索
{pre->
rchild=p;
pre=p;
//保持pre指向p的前驱
//右子树线索化
}//InThreading
第9章查找
intSearch_Seq（SSTableST,KeyTypekey）{//算法9.1
//在顺序表ST中顺序查找其关键字等于key的数据元素。
//若找到，则函数值为该元素在表中的位置，否则为0。
inti=0;
ST.elem[0].key=key;
//"
哨兵"
for（i=ST.length;
ST.elem[i].key!
=key;
--i）;
//从后往前找
returni;
//找不到时，i为0
}//Search_Seq
intSearch_Bin（SSTableST,KeyTypekey）{//算法9.2
//在有序表ST中折半查找其关键字等于key的数据元素。
intlow,high,mid;
low=1;
high=ST.length;
//置区间初值
while（low<
=high）{
mid=（low+high）/2;
if（EQ（key,ST.elem[mid].key））returnmid;
//找到待查元素
elseif（LT（key,ST.elem[mid].key））high=mid-1;
//继续在前半区间进行查找
elselow=mid+1;
//继续在后半区间进行查找
return0;
//顺序表中不存在待查元素
}//Search_Bin
BiTreeSearchBST（BiTreeT,KeyTypekey）{//算法9.5（a）
//在根指针T所指二叉排序树中递归地查找其关键字等于key的数据元素，
//若查找成功，则返回指向该数据元素结点的指针，否则返回空指针
T||EQ（key,T->
data.key））returnT;
//查找结束
elseif（LT（key,T->
data.key））
returnSearchBST（T->
lchild,key）;
//在左子树中继续查找
else
rchild,key）;
//在右子树中继续查找
}//SearchBST
StatusSearchBST（BiTreeT,KeyTypekey,BiTreef,BiTree&
p）{
//算法9.5（b）
//若查找成功，则指针p指向该数据元素结点，并返回TRUE，
//否则指针p指向查找路径上访问的最后一个结点并返回FALSE，
//指针f指向T的双亲，其初始调用值为NULL
T）{p=f;
returnFALSE;
}//查找不成功
elseif（EQ（key,T->
data.key））{p=T;
returnTRUE;
}//查找成功
lchild,key,T,p）;
//在左子树中继续查找
rchild,key,T,p）;
StatusInsertBST（BiTree&
T,ElemTypee）{//算法9.6
//当二叉排序树T中不存在关键字等于e.key的数据元素时，
//插入e并返回TRUE，否则返回FALSE
BiTreep,s;
SearchBST（T,e.key,NULL,p））{//查找不成功
s=（BiTree）malloc（sizeof（BiTNode））;
lchild=s->
rchild=NULL;
p）T=s;
//插入s为新的根结点
elseif（LT（e.key,p->
data.key））p->
lchild=s;
//插入s为左孩子
elsep->
rchild=s;
//插入s为右孩子
}elsereturnFALSE;
//树中已有关键字相同的结点，不再插入
}//InsertBST
StatusDeleteBST（BiTree&
T,KeyTypekey）{//算法9.7
//若二叉排序树T中存在关键字等于key的数据
升级会员 