数据结构习题.docx

数据结构习题.docx

《数据结构习题.docx》由会员分享，可在线阅读，更多相关《数据结构习题.docx（65页珍藏版）》请在冰豆网上搜索。

数据结构习题

数据结构习题与实验

目录

习题一1

习题二4

习题三7

一元多项式之和实验8

哈夫曼树实验13

求最小生成树算法实验17

拓扑排序算法22

求最短路径（迪接斯特算法）28

关键路径35

快速排序43

习题一

①、请设计一算法：

已知顺序表L，表中元素为整型且递增有序，现有一值为e的元素要插入L表，使插入后L表仍然有序。

②、已知L为非递减的顺序表，请设计算法删除L中重复的元素（即删除后使L表变为一递增表）。

#include

#include

#include

#defineLIST_SIZE100

#defineOK1

typedefstruct

{

int*elem;

intlength;

intlistsize;

}SqList;

intInitList_Sq（SqList&L）

{

L.elem=（int*）malloc（LIST_SIZE*sizeof（int））;

if（!

L.elem）exit（0）;

L.length=0;

L.listsize=LIST_SIZE;

returnOK;

}

voidListCreate（SqList&L,inti）

{

if（i>L.listsize）

exit（0）;

for（intj=0;j

{

scanf（"%d",&L.elem[j]）;

L.length++;

}

}

intSortInsert（SqList&L,inte）

{

inti,k=0;

int*p,*q;

p=L.elem;

q=L.elem+L.length-1;

for（i=1;i<=L.length;i++）

{

if（e<=*p）

{

for（q++;q>p;q--）

{

*q=*（q-1）;

}

*p=e;

k=1;

break;

}

else

p++;

}

if（k==0）

{

*（q+1）=e;

}

L.length++;

returnOK;

}

voidmain（）

{

voidListCreate（SqList&L,inti）;

intInitList_Sq（SqList&L）;

intSortInsert（SqList&L,inte）;

inti;

SqListLa;

InitList_Sq（La）;

ListCreate（La,3）;

inta;

printf（"需要插入的数字：

"）;

scanf（"%d",&a）;

SortInsert（La,a）;

printf（"插入后的元素列表变为：

\n"）;

for（i=0;i

{

printf（"%d",La.elem[i]）;

}

printf（"\n"）;

}

/*

voidSortDeleSame（SqList&L）

{

int*i;

int*p;

int*q;

p=L.elem;

q=L.elem+L.length-1;

while（p

{

if（*p==*（p+1））

{

for（i=p;i

{

*i=*（i+1）;

}

L.length--;

q--;

}

else

p++;

}

}

voidmain（）

{

intInitList_Sq（SqList&L）;

voidSortDeleSame（SqList&L）;

voidListCreate（SqList&L,inti）;

inti;

SqListLb;

InitList_Sq（Lb）;

ListCreate（Lb,5）;

SortDeleSame（Lb）;

printf（"\n"）;

for（i=0;i

{

printf（"%d",Lb.elem[i]）;

}

}*/

习题二

③、已知带头结点的动态单链表L中的结点是按整数值递增排列的，试写一算法将值x为的结点插入到表L中，使L仍然有序。

#include

#include

#include

typedefstructLNode

{

intdata;

structLNode*next;

}LNode,*LinkList;

voidmain（）

{

voidCreatList_LinkList（LinkList&L,intn）;

voidListInsert_LinkList（LinkList&L,intx）;

voidPrint_LinkList（LinkList&L,intn）;

LinkListLa;

inta,b;

printf（"请问要输入多少数：

"）;

scanf（"%d",&a）;

printf（"请输入这%d个数：

\n",a）;

CreatList_LinkList（La,a）;

printf（"请问要插入的数是：

"）;

scanf（"%d",&b）;

ListInsert_LinkList（La,b）;

printf（"插入后结果为:

\n"）;

Print_LinkList（La,a+1）;

printf（"\n"）;

}

voidCreatList_LinkList（LinkList&L,intn）

{

inti,a;

LNode*s,*tail;

L=（LinkList）malloc（sizeof（LNode））;

L->next=NULL;

tail=L;

for（i=0;i

{

s=（LinkList）malloc（sizeof（LNode））;

scanf（"%d",&s->data）;

tail->next=s;

tail=tail->next;

}

tail->next=NULL;

}

voidPrint_LinkList（LinkList&L,intn）

{

LNode*p;

p=L->next;

for（inti=0;i

{

printf（"%d",p->data）;

p=p->next;

}

}

voidListInsert_LinkList（LinkList&L,intx）

{

intk=0;

LNode*pre,*p,*s;

pre=L;

p=L->next;

while（pre&&p）

{

if（x<=p->data）

{

s=（LinkList）malloc（sizeof（LNode））;

s->next=pre->next;

pre->next=s;

s->data=x;

k=1;

break;

}

pre=pre->next;

p=p->next;

}

if（k==0）

{

s=（LinkList）malloc（sizeof（LNode））;

pre->next=s;

s->data=x;

s->next=NULL;

}

}

习题三

④、设计一算法，逆置带头结点的动态单链表L。

//La为已知单链表，Lb为新建的一个单链表

voidTrunhead_LinkList（LinkList&La,LinkList&Lb,intn）

{

LinkListp=La->next;

LinkLists;

Lb=（LinkList）malloc（sizeof（LNode））;

Lb->next=NULL;

for（i=0;i

{

s=（LinkList）malloc（sizeof（LNode））;

s->data=p->data;

s->next=Lb->next;

Lb->next=s;

p=p->next;

}

}

一元多项式之和实验

#include

#include

#include

typedefstructpolynode

{

floatcoef;//系数

intexpn;//指数

structpolynode*next;

}polynode,*polylist;

voidcreate（polylist&L）//创建链表

{

intm;

polylistp;

printf（"请输入一元多项式项数：

"）;

scanf（"%d",&m）;

L=（polylist）malloc（sizeof（polynode））;

p=L;

for（inti=1;i<=m;i++）//利用循环，依次输入系数和指数

{

p->next=（polylist）malloc（sizeof（polynode））;

p=p->next;

printf（"请输入第%d项的系数和指数：

",i）;

scanf（"%f%d",&p->coef,&p->expn）;

}

p->next=NULL;

}

voiddisplay（polylistL）//显示链表内容

{

polylistp;

p=L->next;

printf（"%.0fx（%d）",p->coef,p->expn）;

p=p->next;

while（p）

{

if（p->coef<0）

{

printf（"%.0fx（%d）",p->coef,p->expn）;

}

else

{

printf（"+%.0fx（%d）",p->coef,p->expn）;

}

p=p->next;

}

printf（"\n"）;

}

voidadd（polylistLa,polylistLb,polylist&Lc）//加法函数

{

polylistpa,pb,pc;

floatx;

pa=La->next;pb=Lb->next;

pc=（polylist）malloc（sizeof（polynode））;

Lc=pc;

while（pa&&pb）

{if（pa->expn==pb->expn）

{x=pa->coef+pb->coef;

if（x!

=0）

{

pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=x;

pc->expn=pa->expn;

}

pa=pa->next;

pb=pb->next;

}

else//无同类项可合并，指数小者复制到C表

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

if（pa->expnexpn）//a的指数小于b的指数

{

pc->coef=pa->coef;

pc->expn=pa->expn;

pa=pa->next;

}

else

{

pc->coef=pb->coef;

pc->expn=pb->expn;

pb=pb->next;

}

}

}

while（pa）//还剩下a多项式

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=pa->coef;

pc->expn=pa->expn;

pa=pa->next;

}

while（pb）//还剩下b多项式

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=pb->coef;

pc->expn=pb->expn;

pb=pb->next;

}

pc->next=NULL;

}

voidsubtract（polylistLa,polylistLb,polylist&Lc）//减法函数

{polylistpa,pb,pc;

floatx;

pa=La->next;pb=Lb->next;

pc=（polylist）malloc（sizeof（polynode））;

Lc=pc;

while（pa&&pb）

{

if（pa->expn==pb->expn）

{

x=pa->coef-pb->coef;

if（x!

=0）

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=x;

pc->expn=pa->expn;

}

pa=pa->next;pb=pb->next;

}

else//无同类项可合并，指数小者复制到C表

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

if（pa->expnexpn）//a的指数小于b的指数

{

pc->coef=pa->coef;

pc->expn=pa->expn;

pa=pa->next;

}

else

{pc->coef=-pb->coef;

pc->expn=pb->expn;

pb=pb->next;

}

}

}

while（pa）//还剩下a多项式

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=pa->coef;

pc->expn=pa->expn;

pa=pa->next;

}

while（pb）//还剩下b多项式

{pc->next=（polylist）malloc（sizeof（polynode））;

pc=pc->next;

pc->coef=-pb->coef;

pc->expn=pb->expn;

pb=pb->next;

}

pc->next=NULL;

}

voidmain（）//主函数

{

polylistLa,Lb,Lc,Ld;

create（La）;

create（Lb）;

printf（"一元多项式1：

"）;

display（La）;

printf（"一元多项式2：

"）;

display（Lb）;

add（La,Lb,Lc）;

printf（"加的结果：

"）;

display（Lc）;

subtract（La,Lb,Ld）;

printf（"减的结果"）;

display（Ld）;

}

哈夫曼树实验

#include

#include

#include

#include

typedefstruct

{

charch;

intweight;

intparent,lchild,rchild;

}HTNode,*HuffmanTree;

typedefchar**HuffmanCode;

voidCreateHuffmanTree（HuffmanTree&HT,intw[],charch[],intn）;

voidSelect（HuffmanTreeHT,intn,int&s1,int&s2）;

voidHTCoding（HuffmanTreeHT,HuffmanCode&HC,intn）;

voidPrintCode（HuffmanCodeHC,intn,charch[]）;

doubleAverageLength（HuffmanTreeHT,HuffmanCodeHC,intn）;

voidDeCode（HuffmanTreeHT,intn）;

voidmain（）//主函数

{

intn;

inti;

chararrch[20];

intarrweight[20];

doubleavlength;

charch;

HuffmanTreeHT;

HuffmanCodeHC;

printf（"请输入要输入字母的个数：

"）;

scanf（"%d",&n）;

while（（ch=getchar（））!

='\n'）;

if（n>20||n<2）exit（0）;

for（i=0;i

{

printf（"请输入第%d个字母：

",i+1）;

scanf（"%c",&arrch[i]）;

printf（"请输入该字母权重：

"）;

scanf（"%d",&arrweight[i]）;

while（（ch=getchar（））!

='\n'）;

}

CreateHuffmanTree（HT,arrweight,arrch,n）;

HTCoding（HT,HC,n）;

PrintCode（HC,n,arrch）;

avlength=AverageLength（HT,HC,n）;

printf（"平均编码长度为：

%.2f\n",avlength）;

printf（"请输入要解码的数据：

"）;

DeCode（HT,n）;

for（i=0;i

free（HC[i]）;

free（HC）;

free（HT）;

}

voidCreateHuffmanTree（HuffmanTree&HT,intw[],charch[],intn）

{

inti,m,s1,s2;

m=2*n-1;

HT=（HuffmanTree）malloc（（m+1）*sizeof（HTNode））;

for（i=1;i<=n;i++）

{

HT[i].weight=w[i-1];

HT[i].parent=0;

HT[i].lchild=0;

HT[i].rchild=0;

HT[i].ch=ch[i-1];

}

for（i=n+1;i<=m;i++）

{

HT[i].weight=0;

HT[i].parent=0;

HT[i].lchild=0;

HT[i].rchild=0;

HT[i].ch='\0';

}

for（i=n+1;i<=m;i++）

{

Select（HT,i-1,s1,s2）;

HT[s1].parent=i;

HT[s2].parent=i;

HT[i].lchild=s1;

HT[i].rchild=s2;

HT[i].weight=HT[s1].weight+HT[s2].weight;

}

}

voidSelect（HuffmanTreeHT,intn,int&s1,int&s2）

{

inti;

intmin;

min=1000;

for（i=1;i<=n;i++）

{

if（HT[i].parent==0&&HT[i].weight<=min）

{

min=HT[i].weight;

s1=i;

}

}

min=1000;

for（i=1;i<=n;i++）

{

if（HT[i].parent==0&&HT[i].weight<=min&&i!

=s1）

{

min=HT[i].weight;

s2=i;

}

}

}

voidHTCoding（HuffmanTreeHT,HuffmanCode&HC,intn）

{

inti,j,k,start;

intf;

intc;

char*cd;

HC=（HuffmanCode）malloc（（n）*sizeof（char*））;

cd=（char*）malloc（n*sizeof（char））;

cd[n-1]='\0';

for（i=1;i<=n;++i）

{

start=n-1;

for（c=i,f=HT[i].parent;f!

=0;c=f,f=HT[f].parent）

{

if（HT[f].lchild==c）

{cd[--start]='0';}

else

{cd[--start]='1';}

}

HC[i-1]=（char*）malloc（（n-start）*sizeof（char））;

for（j=start,k=0;j

{

HC[i-1][k]=cd[j];

}

}

free（cd）;

}

voidPrintCode（HuffmanCodeHC,intn,charch[]）

{

for（inti=0;i

{

printf（"%c的编码是%s\n",ch[i],HC[i]）;

}

}

doubleAverageLength（HuffmanTreeHT,HuffmanCodeHC,intn）

{

inti,j;

ints1=0,s2=0;

for（i=1;i<=n;i++）

{

s1=s1+HT[i].weight;

}

for（i=0,j=1;i

{

s2=s2+HT[j].weight*strlen（HC[i]）;

}

returns2*1.0/s1;

}

voidDeCode（HuffmanTreeHT,intn）

{

inti;

charendflag='#';

charch;

i=2*n-1;

scanf（"%c",&ch）;

while（ch!

=endflag）

{

if（ch=='0'）

{i=HT[i].lchild;}

else

{i=HT[i].rchild;}

if（HT[i].lchild==0）

{

printf（"%c