数据结构源程序Word文件下载.docx
《数据结构源程序Word文件下载.docx》由会员分享，可在线阅读，更多相关《数据结构源程序Word文件下载.docx（49页珍藏版）》请在冰点文库上搜索。
=T[2]）?
T[0]:
T[2]）:
（（T[1]>
T[1]:
T[2]）;
intmin（tripletT,elemtype&
e=（T[0]<
（（T[0]<
（（T[1]<
main（）
tripletT;
intv1,v2,v3,i,e;
printf（"
pleasev1v2v3\n"
）;
scanf（"
%d%d%d"
&
v1,&
v2,&
v3）;
if（inittriplet（T,v1,v2,v3）&
max（T,e））
printf（"
%d"
e）;
第二章线性表
程序2（线性表的顺序实现）
#definelist_size100
#definelistincrement10
typedefstruct
{elemtype*elem;
intlength;
intlistsize;
}sqlist;
voidinitlist（sqlist&
L）
L.elem=（elemtype*）malloc（list_size*sizeof（elemtype））;
if（!
L.elem）exit（-2）;
L.length=0;
L.listsize=list_size;
voidcreatelist（sqlist&
inti,m;
pleaseinputm!
\n"
scanf（"
m）;
for（i=0;
i<
m;
i++）{scanf（"
L.elem[i]）;
L.length++;
intlocateelem（sqlistL,inte）
{inti;
L.length;
i++）
if（L.elem[i]==e）return1;
return0;
voidlistinsert（sqlist&
L,inti,inte）
{elemtype*newbase;
intj;
if（i<
L.length+1）{printf（"
errror"
exit（-2）;
if（L.length>
=L.listsize）{newbase=（elemtype*）realloc（L.elem,（L.listsize+listincrement）*sizeof（elemtype））;
newbase）exit（-2）;
L.elem=newbase;
L.listsize+=L.listsize+listincrement;
for（j=L.length-1;
j>
=i-1;
j--）L.elem[j+1]=L.elem[j];
L.elem[i-1]=e;
voidlistdelete（sqlist&
L,inti）
3）{printf（"
error"
for（j=i-1;
j<
j++）L.elem[j]=L.elem[j+1];
L.length--;
voidoutputlist（sqlistL）
inti;
i++）printf（"
%d"
L.elem[i]）;
voidgetelem（sqlistL,inti,elemtype&
x）
L.length）{printf（"
error!
x=L.elem[i-1];
voidmergelist（sqlistLa,sqlistLb,sqlist&
Lc）
inti,j,k,x,y;
initlist（Lc）;
i=1;
j=1;
k=0;
while（（i<
=La.length）&
（j<
=Lb.length））
{
getelem（La,i,x）;
getelem（Lb,j,y）;
if（x<
=y）{listinsert（Lc,++k,x）;
++i;
else{listinsert（Lc,++k,y）;
++j;
}
while（i<
=La.length）{getelem（La,i++,x）;
listinsert（Lc,++k,x）;
while（j<
=Lb.length）{getelem（Lb,j++,y）;
listinsert（Lc,++k,y）;
voidunionlist（sqlist&
La,sqlistLb）
inti,x;
for（i=1;
=Lb.length;
getelem（Lb,i,x）;
locateelem（La,x））
listinsert（La,++La.length,x）;
{intj,e;
sqlistLa,Lb,Lc;
initlist（La）;
createlist（La）;
outputlist（La）;
initlist（Lb）;
createlist（Lb）;
outputlist（Lb）;
mergelist（La,Lb,Lc）;
outputlist（Lc）;
unionlist（La,Lb）;
pleaseinputinsertingjande\n"
%d%d"
j,&
e）;
listinsert（Lc,j,e）;
pleaseinputdeletingj\n"
j）;
listdelete（Lc,j）;
getch（）;
程序3（线性表的链式实现）
typedefstructLnode
{elemtypedata;
structLnode*next;
}Lnode,*linklist;
voidcreatelist（linklist&
L,intn）
linklistp;
L=（linklist）malloc（sizeof（Lnode））;
L->
next=NULL;
for（i=n;
i>
0;
--i）
p=（linklist）malloc（sizeof（Lnode））;
p->
data）;
p->
next=L->
next;
L->
next=p;
voidgetelem（linklistL,inti,elemtype&
p=L->
j=1;
while（p&
i）{p=p->
p||j>
i）{printf（"
x=p->
data;
intlocateelem（linklistL,elemtypee）
{linklistp;
while（p）{if（p->
data==e）return1;
p=p->
voidlistinsert（linklist&
{linklistp,s;
p=L;
j=0;
i-1）{p=p->
i-1）exit（-2）;
s=（linklist）malloc（sizeof（Lnode））;
s->
data=e;
next=p->
next=s;
voidlistdelete（linklist&
{linklistp,q;
j=0;
while（p->
next&
（p->
next）||j>
q=p->
next=q->
free（q）;
voidoutputlist（linklistL）
while（p）{printf（"
p->
voidmergelist（linklist&
La,linklist&
Lb,linklist&
linklistpa,pb,pc;
pa=La->
pb=Lb->
Lc=pc=La;
while（pa&
pb）
{if（pa->
data<
=pb->
data）
{pc->
next=pa;
pc=pa;
pa=pa->
else{pc->
next=pb;
pc=pb;
pb=pb->
pc->
next=pa?
pa:
pb;
free（Lb）;
{linklistL,La,Lb,Lc;
inti,e,n;
pleaseinputn!
n）;
createlist（L,n）;
outputlist（L）;
pleaseinputiande!
i,&
listinsert（L,i,e）;
pleaseinputi!
i）;
listdelete（L,i）;
pleaseoutputielementoflinklist!
getelem（L,i,e）;
the%delementoflinklistis%d!
i,e）;
pleaseinputelementofsearcher!
"
if（locateelem（L,e））printf（"
%dissearched!
elseprintf（"
notfound\n"
pleaseinputn!
createlist（La,n）;
createlist（Lb,n）;
程序4（静态链表的实现）
#definemaxsize100
{chardata;
intcur;
}component,slinklist[maxsize];
voidinitlist（slinklistL）
maxsize-1;
++i）L[i].cur=i+1;
L[maxsize-1].cur=0;
intmalloclist（slinklistL）
i=L[0].cur;
if（L[0].cur）L[0].cur=L[i].cur;
returni;
voidfreelist（slinklistL,intk）
L[k].cur=L[0].cur;
L[0].cur=k;
voidoutputlist（slinklistL）
{intk;
k=L[1].cur;
while（k）{printf（"
%c"
L[k].data）;
k=L[k].cur;
voiddifference（slinklistL,int&
s）
intr,m,n,i,j,b,p,k;
initlist（L）;
s=malloclist（L）;
r=s;
pleaseinputmandn!
m,&
for（j=1;
=m;
++j）
i=malloclist（L）;
%s"
L[i].data）;
L[r].cur=i;
r=i;
L[r].cur=0;
=n;
b）;
p=s;
k=L[s].cur;
while（k!
=L[r].cur&
L[k].data!
=b）
{p=k;
if（k==L[r].cur）
{i=malloclist（L）;
L[i].data=b;
L[i].cur=L[r].cur;
L[r].cur=i;
else
{L[p].cur=L[k].cur;
freelist（L,k）;
if（r==k）r=p;
slinklistL;
ints;
difference（L,s）;
程序5（多项式相加的实现）
#include<
floatcoef;
intexpn;
}term,elemtype;
elemtypedata;
}Lnode,*linklist;
voidinitlist（linklist&
L）exit（-2）;
L,intm）
inti,y;
floatx;
pleaseinputdata.coefanddata.expn:
forexample（1,19）,（2,9）,（3,3）!
%f%d"
x,&
y）;
data.coef=x;
data.expn=y;
while（p）
（%f,%d）\n"
data.coef,p->
data.expn）;
p=p->
voidaddlist（linklist&
floatsum;
pb=Lb->
pc=Lc=La;
if（pa->
data.expn<
pb->
data.expn）{pc->
elseif（pa->
data.expn>
{sum=pa->
data.coef+pb->
data.coef;
if（sum==0.0）{pa=pa->
pb=pb->
else{pa->
data.coef=sum;
pc->
voidmain（）
linklistLa,Lb,Lc;
intm;
pleaseinputmofLa!
createlist（La,m）;
pleaseinputmofLb!
createlist（Lb,m）;
Lc\n"
addlist（La,Lb,Lc）;
第三章栈和队列
程序6（栈的实现及其应用）
#definestack_size100
#definestack_increment10
elemtype*base;
elemtype*top;
intstacksize;
}sqstack;
voidinitsqstack（sqstack&
S）
S.base=（elemtype*）malloc（stack_size*sizeof（elemtype））;
S.base）exit（-2）;
S.top=S.base;
S.stacksize=stack_size;
voidcreatesqstack（sqstack&
S,intm）
pleaseinputelemtype!
x）;
*S.top=x;
S.top++;
voidoutputsqstack（sqstackS）
while（S.top!
=S.base）printf（"
*--S.top）;
voidgettop（sqstackS,elemtype&
if（S.top!
=S.base）e=*（S.top-1）;
voidpush（sqstack&
S,elemtypee）
if（S.top-S.base>
=S.stacksize）
S.base=（elemtype*）realloc（S.base,（S.stacksize+stack_increment）*sizeof（elemtype））;
S.top=S.base+S.stacksize;
S.stacksize+=stack_increment;
*S.top++=e;
voidpop（sqstack&
S,elemtype&
=S.base）e=*--S.top;
intstackempty（sqstackS）
if（S.top==S.base）return1;
voidconversion（）
sqstackT;
intn,e;
initsqstack（T）;
\npleaseinputN!
while（n）{push（T,n%8）;
n=n/8;
while（!
stackempty（T））{
升级会员 