10092130138张伟.docx

10092130138张伟.docx

《10092130138张伟.docx》由会员分享，可在线阅读，更多相关《10092130138张伟.docx（28页珍藏版）》请在冰豆网上搜索。

10092130138张伟

1800

实现一个线性表:

参照课本P5上的sq_delete函数，对一个n不超过1024的线性表进行删除操作

#defineM1024

#include

intmain（）

{

intsq_delete（intlist[],int*p_n,inti）;

inta[M],n,m;

inti,q,k,p,l;

scanf（"%d",&n）;

m=n;

for（i=0;i

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

scanf（"%d",&q）;

while（q--）

{

scanf（"%d",&k）;

l=a[k-1];

p=sq_delete（a,&m,k-1）;

if（p==-1）

printf（"%d\n",p）;

if（p==0）

{

printf（"%d\n",l）;

}

}

return0;

}

intsq_delete（list,p_n,x）

intlist[];

int*p_n,x;

{

intj;

if（x<0||x>=*p_n）

return-1;

for（j=x+1;j<*p_n;j++）

list[j-1]=list[j];

（*p_n）--;

return0;

}

被调用函数：

intsq_delete（list,p_n,x）线性表删除

调试时间：

2010-10-1623:

08:

25

1801

实现环形队列（MAXN不超过100001），要求能够进行进队出队操作，参考课本P15页例程。

#defineN100001

#include

#include

chara[N][20];

inthead=0;

inttail=0;

intmain（）

{

intenq（charch1[]）;

intdeq（char*p）;

charb[7],c[20];

intq,x;

scanf（"%d\n",&q）;

while（q--）

{

scanf（"%s",&b）;

if（b[0]=='e'）

{

scanf（"%s",&c）;

enq（c）;

if（enq（c）==0）

printf（""）;

}

elseif（b[0]=='d'）

{

x=deq（&a[head]）;

if（x==-2）

printf（"-1\n"）;

else

printf（"%s\n",a[deq（&a[head]）]）;

}

}

return0;

}

intenq（charch1[]）

{

tail=（tail+1）%N;

if（tail==head）

{

if（tail==0）

tail=N-1;

else

tail--;

return1;

}

strcpy（a[tail],ch1）;

return0;

}

intdeq（char*p）

{inth;

if（head==tail）

return-2;

h=head;

head=（head+1）%N;

*p=a[head][0];

returnh;

}

被调用函数：

进队函数intenq（charch1[]）出对函数intdeq（char*p）

调试时间：

2010-11-1009:

26:

01

1803

实现线性链表的创建于插入（插入到已有元素之后）

include

typedefstructnode{intdata;

structnode*link;

}NODE;

intmain（）

{

NODE*creatlist（intn）;

voidinsert（NODE*phead,inta,intb）;

NODE*ahead,*p;

intm,q;

intx,y;

scanf（"%d",&m）;

ahead=creatlist（m）;

scanf（"%d",&q）;

while（q--）

{

scanf（"%d%d",&x,&y）;

insert（ahead,x,y）;

for（p=ahead;（p->link）!

=NULL;p=p->link）

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

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

}

return0;

}

NODE*creatlist（intn）

{

inti;

NODE*head,*p0,*q;

if（n==0）

return（NULL）;

head=（NODE*）malloc（sizeof（NODE））;

p0=head;

for（i=1;i

{

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

q=（NODE*）malloc（sizeof（NODE））;

p0->link=q;

p0=q;

}

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

p0->link=NULL;

returnhead;

}

voidinsert（NODE*phead,inta,intb）

{

NODE*p0,*q;

q=（NODE*）malloc（sizeof（NODE））;

q->data=b;

q->link=NULL;

if（phead==NULL）

phead=q;

else

{

p0=phead;

while（p0->data!

=a&&p0->link!

=NULL）

p0=p0->link;

q->link=p0->link;

p0->link=q;

}

}

被调用函数：

线性表创建NODE*createlist（intn）和插入函数voidinsert（NODE*phead，inta，intb）

调试时间：

2010-11-3020:

35:

30

1804

实现字符串的strcat,strsub,strequ操作，参照课本P62例程

#defineN1024

#include

chara[N];

charc[N];

intmain（）

{

intstrlen（chars[]）;

intstrcat（chars1[],chars2[]）;

intstrsub（chars1[],inti,intj,chars2[]）;

intstrequ（chars1[],chars2[]）;

charb[6];

intd,e,n;

gets（a）;

scanf（"%d\n",&n）;

while（n--）

{

scanf（"%s",&b）;

if（strequ（b,"strcat"）==1）

{

scanf（"%s",&c）;

strcat（a,c）;

printf（"%s\n",a）;

}

elseif（strequ（b,"strsub"）==1）

{

scanf（"%d%d",&d,&e）;

if（d<0||e>strlen（a））

printf（"fail\n"）;

else

{

strsub（a,d,e,c）;

printf（"%s\n",c）;

}

}

elseif（strequ（b,"strequ"）==1）

{

scanf（"%s",&c）;

if（strequ（a,c）==1）

printf（"yes\n"）;

else

printf（"no\n"）;

}

}

return0;

}

intstrlen（chars[]）

{

inti;

for（i=0;s[i]!

='\0';i++）;

returni;

}

intstrcat（chars1[],chars2[]）

{

inti,j,k;

if（（i=strlen（s1））+（j=strlen（s2））>=N）

return0;

for（k=0;k<=j;k++）

s1[i+k]=s2[k];

return1;

}

intstrsub（chars1[],inti,intj,chars2[]）

{

intm,k;

if（i<0||i>=（m=strlen（s1）））

return0;

if（j<0||i+j>m）

return0;

for（k=0;k

s2[k]=s1[i+k];

s2[k]='\0';

return1;

}

intstrequ（chars1[],chars2[]）

{

inti=0;

while（s1[i]==s2[i]&&s1[i]!

='\0'&&s2[i]!

='\0'）

i++;

if（s1[i]=='\0'&&s2[i]=='\0'）

return1;

else

return0;

}

被调用函数：

intstrcat（chars1[],chars2[]）intstrsub（chars1[],intI,intj,chars2）intstrequ（chars1[],chars2[]）

调试时间：

2010-10-2823:

35:

25

1806

实现选择排序

defineM1023

#include

intmain（）

{

inta[M];

intn,i;

intj,t;

intk;

scanf（"%d",&n）;

for（i=0;i

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

for（i=0;i

{

k=i;

for（j=i+1;j

if（a[k]>a[j]）k=j;

t=a[i];

a[i]=a[k];

a[k]=t;

if（i%（n-1）==0&&i>0）

printf（"%d\n",a[i]）;

else

printf（"%d",a[i]）;

}

return0;

}

调试时间：

2010-10-1912:

14:

10

1807

实现快速排序

#defineM20000

#include

intmain（）

{

voidquick（inta[],intlow,intup）;

intn,k;

intb[M];

scanf（"%d",&n）;

for（k=0;k

scanf（"%d",&b[k]）;

quick（b,0,n-1）;

for（k=0;k

printf（"%d",b[k]）;

printf（"%d\n",b[k]）;

return0;

}

voidquick（a,low,up）

inta[];

intlow,up;

{inti,j;

intt;

if（low

{

i=low;

j=up;

t=a[low];

while（i!

=j）

{

while（it）

j--;

if（i

while（i

i++;

if（i

}

a[i]=t;

quick（a,low,i-1）;

quick（a,i+1,up）;

}

}

被调用函数：

voidquick（inta[],intlow,intup）

调试时间：

2010-10-1623:

35:

28

1808

实现冒泡排序

#defineN1024

#include

intmain（）

{

inta[N];

intn,i;

intj,t;

intm;

scanf（"%d\n",&n）;

for（i=0;i

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

n--;

m=n;

while（n>0）

{

j=0;

for（i=0;i

if（a[i]>a[i+1]）

{

t=a[i];

a[i]=a[i+1];

a[i+1]=t;

j=i;

}

n=j;

}

for（i=0;i

printf（"%d",a[i]）;

printf（"%d\n",a[i]）;

return0;

}

调试时间：

2010-10-2500:

08:

13

1809

对于n个整数，找出第1小，第2小.....第k小的整数

#defineN1000000

#include

inta[N];

intmain（）

{

voidquick（intb[],intlow,intup）;

inti,k;

intn;

scanf（"%d%d",&n,&k）;

for（i=0;i

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

quick（a,0,n-1）;

for（i=0;i

printf（"%d",a[i]）;

printf（"%d\n",a[i]）;

system（"pause"）;

return0;

}

voidquick（intb[],intlow,intup）

{

inti,j;

intt;

if（low

{

i=low;

j=up;

t=b[low];

while（i!

=j）

{

while（it）

j--;

if（i

while（i

i++;

if（i

}

b[i]=t;

quick（b,low,i-1）;

quick（b,i+1,up）;

}

}

被调用函数：

viodquick（intb[],intlowintup）

调试时间：

2010-11-0900:

40:

13

1810

利用原稀疏矩阵的三元数组a，求转置矩阵的三元数组b，并将其规格化，即按行号递增，若行号相同则按照列号递增的顺序。

参照课本P93.94例程

include

intg[1000001],f[1000001];

inta[1000001][3],b[1000001][3];

intmain（）

{

intm,n;

inti,j;

intk,c;

while（scanf（"%d%d%d",&m,&n,&c）!

=EOF）

{

k=1;

while（k<=c）

{

scanf（"%d%d%d",&a[k][0],&a[k][1],&a[k][2]）;

k++;

}

if（c>0）

{

for（i=0;i

g[i]=0;

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

g[a[i][1]]+=1;

f[0]=1;

for（i=1;i

f[i]=g[i-1]+f[i-1];

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

{

j=f[a[i][1]];

b[j][0]=a[i][1];

b[j][1]=a[i][0];

b[j][2]=a[i][2];

f[a[i][1]]=j+1;

}

}

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

printf（"%d%d%d\n",b[i][0],b[i][1],b[i][2]）;

}

system（"pause"）;

return0;

}

调试时间：

2010-11-1718:

53:

12

1811

根据树的层号表示建树，打印树的后序遍历序列。

层号表示法参见课本P117

#include

#include

#defineM26

#defineN26

structnode{intlev;

chardata;

structnode*child[M];

structnode*parent;

};

typedefstructnodeNODE;

typedefstructdnode{intlev;

chardata;

}DNODE;

intmain（）

{

voidlevtree（DNODEa[],intn）;

voidaftree（NODE*root1）;

DNODEa0[N];

intn0,i;

charc1,c2,c3,c4;

scanf（"%d\n",&n0）;

for（i=0;i

{

scanf（"%c%d%c%c%c%c",&c1,&a0[i].lev,&c3,&a0[i].data,&c2,&c4）;

}

levtree（a0,n0）;

printf（"\n"）;

return0;

}

voidlevtree（DNODEa[],intn）

{

inti,j;

NODE*root,*p,*q;

root=（NODE*）malloc（sizeof（NODE））;

root->lev=a[0].lev;

root->data=a[0].data;

for（i=0;i

root->child[i]=NULL;

root->parent=NULL;

p=root;

for（i=1;i

{

q=（NODE*）malloc（sizeof（NODE））;

q->lev=a[i].lev;

q->data=a[i].data;

for（j=0;j

q->child[j]=NULL;

while（q->lev<=p->lev）

p=p->parent;

q->parent=p;

for（j=0;j

{

if（p->child[j]==NULL）

{p->child[j]=q;

break;}

}

p=q;

}

aftree（root）;

}

voidaftree（NODE*root1）

{intii;

if（root1!

=NULL）

{

for（ii=0;ii

aftree（root1->child[ii]）;

printf（"%c",root1->data）;

}

}

被调用函数：

层次建立树voidlevtree（DNODEa[],intn）后序遍历树voidaftree（NODE*root）

调试时间：

2010-12-2209:

19:

51

1812

给定一个有根二叉树，规定连接两个节点的每条边长度是1，定义树的深度为根到叶子节点距离的最大值

include

intmain（）

{

intm=1,n=0;

inti,j=0;

intk,l;

intx,y;

intn1,n2=0;

scanf（"%d",&k）;

while（m!

=0）

{

n1=m;

m=0;

for（i=0;i

{

scanf（"%d%d",&x,&y）;

j++;

if（x>0）

m++;

if（y>0）

m++;

}

n2++;

if（j==k）

m=0;

}

printf（"%d\n",n2）;

return0;

}

调试时间：

2010-12-2215:

12:

39

1814

二叉树T中，如果非叶子结点都有两棵非空子树，那么称二叉树T是一棵完全二叉树。

现在根据边的连接情况判断一棵树是否是完全二叉树。

defineN1025

#include

intmain（）

{

inta[N]={0},n;

inti,j;

intx,y;

intm;

scanf（"%d%d",&n,&j）;

m=n-1;

while（m--）

{scanf（"%d%d",&x,&y）;

a[x]=a[x]+1;

a[y]=a[y]+1;

}

if（a[j]==2||a[j]==0）

a[j]=3;

else

a[j]=2;

for（i=1;i

if（a[i]==2）

{

printf（"no\n"）;

break;

}

if（i>=N）

printf（"yes\n"）;

return0;

}

调试时间：

2010-12-1516:

20:

48

1815

我们大家都学习了Huffman算法，给出每一个点的权值，它可以求出一个具有最小加权外部路径的二叉树，也就是使造价W（k1）*Lk1+...+W（kn）*Lkn（树枝长度为根结点到叶结点边数）最小的二叉树。

现在由你来完成这项工作

#defineN10001

#include

#include

typedefstructnode

{

intdata;

structnode*lchild;

structnode*rchild;

structnode*parent;

}NODE;

NODE*adr[N];

intmain（）

{NODE*creat（inta[],intn）;

intn0,a[N],m,i;

intsum;

NODE*root,*p;

scanf（"%d",&n0）;

for（i=0;i

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

root=creat（a,n0）;