大题目Word文档格式.docx
《大题目Word文档格式.docx》由会员分享，可在线阅读，更多相关《大题目Word文档格式.docx（31页珍藏版）》请在冰豆网上搜索。
{S=（BiTNode*）malloc（sizeof（BitNode））;
S->
data.key=x;
lchild=NULL;
rchild=NULL;
Insert_BST（T,S）;
scanf（“%d”,&
53二叉排序树上的查找（动态查找）
intSearh_BST（BiTreeT,intkey）
{BiTreep,q,S,p=T;
if（p->
data.key==key）return
（1）;
elseif（p->
data.key>
key）{q=p;
p=p->
else{q=p;
S=（BiTNode*）malloc（sizeof（BitNode））;
data.key=key;
lchild=S->
rchild=NULL;
if（!
elseif（q->
key）q->
lchild=S;
rchild=S;
return（0）;
54二叉排序树的删除递归算法（算法9.7）
intDeleteBST（BiTree&
T,KeyTypekey）{
T）returnFALSE;
else{
if（EQ（key,T->
data.key））{returnDelete（T）;
}
elseif（LT（key,T->
data.key））returnDeleteBST（T->
lchild,key）;
elsereturnDeleteBST（T->
rchild,key）;
55定义线性链表的数据类型
typedefstructLNode{
ElemTypedata;
structLNode*next;
}LNode,*LinkList
56双向链表删除
StatusListDelete_Dul（DuLinkList&
L,inti,ElemType&
e）
{
（p=GetElemP_Dul（L,i）））returnERROR;
e=p->
data;
prior->
next=p->
next;
next->
prior=p->
prior;
free（p）;
returnOK
57双向链表的插入
StatusListInsert_Dul（DuLinkList&
L,inti,ElemTypee）
（s=（DuLinkList）malloc（sizeof（DuLNode））））returnERROR
s->
data=e;
prior=p->
next=s;
next=p;
prior=s;
58二叉链表的定义
typedefstructBiTNode{
TElemTypedata;
StructBiTNode*lchild,*rchild;
}BiTNode,*BiTree;
59需用到栈，顺序栈的定义如下：
typedefBiTNode*SElemType;
typedefstruct{
SElemType*base;
SElemType*top;
intstacksize;
}SqStack;
60二叉树结点个数
intSize（BiTreeT）
if（T==NULL）return0;
elsereturn1+Size（T->
lchild）+Size（T->
rchild）;
61按层次遍历二叉树的定义
typedefBiTNode*ElemType;
QElemType*base;
intfront,rear;
}SqQueue
62后继线索化——处理前驱结点
voidInThreading（BiThrTreeP）
{if（P）
{InThreading（P->
lchild）;
P->
rchild）P->
RTag=Thread;
if（pre&
pre->
RTag=Thread）pre->
rchild=P;
pre=P;
InThreading（P->
63前驱线索化——处理后继结点
{InThreading（P->
lchild）
{P->
LTag=Thread;
P->
lchild=pre;
64孩子兄弟表示法
typedefstructCSNode{
ElemTypedata;
structCSNode*firstchild,*nextsibling;
}CSNode,*CSTree;
65队列的定义
typedefstructQNode
{QElemTypedata;
structQNode*next;
}QNode,*QueuePtr;
Typedefstruct{
QueuePtrfront；
QueuePtrrear；
}LinkQueue；
66队列的删除
StatusDequeue（LinkQueue&
Q，QelemType&
e）{
If（Q.front==Q.rear）returnERROR；
P=Q.front->
e=p->
Q.front->
next=p->
next
If（Q.rear==p）Q.rear=q.front；
Free（P）；
RenturnOK;
1线形表的插入
intsxbcr（inti,intx,intv[],int*p）
intj,n;
n=*p;
if（（i<
1）||（i>
n+1））
return（0）;
else
{for（j=n;
j>
=i;
j--）
v[j]=v[j-1];
v[j]=x;
*p=++n;
return
（1）;
2线形表的删除
intsxbsc（inti,intv[],int*p）
n））
{for（j=i;
j<
n;
j++）
v[j-1]=v[j];
*p=--n;
3单链表的查找
LNode*dlbcz（LNode*L,intX）
{LNode*p;
p=L;
while（p!
=NULL&
&
data!
=X）
p=p->
return（p）;
4单链表的插入
voiddlbcr（LNode*p,intx）
{LNode*s;
s=（LNode*）malloc（sizeof（LNode））;
data=x;
5单链表的删除
voiddlbsc（LNode*p）
{LNode*q;
if（p->
next!
=NULL）
{q=p->
next=q->
free（q）;
LNode*dlbjl（inta[],intn）
LinkList*s,*h;
inti;
h=（LNode*）malloc（sizeof（LNode））;
h->
data=0;
next=NULL;
for（i=n;
i>
0;
i--）
{s=（LNode*）malloc（sizeof（LNode））;
data=a[i-1];
next=h->
return（h）;
6入栈
intpush（SqStack&
S,SElemTypee）
//插入元素e为新的棧顶元素
if（S.top-S.base>
=S.stacksize）
{
S.base=（ElemType*）realloc（S.base,（S.stacksize+STACKINCREAMENT）*sizeof（ElemType））;
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREAMENT;
*S.top++=e;
returnOK;
7出栈
intPop（SqStack&
S,SElemType&
if（S.top==S.base）returnERROR;
e=*--S.top;
8链栈的入栈
QNode*lzjz（QNode*top,intx）
{QNode*p;
p=（QNode*）malloc（sizeof（QNode））;
next=top;
top=p;
return（p）;
9链栈的出栈
JD*lztz（JD*top,int*p）
{JD*q;
if（top!
{q=top;
*p=top->
top=top->
link;
return（top）;
10汉诺塔
/*Hanoi.txt*/
main（）
{intm;
printf（"
Inputthenumberofdisks:
"
）;
scanf（"
%d"
&
m）;
Thestepstomoving%3ddisks:
\n"
m）;
hanoi（m,'
A'
'
B'
C'
（0）}
voidhanoi（intn,charx,chary,charz）
（1）{
（2）if（n==1）
（3）move（1,x,z）;
（4）else{
（5）hanoi（n-1,x,z,y）;
（6）move（n,x,z）;
（7）hanoi（n-1,y,x,z）;
（8）}
（9）}
voidmove（inth,charc,charf）
%d:
%c--->
%c\n"
h,c,f）;
11入队
QNode*dlcr（QNode*rear,intx）
rear->
12出队
intdlsc（QNode*front,QNode*rear）
{QNode*s;
intx;
if（front==rear）
return（-1）;
s=front->
front->
next=s->
if（s->
next==NULL）
rear=front;
x=s->
free（s）;
return（x）;
13划分子集
voiddivision（intr[][N],intn,intcq[],
intnewr[],intresult[]）
{intk,i,pre,group;
for（k=0;
k<
k++）
cq[k]=k+1;
front=n-1;
rear=n-1;
newr[k]=0;
group=1;
pre=0;
do{front=（front+1）%n;
i=cq[front];
if（i<
pre）
{group++;
result[i-1]=group;
newr[k]=r[i-1][k];
elseif（newr[i-1]!
=0）
{rear=（rear+1）%n;
cq[rear]=i;
{result[i-1]=group;
newr[k]=newr[k]+r[i-1][k];
pre=i;
}while（rear!
=front）;
14先序遍历二叉树的递归算法
voidPreOrderTraverse（BiTreeT）{
if（T）{
printf（"
%c"
T->
data）;
PreOrderTraverse（T->
15中序遍历二叉树的递归算法
voidInOrderTraverse（BiTreeT）{
if（T）{
InOrderTraverse（T->
16后序遍历二叉树的递归算法
voidPostOrderTraverse（BiTreeT）{
PostOrderTraverse（T->
17先序遍历的非递归算法
voidpreorder（BiTreeT）
{SqStackS;
BiTreeP=T;
InitStack（S）;
Push（S,NULL）;
while（P）
{printf（"
P->
if（P->
rchild）
Push（S,P->
P=P->
elsePop（S,P）;
18中序遍历的非递归算法1
voidinorder（BiTreeT）{
SqStackS;
do{while（P）{
*（S.top）=P;
S.top++;
if（S.top）{
S.top--;
P=*（S.top）;
printf（"
}while（（S.top!
=S.base）||P）;
19后序遍历的非递归算法1
voidPostorder（BiTreeT）
{BiTreep=T,q=NULL;
Push（S,p）;
while（!
StackEmpty（S））
{if（p&
p!
=q）{Push（S,p）;
else{Pop（S,p）;
if（p->
rchild&
rchild!
=q）
{Push（S,p）;
else{printf（"
p->
q=p;
20先序建立二叉树的递归算法（p131,算法6.4）
StatusCreateBiTree（BiTree&
T）
{charch;
ch）;
if（ch=='
'
）T=NULL;
else{if（!
（T=（BiTNode*）malloc（sizeof（BiTNode））））exit（OVERFLOW）;
T->
data=ch;
CreateBiTree（T->
21二叉树的显示输出
voidPrintBiTree（BiTreeT,intn）
charch='
;
PrintBiTree（T->
rchild,n+1）;
for（i=1;
i<
=n;
++i）{printf（"
%5c"
ch）;
T->
lchild,n+1）;
22利用二叉树后序遍历计算二叉树的深度
intDepth（BiTreeT）{
intdepl,depr;
depl=Depth（T->
depr=Depth（T->
if（depl>
=depr）return（depl+1）;
elsereturn（depr+1）;
}
23求二叉树结点个数
24按层次遍历二叉树
voidLevelOrderTraverse（BiTreeT）
{BiTreep;
SqQueueQ;
InitQueue（Q）;
if（T）{Q.base[Q.rear]=T;
Q.rear=（Q.rear+1）%MAXQSIZE;
while（Q.front!
=Q.rear）
{p=Q.base[Q.front];
Q.front=（Q.front+1）%MAXQSIZE;
if（p->
{Q.base[Q.rear]=p->
Q.rear=（Q.rear+1）%MAXQSIZE;
}}}}
25左右子树互换
voidExchange（BiTree&
S=T->
T->
lchild=T->
Exchange（T->
26复制二叉树
voidCopyTree（BiTreeT,BiTree&
T1）
{if（T）
{T1=（BiTree）malloc（sizeof（BiTNode））;
T1）{printf（"
Overflow\n"
exit
（1）;
T1->
data=T->
lchild=T1->
升级会员 