大题目.docx
《大题目.docx》由会员分享，可在线阅读，更多相关《大题目.docx（31页珍藏版）》请在冰豆网上搜索。
大题目
50//折半查找51二叉排序树中的算法52构造二叉排序树的算法53二叉排序树上的查找（动态查找）54二叉排序树的删除递归算法55定义线性链表的数据类型56双向链表删除57双向链表的插入58二叉链表的定义59需用到栈，顺序栈的定义如下60二叉树结点个数61按层次遍历二叉树的定义62后继线索化——处理前驱结点63前驱线索化——处理后继结点64孩子兄弟表示法65队列的定义66队列的删除
1线形表的插入2线形表的删除3单链表的查找4单链表的插入5单链表的删除6入栈7出栈8链栈的入栈9链栈的出栈10汉诺塔11入队12出队13划分子集14先序遍历二叉树的递归算法15中序遍历二叉树的递归算法16后序遍历二叉树的递归算法17先序遍历的非递归算法18中序遍历的非递归算法19后序遍历的非递归算法20先序建立二叉树的递归算法21二叉树的显示输出22利用二叉树后序遍历计算二叉树的深度23求二叉树结点个数24按层次遍历二叉树25左右子树互换26复制二叉树27线索二叉树的存储表示28遍历中序线索二叉树29遍历先序线索二叉树30遍历后序线索二叉树（不带头结点）31通过中序遍历建立中序线索化二叉树32通过中序遍历建立中序线索化二叉树33中序线索化34先序线索化35后序线索化36建立赫夫曼树及求赫夫曼编码的算法37建立邻接矩阵38邻接表存储表示39网络（带权图）的邻接表41整个图的DFS遍历42图的广度优先搜索算法43利用普里姆算法建立最小生成树44拓扑排序的算法45利用关键路径法求AOE网的各关键活动49二叉排序树的数据类型描述
50//折半查找
intSearch_Bin（SSTableST,KeyTypekey）
{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;
}
51二叉排序树中的算法
voidInsert_BST（BiTree&T,BiTreeS）
{BiTreep,q;
if（!
T）T=S;
else{p=T;
while（p）
{q=p;
if（S->data.keydata.key）p=p->lchild;
elsep=p->rchild;
}
if（S->data.keydata.key）q->lchild=S;
elseq->rchild=S;
}
return;
}
52构造二叉排序树的算法
voidCreateBST（BiTree&T）
{intx;BiTreeS;T=NULL;
scanf（“%d”,&x）;
while（x!
=0）
{S=（BiTNode*）malloc（sizeof（BitNode））;
S->data.key=x;
S->lchild=NULL;
S->rchild=NULL;
Insert_BST（T,S）;
scanf（“%d”,&x）;
}
return;
}
53二叉排序树上的查找（动态查找）
intSearh_BST（BiTreeT,intkey）
{BiTreep,q,S,p=T;
while（p）
if（p->data.key==key）return
（1）;
elseif（p->data.key>key）{q=p;p=p->lchild;}
else{q=p;p=p->rchild;}
S=（BiTNode*）malloc（sizeof（BitNode））;
S->data.key=key;S->lchild=S->rchild=NULL;
if（!
T）T=S;
elseif（q->data.key>key）q->lchild=S;
elseq->rchild=S;
return（0）;
}
54二叉排序树的删除递归算法（算法9.7）
intDeleteBST（BiTree&T,KeyTypekey）{
if（!
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）
{
if（!
（p=GetElemP_Dul（L,i）））returnERROR;
e=p->data;
p->prior->next=p->next;
p->next->prior=p->prior;
free（p）;
returnOK
}
57双向链表的插入
StatusListInsert_Dul（DuLinkList&L,inti,ElemTypee）
{
if（!
（p=GetElemP_Dul（L,i）））returnERROR;
if（!
（s=（DuLinkList）malloc（sizeof（DuLNode））））returnERROR
s->data=e;
s->prior=p->prior;p->prior->next=s;
s->next=p;
p->prior=s;
returnOK
}
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;
typedefstruct{
QElemType*base;
intfront,rear;
}SqQueue
62后继线索化——处理前驱结点
voidInThreading（BiThrTreeP）
{if（P）
{InThreading（P->lchild）;
if（!
P->rchild）P->RTag=Thread;
if（pre&pre->RTag=Thread）pre->rchild=P;
pre=P;
InThreading（P->rchild）;
}
}
63前驱线索化——处理后继结点
voidInThreading（BiThrTreeP）
{if（P）
{InThreading（P->lchild）;
if（!
P->lchild）
{P->LTag=Thread;P->lchild=pre;}
pre=P;
InThreading（P->rchild）;
}
}
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->next;
e=p->data;
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）
{
intj,n;
n=*p;
if（（i<1）||（i>n））
return（0）;
else
{for（j=i;jv[j-1]=v[j];
*p=--n;
return
（1）;
}
}
3单链表的查找
LNode*dlbcz（LNode*L,intX）
{LNode*p;
p=L;
while（p!
=NULL&&p->data!
=X）
p=p->next;
return（p）;
}
4单链表的插入
voiddlbcr（LNode*p,intx）
{LNode*s;
s=（LNode*）malloc（sizeof（LNode））;
s->data=x;
s->next=p->next;
p->next=s;
5单链表的删除
voiddlbsc（LNode*p）
{LNode*q;
if（p->next!
=NULL）
{q=p->next;
p->next=q->next;
free（q）;
}
}
}
LNode*dlbjl（inta[],intn）
{
LinkList*s,*h;
inti;
h=（LNode*）malloc（sizeof（LNode））;
h->data=0;
h->next=NULL;
for（i=n;i>0;i--）
{s=（LNode*）malloc（sizeof（LNode））;
s->data=a[i-1];
s->next=h->next;
h->next=s;
}
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））;
if（!
S.base）exit（OVERFLOW）;
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREAMENT;
}
*S.top++=e;
returnOK;
}
7出栈
intPop（SqStack&S,SElemType&e）
{
if（S.top==S.base）returnERROR;
e=*--S.top;
returnOK;
}
8链栈的入栈
QNode*lzjz（QNode*top,intx）
{QNode*p;
p=（QNode*）malloc（sizeof（QNode））;
p->data=x;
p->next=top;
top=p;
return（p）;
}
9链栈的出栈
JD*lztz（JD*top,int*p）
{JD*q;
if（top!
=NULL）
{q=top;
*p=top->data;
top=top->link;
free（q）;
}
return（top）;
}
10汉诺塔
/*Hanoi.txt*/
main（）
{intm;
printf（"Inputthenumberofdisks:
"）;
scanf（"%d",&m）;
printf（"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）
{
printf（"%d:
%c--->%c\n",h,c,f）;
}
11入队
QNode*dlcr（QNode*rear,intx）
{QNode*p;
p=（QNode*）malloc（sizeof（QNode））;
p->data=x;
p->next=NULL;
rear->next=p;
return（p）;
}
12出队
intdlsc（QNode*front,QNode*rear）
{QNode*s;
intx;
if（front==rear）
return（-1）;
s=front->next;
front->next=s->next;
if（s->next==NULL）
rear=front;
x=s->data;
free（s）;
return（x）;
}
13划分子集
voiddivision（intr[][N],intn,intcq[],
intnewr[],intresult[]）
{intk,i,pre,group;
for（k=0;kcq[k]=k+1;
front=n-1;
rear=n-1;
for（k=0;knewr[k]=0;
group=1;
pre=0;
do{front=（front+1）%n;
i=cq[front];
if（i{group++;
result[i-1]=group;
for（k=0;knewr[k]=r[i-1][k];
}
elseif（newr[i-1]!
=0）
{rear=（rear+1）%n;
cq[rear]=i;
}
else
{result[i-1]=group;
for（k=0;knewr[k]=newr[k]+r[i-1][k];
}
pre=i;
}while（rear!
=front）;
}
14先序遍历二叉树的递归算法
voidPreOrderTraverse（BiTreeT）{
if（T）{
printf（"%c",T->data）;
PreOrderTraverse（T->lchild）;
PreOrderTraverse（T->rchild）;
}
}
15中序遍历二叉树的递归算法
voidInOrderTraverse（BiTreeT）{
if（T）{
InOrderTraverse（T->lchild）;
printf（"%c",T->data）;
InOrderTraverse（T->rchild）;
}
}
16后序遍历二叉树的递归算法
voidPostOrderTraverse（BiTreeT）{
if（T）{
PostOrderTraverse（T->lchild）;
PostOrderTraverse（T->rchild）;
printf（"%c",T->data）;
}
}
17先序遍历的非递归算法
voidpreorder（BiTreeT）
{SqStackS;BiTreeP=T;
InitStack（S）;Push（S,NULL）;
while（P）
{printf（"%c",P->data）;
if（P->rchild）
Push（S,P->rchild）;
if（P->lchild）
P=P->lchild;
elsePop（S,P）;
}
}
18中序遍历的非递归算法1
voidinorder（BiTreeT）{
SqStackS;BiTreeP=T;
InitStack（S）;
do{while（P）{
*（S.top）=P;S.top++;
P=P->lchild;}
if（S.top）{
S.top--;P=*（S.top）;
printf（"%c",P->data）;
P=P->rchild;}
}while（（S.top!
=S.base）||P）;
}
19后序遍历的非递归算法1
voidPostorder（BiTreeT）
{BiTreep=T,q=NULL;
SqStackS;InitStack（S）;Push（S,p）;
while（!
StackEmpty（S））
{if（p&&p!
=q）{Push（S,p）;p=p->lchild;}
else{Pop（S,p）;
if（!
StackEmpty（S））
if（p->rchild&&p->rchild!
=q）
{Push（S,p）;p=p->rchild;}
else{printf（"%c",p->data）;q=p;}
}
}
}
20先序建立二叉树的递归算法（p131,算法6.4）
StatusCreateBiTree（BiTree&T）
{charch;scanf（"%c",&ch）;
if（ch==''）T=NULL;
else{if（!
（T=（BiTNode*）malloc（sizeof（BiTNode））））exit（OVERFLOW）;
T->data=ch;
CreateBiTree（T->lchild）;
CreateBiTree（T->rchild）;
}
returnOK;
}
21二叉树的显示输出
voidPrintBiTree（BiTreeT,intn）
{
inti;charch='';
if（T）{
PrintBiTree（T->rchild,n+1）;
for（i=1;i<=n;++i）{printf（"%5c",ch）;}
printf（"%c\n",T->data）;
PrintBiTree（T->lchild,n+1）;
}
}
22利用二叉树后序遍历计算二叉树的深度
intDepth（BiTreeT）{
intdepl,depr;
if（T）{
depl=Depth（T->lchild）;
depr=Depth（T->rchild）;
if（depl>=depr）return（depl+1）;
elsereturn（depr+1）;
}
return0;
}
23求二叉树结点个数
intSize（BiTreeT）
{
if（T==NULL）return0;
elsereturn1+Size（T->lchild）+Size（T->rchild）;
}
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];
printf（"%c",p->data）;
Q.front=（Q.front+1）%MAXQSIZE;
if（p->lchild）
{Q.base[Q.rear]=p->lchild;
Q.rear=（Q.rear+1）%MAXQSIZE;}
if（p->rchild）
{Q.base[Q.rear]=p->rchild;
Q.rear=（Q.rear+1）%MAXQSIZE;}}}}
25左右子树互换
voidExchange（BiTree&T）
{
BiTreeS;
if（T）{
S=T->lchild;
T->lchild=T->rchild;
T->rchild=S;
Exchange（T->lchild）;
Exchange（T->rchild）;
}
}
26复制二叉树
voidCopyTree（BiTreeT,BiTree&T1）
{if（T）
{T1=（BiTree）malloc（sizeof（BiTNode））;
if（!
T1）{printf（"Overflow\n"）;exit
（1）;}
T1->data=T->data;
T1->lchild=T1->rchild=NULL;
升级会员 