某某工业大学应数刘智煌数据结构Word格式文档下载.docx
《某某工业大学应数刘智煌数据结构Word格式文档下载.docx》由会员分享，可在线阅读，更多相关《某某工业大学应数刘智煌数据结构Word格式文档下载.docx（17页珍藏版）》请在冰豆网上搜索。
//定义名字字符串
intscore;
};
typedefstructBiTNode//定义数据类型
ElemTypedata;
structBiTNode*lchild,*rchild;
//左右孩子指针
}*BiTree,BiTNode;
//堆栈
typedefstruct
BiTree*base;
//栈底
BiTree*top;
intsize;
//大小
}SqStack;
StatusInitStack（SqStack&
S）
S.base=（BiTree*）malloc（SIZE*sizeof（BiTree））//申请一个空间储存树;
if（!
S.base）exit（OVERFLOW）;
//栈底不存在退出程序
S.top=S.base;
//把顶指针值赋给底指针
S.size=SIZE;
//树的大小等于申请SizE大小
return1;
}
StatusGetTop（SqStackS,BiTree&
e）//获得最上面的指针
if（S.top==S.base）return0;
//头等于尾空指针
e=*（S.top-1）;
StatusPush（SqStack&
S,BiTreee）//把输入的数压进栈
if（S.top-S.base>
=S.size）//有空间可以储存
{
S.base=（BiTree*）realloc（S.base,（S.size+INC）*sizeof（BiTree））;
//有空间就把输入的数推进栈里，没有就退出程序。
if（!
S.top=S.base+S.size;
S.size+=INC;
}
*S.top++=e;
StatusPop（SqStack&
S,BiTree&
e）//把数推出指针
//
e=*--S.top;
//把不需要的数推出
intStackEmpty（SqStackS）//测试是不是空栈
if（S.base==S.top）return1;
elsereturn0;
//队列
typedefBiTreeQElemType;
//构造一个树
typedefstructQNode
QElemTypedata;
QNode*next;
//*next指针
}*QueuePtr;
structLinkQueue//构造一个队列
QueuePtrfront,rear;
StatusInitQueue（LinkQueue&
Q）//队列类型
（Q.front=Q.rear=（QueuePtr）malloc（sizeof（QNode））））exit（OVERFLOW）;
//如果首队列尾队列队列，申请空间储存结点，结束程序
Q.front->
next=NULL;
StatusEnQueue（LinkQueue&
Q,QElemTypee）
QueuePtrp;
（p=（QueuePtr）malloc（sizeof（QNode））））exit（OVERFLOW）;
p->
data=e;
Q.rear->
next=p;
Q.rear=p;
StatusDeQueue（LinkQueue&
Q,QElemType&
e）
if（Q.front==Q.rear）return0;
p=Q.front->
next;
e=p->
data;
next=p->
if（Q.rear==p）Q.rear=Q.front;
free（p）;
//二叉排序树
StatusInitDSTable（BiTree&
TREE1）//构造一棵树叫TREE1
TREE1=NULL;
BiTreeSearchBST（BiTreeT,StudentITREE1ypekey）//查找树里面的学号
{
T||EQ（key,T->
data.key））//比较输入的学号和树里面的学号
returnT;
elseifLT（key,T->
data.key）
returnSearchBST（T->
lchild,key）;
//如果相同返回树
else
rchild,key）;
StatusSearchBST（BiTree&
T,StudentITREE1ypekey,BiTreef,BiTree&
p）
T）
p=f;
return0;
}//如果非空，把f的值赋给p
elseifEQ（key,T->
p=T;
data.key）
lchild,key,T,p）;
rchild,key,T,p）;
}//不同就重复查找直到相同
StatusInsertBST（BiTree&
T,ElemTypee）//插入结点信息
BiTreep,s;
SearchBST（T,e.key,NULL,p））
s=（BiTree）malloc（sizeof（BiTNode））;
s->
//插入结点
lchild=s->
rchild=NULL;
//左右孩子指针等于空值
p）
T=s;
//若果非空树，s的值赋给T。
elseifLT（e.key,p->
lchild=s;
rchild=s;
}//如果e.key大于data.key，则插入左孩子指针，否则插入右孩子指针
//删除树
voidDelete（BiTree&
BiTreeq,s;
p->
rchild）
q=p;
p=p->
lchild;
free（q）;
}//如果，右孩子没有p，则在左孩子找p
elseif（!
lchild）
rchild;
}//如果左孩子没有p，则在右孩子中找。
else
s=p->
//把左孩子中p赋给s。
while（s->
q=s;
s=s->
}//循环直到右孩子不存在s。
data=s->
//把找到最后一个右孩子的值赋给p
//整段把树左边移到右边。
if（q!
=p）//如果q不等于p
q->
rchild=s->
//右孩子树移到左边
//否则s的值赋给q
free（s）;
StatusDeleteBST（BiTree&
T,StudentITREE1ypekey）//删除树
ifEQ（key,T->
Delete（T）;
DeleteBST（T->
}//循环找和删除。
intBiTreeDepth（BiTreeT）//树的深度
inti,j;
T）return0;
if（T->
lchild）
i=BiTreeDepth（T->
lchild）;
elsei=0;
rchild）
j=BiTreeDepth（T->
rchild）;
elsej=0;
returni>
j?
i+1:
j+1;
}//若左孩子存在，循环寻找直到左孩子不存在，找到树的深度，返回树的深度。
voidVisit（ElemTypee）//查看结点中学号
printf（"
%d->
"
e.key）;
//中序遍历
StatusInOrderTraverse（BiTreeT）
BiTreep;
SqStackS;
InitStack（S）;
Push（S,T）;
while（!
StackEmpty（S））
while（GetTop（S,p）&
&
p）Push（S,p->
Pop（S,p）;
{
Pop（S,p）;
Visit（p->
data）;
Push（S,p->
}
\n"
）;
//前序遍历
StatusPreOrderTraverse（BiTreeT）
//后序遍历
StatusPostOrderTraverse（BiTreeT）
SqStackR;
BiTreer;
InitStack（S）;
InitStack（R）;
Push（S,T）;
if（!
StackEmpty（R））GetTop（R,r）;
if（GetTop（S,p）&
rchild&
p!
=r）
{
Push（S,p->
Push（R,p）;
}
else
Pop（S,p）;
Visit（p->
if（r==p）Pop（R,r）;
p=NULL;
Push（S,p）;
voidShowTree（BiTreeT）//层次遍历法显示树
LinkQueueq;
BiTrees;
intd,t,i,n,num;
d=t=i=n=0;
num=1;
d=BiTreeDepth（T）;
if（T）
InitQueue（q）;
EnQueue（q,T）;
while（num<
=（pow（2,d）-1））
if（num==pow（2,i））
printf（"
i++;
t=0;
n=（int）pow（2,d-i+t）;
for（intx=1;
x<
=n-1;
x++）printf（"
"
t=1;
DeQueue（q,s）;
if（s==NULL）{printf（"
num++;
else{printf（"
%d"
s->
data.key）;
if（s&
s->
lchild）EnQueue（q,s->
elseEnQueue（q,NULL）;
rchild）EnQueue（q,s->
intShowTree2（BiTreeT,intn）//递归法显示树
inti;
if（T==NULL）return1;
ShowTree2（T->
rchild,n+1）;
for（i=0;
i<
n;
i++）printf（"
%d\n"
T->
lchild,n+1）;
intmain（）
BiTreeTREE1,p=NULL;
charname[10];
intscore;
ElemTypee;
printf（"
[1]:
BuildtheBinarySortTree[2]:
InserttheNodes[3]:
DeleteNodes[4]:
preOrderTraverse,InOrderTraverse,postOrderTraverse[5]:
build50Nodesandtesttheefficiency\n"
while（true）{
charchoise;
scanf（"
%c"
&
choise）;
if（choise=='
q'
）break;
switch（choise）{
case'
[1]'
:
InitDSTable（TREE1）;
\n\n\n\PleaseinsertthenumberoftheNodesyouwant：
（x）"
intN1;
N1）;
pleaseinsert：
\n\nKeyStudent’snamescore\n"
）
for（inti=0;
=N1-1;
i++）
{
scanf（"
%d%s%d"
e.key,e.name,&
e.score）;
InsertBST（TREE1,e）;
}
thebinarytreeisshownasfollow：
\n\n"
ShowTree（TREE1）;
break;
[2]'
pleasetypeintheDataas：
\n\nStudentIDStudent’sNameStudent’sscore\n"
scanf（"
p=SearchBST（TREE1,e.key）;
if（p）
printf（"
youcannotrepeattheKey\n"
else{
InsertBST（TREE1,e）;
c'
PleaseinserttheS：
intN2;
N2）;
p=SearchBST（TREE1,N2）;
if（p）{
Deleted:
\nTheNUMBERSyouhavedeleteisasbelow\n"
%d%s%d\n"
p->
data.key,p->
data.name,p->
data.score）;
DeleteBST（TREE1,N2）;
[3]'
PreOrderTraverse：
PreOrderTraverse（TREE1）;
InOrderTraverse：
InOrderTraverse（TREE1）;
：
PostOrderTraverse\n"
PostOrderTraverse（TREE1）;
e'
structElemTyper[N]={{43,"
name"
43},{25,"
35},{48,"
48},{1,"
name6"
82},
{24,"
32},{9,"
85},{38,"
36},{28,"
36},{27,"
37},
{23,"
33},{12,"
12},{40,"
38},{13,"
13},{45,"
14},
{29,"
39},{35,"
35},{21,"
31},{30,"
38},{20,"
20},
{11,"
11},{31,"
31},{19,"
19},{32,"
32},{18,"
18},
{47,"
14},{8,"
name4"
80},{5,"
name8"
84},{4,"
name2"
78},{17,"
17},
{49,"
14},{34,"
32},{16,"
16},{15,"
15},{3,"
name7"
83},
{41,"
14},{36,"
34},{14,"
14},{2,"
name1"
4},{26,"
34},
{7,"
name9"
85},{39,"
39},{46,"
46},{10,"
name5"
81},{22,"
30},
{42,"
44},{33,"
33},{44,"
44},{6,"
name3"
79},{37,"
{50,"
50}};
N-1;
InsertBST（TREE1,r[i]）;
intn=10000000;
//总共查找次数
doublestart=clock（）;
//查找二叉排序树开始时间
i++）{
srand（i）;
//随循环设置随机种子
intrandnumber=rand（）%50;
//每一次给定一个0到50的随机数
p=SearchBST（TREE1,randnumber）;
//if（p）
//printf（"
doublefinish=clock（）;
//查找二叉排序树结束时间
doubletime=finish-start;
在二叉排序树里随机查找任意一个关键字%d次所需时间为：
%lf"
n,time）;
start=clock（）;
//查找数组开始时间
升级会员 