举例.docx
《举例.docx》由会员分享，可在线阅读，更多相关《举例.docx（39页珍藏版）》请在冰豆网上搜索。
举例
目录
一、使用第二种存储结构求广义表的深度2
二、使用第二种存储结构复制广义表2
三、使用第二种存储结构建立广义表2
四、已知单链表的数据域为整型，试将其分解为奇数和偶数两个单链表3
五、将不带头结点的单链表置逆4
六、求两个集合的交集5
七、在顺序表的某个位置插入一个元素：
5
八、输出单链表各结点的值：
6
九、两个一元多项式相加：
6
十、从键盘上输入n个数，正向建立单链表：
8
十一、从键盘上输入n个数，反向建立单链表：
9
十二、链栈的入栈、出栈操作：
9
十三、顺序栈的入栈、出栈操作：
10
十四、复制一个带头结点的单链表：
10
十五、复制一个不带头结点的单链表：
11
十六、一元多项式乘法：
12
十七、复制一棵二叉链表表示的二叉树：
13
十八、二叉树结点的值为整数，求各结点值之和：
13
十九、二叉树结点的值为整数，求最大值结点的指针：
13
二十、二叉树结点的值为整数，求正、负整数结点值之和的积：
14
二十一、前序遍历输出二叉树各结点的层次及值：
14
二十二、求二叉树的高及一条等于高的路径：
15
二十三、求二叉树的高：
16
二十四、二叉树结点的值为整数，求叶子结点值之和：
16
二十五、判断两棵二叉树是否相似（相等）：
16
二十六、求二叉树中两结点p和q的最近的共同祖先：
17
二十七、判断一棵二叉树是否是完全二叉树：
18
二十八、判断一棵二叉树是否是排序二叉树：
19
二十九、将不带头结点的单链表逆转：
19
三十、将不带头结点的双向链表逆转：
20
三十一、求元素x在矩阵中的下标，不存在返回（0，0）：
21
三十二、已知矩阵从上到下、从左到右元素值从小到大，元素x存在于矩阵中，要求比较次数不大于m+n次，求其下标：
21
三十三、在二叉树的二叉链表中增设一个指向父母结点的指针和一个标志位（初值为0），其取值范围为0、1、2，不使用堆栈也不用递归，后序遍历该二叉树，试给出算法：
22
三十四、在二叉树的二叉链表中增设一个标志位（初值为0），其取值范围为0、1、2，不使用堆栈也不用递归，后序遍历该二叉树，试给出算法：
22
三十五、试给出算法判断一棵树是否为二叉排序树：
23
三十六、试给出算法判断一棵树是否为平衡二叉树：
24
三十七、已知待排序列用单链表表示，试给出直接插入排序算法：
24
三十八、已知待排序列用单链表表示，试给出快速排序算法：
25
三十九、n=7,e=1026
四十、编程实现将以孩子-兄弟链表示的树用广义表的形式输出：
27
四十一、求集合的幂集28
四十二、在二叉链表中增加一个子孙数目域Cnum，计算各结点的子孙数目:
29
四十三、将用孩子兄弟链表示的树按以下格式输出：
30
四十四、约瑟夫问题33
四十五、中缀表达式变后缀表达式33
四十六、字符分类：
三种字符重排为字母、数字和其它字符33
四十七、已知二叉链表表示的二叉树结点数据类型为大写字母，从键盘输入前序遍历序列（无孩子用字符0表示），建立该二叉树。
34
四十八、二叉排序树的查找。
35
一、使用第二种存储结构求广义表的深度
intGListDepth（GListL）
{
if（!
L）return0;
if（L->tag==ATOM）return0;
for（max=0,pp=L->hp;pp;pp=pp->tp）
{
dep=GListDepth（pp）;
if（dep>max）max=dep;
}
returnmax+1;
}
二、使用第二种存储结构复制广义表
StatusCopyGList（GList&T,GListL）
{
if（!
L）T=NULL;else
{
if（!
（T=newGLNode））exit（OVERFLOW）;
T->tag=L->tag;
if（l->tag==ATOM）T->atom=L->atom;
elseCopyGList（T->hp,L->hp）;
CopyGList（T->tp,L->tp）;
}
}
三、使用第二种存储结构建立广义表
StatusCreateGList（GList&L,SStringS）
{
if（StrEmpty（S））L=NULL;else
{
if（!
（L=newGLNode））exit（OVERFLOW）;
if（StrLength（S）==1）
{
L->tag=ATOM;L->atom=S;
}else
{
L->tag=LIST;
SubString（sub,S,2,StrLength（S）-2）;
sever（sub,hsub）;
CreateGList（L->hp,hsub）;p=L->hp;
while（!
StrEmpty（sub））
{
sever（sub,hsub）;
CreateGList（p->tp,hsub）;p=p->tp;
}
}
L->tp=NULL;
}
}
四、已知单链表的数据域为整型，试将其分解为奇数和偶数两个单链表
voidsep（linkedlistL,linkedlist&A,linkedlist&B）
{
A=B=NULL;
while（L）
{
H=L;
L=L->next;
if（H->data%2）
{
H->next=A;
A=H;
}else
{
H->next=B;
B=H;
}
}
}
五、将不带头结点的单链表置逆
linkedlistrever（linkedlistL）
{
H=NULL;
while（L）
{
P=L;L=L->next;
P->next=H;H=P;
}
returnH;
}
六、求两个集合的交集
linkedlistintersection（linkedlist&La,linkedlist&Lb）
{
pa=La->next;pb=Lb->next;
Lc=pc=newlnode;
while（pa&&pb）
if（pa->data>pb->data）pb=pb->next;else
if（pa->datadata）pa=pa->next;else
{
ltemp=newlnode;
ltemp->data=pa->data;
pc->next=ltemp;pc=ltemp;
pa=pa->next;pb=pb->next;
}
pc->next=NULL;returnLc
}
七、在顺序表的某个位置插入一个元素：
voidinsert（sqlist&L,inti,elemtypee）
{
for（j=L.listsize;j>i;j--）L.elem[j+1]=L.elem[j];
L.elem[i+1]=e;
L.listsize++;
}
intinsert（sqlist&L,inti,elemtypee）
{
if（L.listsize==L.MAXLEN）return1;
for（j=L.listsize;j>i;j--）L.elem[j+1]=L.elem[j];
L.elem[i+1]=e;
L.listsize++;
return0;
}
八、输出单链表各结点的值：
voidoutput（linkedlistL）
{
while（L）
{
cout<data<<‘’;
L=L->next;
}
cout<}
九、两个一元多项式相加：
voidadd（linkedlistA,linkedlistB,linkedlist&C）
{
p=C=newstructlnode;
while（A&&B）
{
if（A->exp>B->exp）
{
p->next=newstructlnode;
p=p->next;
p->coef=A->coef;
p->exp=A->exp;
A=A->next;
}else
if（A->expexp）
{
p->next=newstructlnode;
p=p->next;
p->coef=B->coef;
p->exp=B->exp;
B=B->next;
}else
{
co=A->coef+B->coef;
if（co）
{
p->next=newstructlnode;
p=p->next;
p->coef=co;
p->exp=B->exp;
}
A=A->next;
B=B->next;
}
}
while（A）
{
p->next=newstructlnode;
p=p->next;
p->coef=A->coef;
p->exp=A->exp;
A=A->next;
}
while（B）
{
p->next=newstructlnode;
p=p->next;
p->coef=B->coef;
p->exp=B->exp;
B=B->next;
}
p->next=NULL;
p=C;
C=C->next;
deletep;
}
十、从键盘上输入n个数，正向建立单链表：
linkedlistcreate（intn）
{
linkedlisthead,p1,p2;
head=NULL;
for（;n;n--）
{
p1=（linkedlist）malloc（sizeof（lnode））;
if（!
head）head=p1;elsep2->next=p1;
cin>>p1->data;
p2=p1;
}
p2->next=NULL;
return（head）;
}
十一、从键盘上输入n个数，反向建立单链表：
linkedlistcreate（intn）
{
linkedlisthead,p;
head=NULL;
for（;n;n--）
{
p=newstructlnode;
p->next=head;
cin>>p->data;
head=p;
}
returnhead;
}
十二、链栈的入栈、出栈操作：
voidPush（linkedstack&top,elemtypee）
{
linkedstackp=newstructlnode;
p->data=e;
p->next=top;
top=p;
}
voidPop（linkedstack&top,elemtype&e）
{
linkedstackp=top；
e=p->data;
top=p->next;
deletep;
}
十三、顺序栈的入栈、出栈操作：
voidPush（sqstacks,int&top,elemtypee）
{
s[top++]=e;
}
voidPop（sqstacks,int&top,elemtype&e）
{
e=s[--top];
}
十四、复制一个带头结点的单链表：
listCopylist（listA）
{H=r=newnode;p=A->next;
while（p）
{r->next=newnode;r=r->next;
r->coef=p->coef;r->exp=p->exp;
p=p->next;
}
r->next=NULL;
returnH;
}
或
listCopylist（listA）
{
if（!
A）returnNULL;
p=newlnode;
p->coef=A->coef;p->exp=A->exp;
p->next=Copylist（A->next）;
returnp;
}
十五、复制一个不带头结点的单链表：
listCopylist（listA）
{H=r=newnode;p=A;
while（p）
{r->next=newnode;r=r->next;
r->coef=p->coef;r->exp=p->exp;
p=p->next;
}
r->next=NULL;
r=H；
H=H->next;
Deleter;
returnH;
}
或
listCopylist（listA）
{H=NULL;p=A;
while（p）
{r=newnode;
r->coef=p->coef;r->exp=p->exp;
if（!
H）H=r;elseq->next=r;
q=r;
p=p->next;
}
r->next=NULL;
returnH;
}
或
listCopylist（listA）
{
If（!
A）returnNULL;
H=newnode;
H->coef=A->coef;
H->exp=A->exp;
H->next=Copylist（A->next）;
returnH;
}
十六、一元多项式乘法：
voidPolyMul（listA,listB,list&C）
{
C=newnode;C->next=NULL;q=B->next;
while（q）
{
p=Copylist（A）;r=p->next;
while（r）
{
r->exp+=q->exp;
r->coef*=q->coef;
r=r->next;
}
AddPloyn（C,p）;
q=q->next;
}
}
十七、复制一棵二叉链表表示的二叉树：
voidCopytree（bitptrt,bitptr&nt）
{
if（!
t）nt=NULL;else
{
nt=newnode;
nt->data=t->data;
Copytree（t->lc,nt->lc）;
Copytree（t->rc,nt->rc）;
}
}
十八、二叉树结点的值为整数，求各结点值之和：
intSum（bitptrt）
{
if（!
t）return0;
returnt->data+Sum（t->lc）+Sum（t->rc）;
}
十九、二叉树结点的值为整数，求最大值结点的指针：
voidporder（bitptrt,bitptr&mt）
{
if（t）
{
if（t->data>mt->data）mt=t;
porder（t->lchild,mt）;
porder（t->rchild,mt）;
}
}
voidmax（bitptrt,bitprt&maxt）
//bitptrmax（bitptrt）
{
maxt=t;
porder（t,maxt）;
//returnmaxt;
}
二十、二叉树结点的值为整数，求正、负整数结点值之和的积：
voidvisit（bitptrt,int&m,int&n）
{
if（t）
{
if（t->data>0）m+=t->data;else
n+=t->data;
visit（t->lc,m,n）;
visit（t->rc,m,n）;
}
}
intMul（bitptrt）
{
m=n=0;
visit（t,m,n）;
returnm*n;
}
二十一、前序遍历输出二叉树各结点的层次及值：
voidOutTree（bitptrt,intn）//n的初值为1
{
if（t）
{
cout<’<data<<’’;
OutTree（t->lc,n+1）;
OutTree（t->rc,n+1）;
}
}
二十二、求二叉树的高及一条等于高的路径：
voidhigh（bitptrt,intlevel,int&hi）
//level初值为1，hi初值为0
{
if（t）
{
if（level>hi）hi=level;
high（t->lchild,level+1,hi）;
high（t->rchild,level+1,hi）;
}
}
voidGetHigh（bitptrt,intn,int&high,arp,ar&path）
//n的初值为1,high的初值为0
{
if（t）{
p[n]=t->data;
if（highhigh=n;
for（i=1;i<=n;i++）path[i]=p[i];
}
GetHigh（t->lc,n+1,high,p,path）;
GetHigh（t->rc,n+1,high,p,path）;
}
}
二十三、求二叉树的高：
intGetHigh（bitptrt）
{
if（!
t）return0;
returnMax（GetHigh（t->lc）,GetHigh（t->rc））+1
}
二十四、二叉树结点的值为整数，求叶子结点值之和：
intSum（bitptrt）
{
if（!
t）return0;else
if（!
t->lc&&!
t->rc）returnt->data;else
returnSum（t->lc）+Sum（t->rc）;
}
二十五、判断两棵二叉树是否相似（相等）：
intsimilartree（bitptrt1,bitptrt2）
{
if（!
t1&&!
t2）return1;
if（t1&&!
t2||!
t1&&t2）return0;
returnsimilartree（t1->lc,t2->lc）&&
similartree（t1->rc,t2->rc）;
}
intequaltree（bitptrt1,bitptrt2）
{
if（!
t1&&!
t2）return1;
if（t1&&!
t2||!
t1&&t2）return0;
return（t1->data==t2->data）&&
equaltree（t1->lc,t2->lc）&&
equaltree（t1->rc,t2->rc）;
}
二十六、求二叉树中两结点p和q的最近的共同祖先：
bitptrForefather（bitptrt,bitptrp,bitptrq）
{
Fft=NULL;
Fpost（t,p,q,Fft）;
returnFft;
}
intFpost（bitptrt,bitptrq,bitptrq,bitptr&Fft）
{
if（!
t||Fft）return0;
d=Fpost（t->lc,p,q,Fft）+Fpost（t->rc,p,q,Fft）;
if（d==2）if（!
Fft）Fft=t;
if（t==p||t==q）returnd+1;elsereturnd;
}
二十七、判断一棵二叉树是否是完全二叉树：
intComptree（bitptrt）
{
Init（Q）;if（t）Enqueue（Q,t）;f=0;
while（!
Empty（Q））
{
p=Dequeue（Q）;
if（!
f）if（p->lc）Enqueue（Q,p->lc）;
elsef=1;elseif（p->lc）return0;
if（!
f）if（p->rc）Enqueue（Q,p->rc）;
elsef=1;elseif（p->rc）return0;
}
return1;
}
或
intComptree（bitptrt）
{
Init（Q）;if（t）Enqueue（Q,（t,1））;m=n=0;
while（!
Empty（Q））
{
（p,m）=Dequeue（Q）;n++;
if（p->lc）Enqueue（Q,（p->lc,m*2））;
if（p->rc）Enqueue（Q,（p->rc,m*2+1））;
}
if（m==n）return1;elsereturn0;
}
二十八、判断一棵二叉树是否是排序二叉树：
voidbst1（bitptrt,bitptrp,int&isbst）
{
if（t&&isbst）
{
bst1（t->lc,p,isbst）;
if（p）if（p->data>t->data）isbst=0;
p=t;
bst1（t->rc,p,isbst）;
}
}
intbst（bitptrt）
{
p=NULL;isbst=1;
bst1（t,p,isbst）;
returnisbst;
}
二十九、将不带头结点的单链表逆转：
voidReverse（linkedlist&H）
{
q=NULL;
while（H）
{
p=H;
H=H->next;
p->next=q;
q=p;
}
H=p;
}
三十、将不带头结点的双向链表逆转：
voidReverse（linkedlist&H）
{
while（H）
{
p=H->next;
H->next=H->pre;
H->pre=p;
p=H;
升级会员 