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;iscanf（"%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;ks2[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;iscanf（"%d",&a[i]）;
for（i=0;i{
k=i;
for（j=i+1;jif（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;kscanf（"%d",&b[k]）;
quick（b,0,n-1）;
for（k=0;kprintf（"%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（iwhile（ii++;
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;iscanf（"%d",&a[i]）;
n--;
m=n;
while（n>0）
{
j=0;
for（i=0;iif（a[i]>a[i+1]）
{
t=a[i];
a[i]=a[i+1];
a[i+1]=t;
j=i;
}
n=j;
}
for（i=0;iprintf（"%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;iscanf（"%d",&a[i]）;
quick（a,0,n-1）;
for（i=0;iprintf（"%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（iwhile（ii++;
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;ig[i]=0;
for（i=1;i<=c;i++）
g[a[i][1]]+=1;
f[0]=1;
for（i=1;if[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;iroot->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;jq->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;iiaftree（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;iif（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;iscanf（"%d",&a[i]）;
root=creat（a,n0）;
升级会员 