2024年华为C语言机试题面试题

1.第一题的题目大约是输入整型数组求数组的最小数和最大数之和，例如输入L234则输出为5,当输入只有一个数

的时候，则最小数和最大数都是该数，例如只输入1,则输出为2;另外数组的长度不超出50

#include<stdio.h>

mainQ

(

intnum(50]={0};

inti,n;

printfC•请输入整型数组的长度Q~50):");

scanfC%d",&n);

printf("请输入整型数组的元素:');

for(i=0;i<n;i++)

(

scanf("%d'&num「]);

}

intmin_num=num[0];

intmax_num=num[0];

for(intj=O;j<n;j++)

if(max_num<num(j])

max_num=num[j]；

elseif(min_num>num(j|)

min_num-num(j];

}

intsum=min_num+max_num;

printf(”数组中最大与最小值之和：%d\n\sum);

return0;

)

2.求两个长长整型的数据的和并输出，例如输入3333・。。1............则输出,・・・

#include<stdio.h>

#include<string.h>

#include<malloc.h>

mainQ

char*numl,*num2;/俩个整型

char*sum;

//inttemp;

intIen_numl,len_num2;//两个长长整型数据的长度

intlen_max,len_min;

numl-(char*)malloc(sizGof(char));

num2=(char*)malloc(sizeof(char));

printfC1输入两个长长整型数据：");

scanfC%s",numl);

printfC•输入两个长长整型数据：")；

scanfC%s",num2);

len_numl=strlen(numl);

Ien_num2=strlen(num2);

Ien_max=(len_numl>=len_nim2)?Ien_numl:len_num2;

Ien_min=(len_numl<=len_num2)?Ien_numl:len_num2;

intlen_maxl=len_max;

sum=(char*)malloc(sizeof(char)*len_max);

memset(sum,OxOO』en_max+Li;〃切忌初始化

forClen_numl>0&&len_num2>0;len_numl—Jen_num2—)

sum[len_max--]=((numl[len_numl-l]-'0')+(num2[len_num2-l]-'0'));

if(len_numl>0)

sum[len_max—]=numl[len_numl-1卜'O';

len_numl—;

}

if(len_num2>0)

(

sum[len_max—]=numl(len_num2-1]-'O';

Ien_num2-;

}

for(intj=len_maxl;j>=O;j--)〃实现进瞒作

(

//temp=sum[j]-O,;

if(sum(j]>=10)

(

sum(j-l]+=sum[j]/10;

sum(j]%=10;

)

char*outsum=(char*)malloc(sizeof(char)*len_maxl);

j=0;

while(sum(j]==O)〃跳出头部0元素

j++；

for(intm-0;m<len_maxl;j++++)

outsum[m)=sum(j]+,0,;

outsum[m]=>\0';

printf(•输出两长长整型数据之和:％sVAoutsum);

return0;

)

3.通过健盘输入一串4号字母(a~z)组成的字符串。请编写一个字符串过漉程序,若字符串中出现多个相同的字符,将非

初次出现的字符过滤掉.

例如字符串"abacacde"过滤成果为“abcde".

要求实现函数：

voidstringFilter(constchar*pInputStr,longIlnputLen,char*pOutputStr);

【输入】plnputStr〉输入字符串

UnputLen:愉入字^串长g

【输出】pOutputStr:输出字符串，空间已经开辟好，与输入字符串等长；

#include<stdio.h>

#include<string.h>

#include<malloc.h>

voidstringFilter(constchar*p_str,longlen,char*p_outstr)

(

intarray[256]={0};

constchar*tmp=p_str;

for(intj=O;j<len;j++)

(

if(array[tmp(j]]==O)

*p_outstr++=tmp[j];

array[tmp[j]]++;

)

Ap_ouistr=\0';

)

voidmain()

{

char*str="cccddecc";

intlen=strlen(str);

char*outstr=(char*)malloc(len*sizeof(char));

stringFilter(str,len,outstr);

printf("%s\n",outstr);

free(outstr);

outstr-NULL;

)

4.通过键盘输入一串小写字母(a~z)组成的字符串。请编写一个字符串压缩程序,

将字符串中连续出席的重复字母进行压缩，并输出压缩后的字符串。

压缩规则：

1.仅压缩连续重复出现的字符。例如字符串"abcbc"因为无连续重复字符，压缩

后的字符串还是"abcbc”.

2.压缩字段的格式为"字符重复的次数+字符"。例如：字符串"xxxyyyyyyz”压缩

后就成为"3x6yz"

要求实现函数：

voidstringZip(constchar*pInputStr,longIlnputLen,char*pOutputStr);

【输入】plnputStr:输入字符串

IlnputLen:输入字符串长度

【输出】pOutputStr:输出字符串，空间已经开辟好，与输入字符串等长；

include<stdio.h>

#include<string.h>

#include<malloc.h>

voidstringZip(constchar*p_str,longlen,char*p_outstr)

intcount=l;

for(inti=0;i<len;i++)

if(p_str[i]==p_str(i+l])

count++;

else

if(count>l)

*p_outstr++=count+'0';

*p_outstr++=p_str(i];

)

else

(

*p_outstr++-p_str[i];

)

count=1〃注意其位置

)

}

*p_outstr='\0';

}

voidmain()

(

char*str="cccddecc";

printf(,压缩之前的字符串为:%s\n”,str);

intlen=strlen(str);

char*outstr=(char*)malloc(len*sizeof(char));

stringZip(str,len,outstr);

printf。压缩之后的字符串为：%s\n",outstr);

free(outstr);

outstr=NULL;

)

5.通过键盘输入100以内正整数的加、减运算式，请编写一个程序输出运算成果

字符串。

输入字符串的格式为：〃操作数1运算符操作数2","操作数"与"运算符"

之间以一个空格隔开。

补充阐明：

1.操作数为正整数，不需要考虑计算成果溢出的情况。

2.若输入算式格式错误，输出成果为"0"。

要求实现函数：

voidarithmetic(constchar*pInputStr,longIlnputLen,char*pOutputStr);

【输入】plnputStr:输入字符串

IlnputLen:输入字符串长度

【输出】pOutputStr:输出字符串，空间已经开辟好，与输入字符串等长；

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

voidarithmetic(constchar*input,longlen,char*output)

(

charsl[10];

chars2(101;

chars3[10];

intent=0;

intlen_input=strlen(input);

for(inti=0;i<len_input;++i)

(

if(input[i]=='')

cnt++;

}

if(cnt!=2)

(

•output++='O';

,output='\0';

return;

sscanf(input,"%s%s%s*,sl,s2,s3);

if(strlen(s2)!=l||(s2(0]!='+'&&s2(0]!='-'))

*output++='O';

,output='0';

return;

intlen_sl=strlen(sl);

for(i=0;i<len_sl;i++)

if(sl(i]<'0'||sl(i]>'91)

*output++='O';

*output="\0';

return;

intIen_s3=strlen(s3);

for(i=0;i<len_s3;i++)

(

if(s3[i]<5|s3m>9)

(

*output++='O';

“output='O';

return;

)

|

intx=atoi(sl);

inty=atoi(s3);

if(s2[0]=='+')

(

intresult=x+y;

itoa(result,output,10);

elseif(s2(0]=='-')

intresult=x-y;

itoa(result,output,10);

)

else

(

*output++='O';

*output=>\O';

return;

}

}

voidmain()

{

charstr(]={TO-23");

charoutstr[10];

intlen=strlen(str);

arithmetic(str,len,outstr);

printf("%s\n",str);

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

）

6.一组人（n个），国成一圈，从某人开始数到第三个的人出列，再接着从下一个人开始数,屐后检出最后出列的人

（约瑟夫环是一个数学的应用问题：已知n个人（以编号1,2,3…n分别表示）围坐在一张圆桌周围.从编号为k的

人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律至免下去，直

到医］桌周围的人所有出列。）

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<malloc.h>

typedefstructNode

（

intdata;

structNode*next;

山nkList;

LinkList*create(intn)

LinkList*p,*q,*head;

inti=l;

p=(LinkList*)malloc(sizeof(LinkList));

p->data-i;

head=p;

for(i=l;i<=n;i++)

(

q=(LinkList*)malloc(sizeof(LinkList));

q->data=i+l;

p->next=q;

p=q；

}

p->next=head;〃使链表尾连受链表头，形成循环链表

returnhead;

free(p);

p=NULL;

free(q);

q=NULL;

}

voiddeletefun(LinkList*Lintm)

(

LinkList*p,*q,*temp;

inti；

p=L;

while(p->next!=p)

(

for(i=l;i<m;i++)

(

q=p；

p=p->next;

)

printf('%5d",p->data);

temp=p;

q->next=p->next;

p=p->next;

free(temp);

)

printf("%5d\n",p->data);

)

intmain()

(

intn=7,m=3;

LinkList*headl;

headl=create(n);

deletefun(headl,m);

return0;

)

7..输入一串字符f只包恬"0-10"和‘，"找出其中母小的数字和最大的数字(也许不止一个)，输出最后剩余数字个

数.如输入"3,3,4,5,677”

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

voidmain()

charstr(100];

printf("输入一组字符串:\n・);

scanfC%s",&str);

intlen-strlen(str);

intarray(100];

intcount=0;

for(inti=0;i<len;i++)

(

if(str[i]>='0'&&str(iJ<=9,)

array[count++]=str[i]-'0';

}

array[count]='\0';

intresult=count;

intmin=array[O];

intmax=array(OJ;

for(intj=0;j<countj++)

if(max<array(j])

max=array(j);

elseif(min>array(j])

min=array(j]；

)

for(intk-0;k<count;k**)

(

if(array[k]==min)

result-;

if(array[k]==max)

result-;

}

printf("%d\n",result);

)

&辆入一组身高在170到190之间(5个身高)，比蛟身高差，选出身高差最小的两个身高；若身高差相同，逸平均身

高高的那两个身高；从小到大输出；

如输入170181173186190输出170173

#include<stdio.h>

#include<stdlib.h>

#defineN5

intmain()

{

intHeight[N];

intdmin;

intH1.H2;

inti,j,temp;

printf(”请输入一组身高在170到190之间的数据(共5个):\n)

for(intk=0;k<N;k++)

scanfC%d",&Height[kD；

printfC\n-);

for(i=0;i<N;i++)

for(j=lJ<N-i&&Helght[j-l]>Height[j];j++)

(

temp=Height[j-l];

Height(j-l]=Height(j];

Height(j]=temp;

)

Hl=HeightlOJ;

H2=Height[l];

dmin=H2-Hl;

for(intm=2;m<N;m++)

(

if(Height(m]-Height[m-l)<=dmin)

(

Hl=Height[m-l];

H2=Height[m];

dmin=Height[m]-Height[m-l];

)

}

prints身高差最小的两个身高为:\n)

prlntf('%d,%d\n',Hl,H2);

return0;

)

9.删除子串，只要是原串中有相同的子串就删掉，无论有多少个，返回子串个数。

#include<stdio.h>

include<stdlib.h>

#include<assert.h>

#include<string.h>

intdelete_sub_str(constchar*str,constchar*sub_str,char*result)

{

assert(str!=NULL&&sub_str!=NULL);

constchar*p,*q;

char*t,*temp;

p=str;

q-sub_str;

t=result;

intn,count=0;

n=strlen(q);

temp=(char*)malloc(n+l);

memset(temp,0x00,n+1);

while(Ap)

(

memcpy(temp,p,n);

if(strcmp(temp,q)==0)

(

count++;

memset(temp,0xG0,n+1);

p=p+n;

)

else

(

*t-*p；

P++；

t++;

memset(temp,OxOO,n+1);

)

}

free(temp);

returncount;

)

voidmain()

(

chars[100]={'O');

intnum=delete_sub_str(u123abcl2de234fglhi34jl23k":123"

printf("Thenumberofsub_stris%d\r\n",num);

printf("Theresultstringis%s\r\n",s);

)

10.要求编程实现上述高精度的十进制加法。要求实现函数：

voidadd(constchar*numl,constchar*num2,char*result)

【输入】numl:字符串形式操作数1，假如操作数为负，则numl⑼为符号位

num2:字符串形式操作数2,假如操作数为负，则num2⑼为符号位

【输出】result:保存加法计算成果学符串,假如成果为负，则roculUO)为符号位.

#include<stdio.h>

#include<stdlib.h>

#include<string.h>

voidmove(char*str,intlength)//移除字母前的.「符号

(

if(str[O]!=

return;

IntI;

for(i=0;i<length-1;i++)

str[i]=str[i+l];

str(i]=AO';

)

intremove_zero(char*result,intlength)

intcount=0;

for(inti=length-1;i>0;i-),7从最后开始移除0,直到遇到非0数字，只对最初位置上的0不予判断

(

if(result[i]--'0')

(

result[i]='\0';

count++;

}else

returnlength-count;

)

returnlength-count;

)

voidreverse(char*resultintlength)/片衿符串倒转

(

chartemp;

for(inti=0;i<=(length-l)/2;i-+)

temp=result[i];

result(i]=result[length-l-i];

result[length-l-i]=temp;

}

)

intreal_add(char*strl,char*str2,char*result,constboolflag)

(

intlenl=strlen(strl);

intIen2=strlen(str2);

intnl,n2,another=0;//another

intcur_rs=0;〃表示result的目前位数

inti,j;

intcurSum;

for(l=lenl-1,J=Ien2-1;i>=0&&j>=0;i—,J—)

(

nl=strl[i]-'O';

n2=str2g]-'O';

curSum=nl+n2+another;

result[cur_rs++]=curSum%10+'O';

another=curSum/10;

)

if(j<0)

(

while(i>-0)〃遍历strl剜余名位

(

nl=strl[i-]-'O';

curSum=nl+another;

result[cur_rs++]=curSum%10+'O';

another=curSum/10;

}

if(another!=0)〃假如尚有进位未加上

result[cur_rs++]=another+'O';

)

else

(

while(j>=0)

(

n2=str2(j-]-'O';

curSum=n2+another;

result[cur_rs++]=curSum%10+'O';

another=curSum/10;

)

if(another!=0)

result[cur_rs++]-another+'O';

)

result(cur_rs]='\0';

cur_rs=remove_zero(result,cur_rs);

if(iflag)

(

result[cur_rs++]=

result[cur_rs]=\0';

}

reverse(result,strlen(result));

returncur_rs;

)

intreal_minus(char*strl,char*str2,char*result)〃使用strl减去str2

charbig[100],small[100];

intbigjen,smljen;

intlenl=strlen(strl);

intIen2=strlen(str2);

boolflag=false;〃用于标识str2是否比strl大

if(lenl<Ien2)

flag=true;

elseif(lenl==Ien2)

(

lf(strcmp(strl,str2)==0)

(

result[O]='O';

result[l]='\0';

return1;

}elseif(strcmp(strl,str2)<0)

flag=true;

)

if(flag)〃将strl和str2互换，端保strl指向的值是其中较大者，屐后通过flag确定要不要给前面加一号

(

char*temp-strl;

strl=str2;

str2=temp;

lenl=strlen(strl);

Ien2=strlen(str2);

)

intnl,n2,another=0;//another表示是否有借位

inti.j;

Intcur_rs=0;

intcurMinus;

for(i=lenl-1,j=Ien2-1;i>=0&&j>=0;i-j-)

(

nl=strl[i]-'O';

n2=str2[j]-'O';

if(nl>=n2+another)

result[cur_rs++]=(nl-n2-another)+'O';

another=0;

)

else

(

result(cur_rs++]=(nl+10-n2-another)+'O';

another=1;

}

)

while(i>=0)

(

nl=strl[i-)-,0,;

if(another!=0)

(

nl-=another;

another=0;

result[cur_rs++]=nl+'O';

)

result[cur_rs]='\O';

cur_rs-remove_zero(result,cur_rs);

if(flag)

(

result[cur_rs++]=

result[cur_rs]='\O';

)

reverse(result,cur_rs);

returncur_rs;

)

voidaddi(constchar*numl,constchar*num2,char*result)

(

intlenl=strlen(numl);

intIen2=strlen(num2);

intrs_len;

if(!lenl||!len2)

return;

charstrl[100],str2(100];

strncpy(strl,numl,lenl);

strl[lenl]-'\0';

strncpy(str2,num2,Ien2);

str2[len2]=>\0';

if(strl[O]==&&str2[0]==,-)

(

move(strl,lenl);

move(str2,ler»2);

rsjen=real_add(strl,str2,result,false);

}elself(strl[O]==-)

(

move(strl,lenl);

rsjen=real_minus(str2,strl,result);

)

elseif(str2[0]==

move(str2,Ien2);

rsjen=real_minus(strl,str2,result);

}else

rs.len=real_add(strl,str2,result,true);

//intmain(intargc,char*argv[])

intmainQ

charnuml[100],num2(100];

printf（"请输入两个整型数据：\n"）;

scanf("%s%s",numl,num2);

charresult[100];

memset(result,0,100);

addi(numl,num2,result);

printf("%s\n",result);

return0;

}

11.描述：10介学生考完期末考试评卷完成后，A老师需要划出及格线，要求如下：

(1)及格线是10的倍数；

(2)确保同少有60%的学生及格;

(3)假如所有的学生都高于60分,则及格线为60分

输入：输入10个整数，取值0~100

输出：输出及格线，10的倍数

#include<stdio.h>

voidbubblesort(intarr[])

(

intij,temp;

for(i=0;i<10;i++)

for(j=0;j<9-i&&arrOJ>arr(j+l]j++)

(

temp=arr(j);

arr[j]=arrg+l];

arr[j+l]=temp;

)

intGetPassLine(inta[])

{

bubblesort(a);

if(a[0]>=60)

return60;

else

return(((int)a[4]/10)*10);

)

mainQ

(

inta[10]={0};

intresult;

prlntf，请随机输入10个成绩(0-100):\n-);

scanfC%d%d%d%d%d%d%d%d%d%d\&a(0)f&a(l),&a(2],&a(3],&a[4],&a(5],&a(6],&aP],&a[8]f&a[9J);

printf('\n");

result=GetPassLine(a);

printf。及格线为:%d\n”,result);

return1;

)

12.描述：一条长廊里依次装有n(l<n<65535)盏电灯，从头到尾编号1、2、3、n.每盏电灯由一个拉线

开关控制.开始，电灯所有关若。

有n个学生从长廊穿过.第一个学生把号码凡是1的倍数的电灯的开关拉一下；接着第二个学生把号码凡是2的倍数的

电灯的开关拉一下；接着第三个学生把号码凡是3的倍数的电灯的开关拉一下；如此继续下去，最后第n个中生把号码

凡是n的倍数的电灯的开关拉一下.n个学生按此要求走完后，长廊里电灯有几盏亮着.注：电灯数和学生数一致。

输入：电灯的数量

输出：亮着的电灯数量

样例输入：3

样例输出：1

#include<stdio.h>

#defineMax_Bubl_Num65535

intGetLightLampNum(intn)

{

intBublNum(Max_Bubl_Num]={O);//O表示灯灭，1表示灯亮

unsignedinti,j;

unsignedintcount=0;

for(i=l;i<=n;i++)

for(j=i;j<=n&&j%i==0;j++)

BublNum(j-l]+=l;

BublNum(j-l]=BublNum(i-l]%2;

)

for(intk=0;k<n;k++)

(

if(BublNum[k]==l)

count4+;

}

returncount;

)

intmaln()

(

intn,result;

printf(”请输入灯的数员(1-65535):\nB);

scanfC%d",&n);

result=GetLightLampNum(n);

printf（“最后亮灯的数量为:%d\M,result）;

return0;

）

13描述：已知2条地铁线路，其中A为环线，B为东西向线路，线路都是双向的。通

过的站点名分别如下，两条线交叉的换乘点用Tl、T2表示。编写程序，任意输入两个

站点名称，输出乘坐地铁最少需要通过的车站数量（含输入的起点和终点，换乘站点只

计算一次）。

地铁线A（环线）通过车站:AlA2A3A4A5A6A7A8A9T1A1OAllA12A13

T2A14A15A16A17A18

地铁线B（直线）通过车站:BlB2B3B4B5T1B6B7B8B9BIOT2BllB12B13

B14B15

输入：输入两个不一样的站名

输出：输出最少通过的站数，含输入的起点和终点，换乘站点只计算一次

输入样例：AlA3

输出样例：3

#include<stdio.h>

#include<string>

#include<queue>

#include<vector>

usingnamespacestd;

#defineMAX35

#defineSUBWAY,A20

#defineSUBWAY.B15

typedefstructnode{

intadjvex;

structnode*next;

Jedgenode;

typedefstruct{

charnameflO];

boolflag;

edgenode*link;

}vexnode;

constchar

,',,,,,,,,,

subway_namel[SUBWAY_AK10]={Al*,-A2",'A3","A4rA5,A6"/A7/A8,'A9",'Tl',A10,All","A12"/A13

「T2/A147Al5","A16/A17/A181

constchar

,"n',',,,,

subway_name2[SUBWAY_B][10]={"Bl'IB21'B3"1B4"/B5'/B6,B7,"B8","E9","B10/Bll,B12'rB13",-B14",

“B15»

voidcreat(vexnodega(]){

inti;

edgenode*p;

for(i=0;i<MAX;i++){

ga[i].link=NULL;

ga[i].flag-true;

if(i<SUBWAY_A)strcpy(ga(i).name,subway_namel(i]);

elsestrcpy(ga[i].name,subway_name2[i-20]);

)

〃A地铁建邻接表

for(i=l;i<SUBWAY_A-l;i++){

p=(edgenode*)malloc(si2eof(edgenode));

p->adjvex=i-l;

p->next=NULL;

ga[i].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=i+l;

p->next=NULL;

ga[i].link->next=p;

if(i==9)(

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+4;

p->next=NULL;

ga(i].link->next->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex-SUBWAY_A+5;

p->next=NULL;

ga[i].link->next->next->next=p;

}

elseif(i==14){

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+9;

p->next=NULL;

ga(i].link->next->next=p;

p=(edgenodeA)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+10;

p->next=NULL;

ga(i].link->next->next->next=p;

)

)

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A-l;

p->next=NULL;

ga[O].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex-l;

p->next=NULL;

ga[O].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A-2;

p->next=NULL;

ga(SUBWAY_A-l].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=O;

p->next=NULL;

ga[SUBWAY_A-l].link->next=p;

〃B地铁建邻接表

for(i=l;i<SUBWAY_B-l;i++){

if(i==4||i==5||i==9||i==13)continue;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+i-l;

p->next=NULL;

ga[i+SUBWAY_A].link=p;

p-(edgenode*)rY)alloc(si2eof(©dgenode));

p->adjvex=SUBWAY_A+i+l;

p->next=NULL;

ga(i+SUBWAY_A].link->next=p;

)

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+3;

p->next=NULL;

ga(SUBWAY_A+4].link=p;

p=(edgenode<)malloc(slzeof(edgenode));

p->adjvex=9;

p->next=NULL;

ga(SUBWAY_A+4].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=9;

p->next=NULL;

ga[SUBWAY_A+5].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+6;

p-、next-NULL;

ga(SUBWAY_A+5].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+8;

p->next=NULL;

ga(SUBWAY_A+9].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=14;

p->next=NULL;

ga(SUBWAY_A+9].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=14;

p->next=NULL;

ga(SUBWAY_A+10].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+ll;

p->next=NULL;

ga(SUBWAY_A+10].link->next=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+l;

p->next=NULL;

ga[SUBWAY_A].link=p;

p=(edgenode*)malloc(sizeof(edgenode));

p->adjvex=SUBWAY_A+SUBV/AY_B-2;

p->next=NULL;

ga[SUBWAY_A+SUBWAY_B-l].link=p；

//打印各邻接节点

for(i=0;i<MAX;i++){

printf("%s:*,ga[i].name);

edgenode*s;

s=ga(i].link;

while(s!=NULL){

printf(*->%s",ga(s->adjvex].name);

s=s->next;

}

printf(*\n');

)

)

intmain(){

vexnodega[MAX];

creat(ga);

inti;

charstr[2][10];

while(scanf("%s%s",str[O],str[l|)!=EOF){

intxemp=O;

for(i=0;i<MAX;i++){

ga[i].flag=true;

if(!strcmp(str[O],ga[i].name))temp=i;

)

queue<vexnode>q;

q.push(ga[templ);

ga(temp).flag=false;

intcount=0;

intstart=0;

intend=l;

boolfind_flag-false;

while(!q.empty()){

if(find_flag)break;

count++;

printf('************************\n*);

printfC第％d层搜索,count);

inttemp_end=end;

while(start<temp_end)(

printf("%s\);

if(!strcmp(q.front().name,str[l])){

find_flag=true;

break;

)

edgenode*s;

s=q.front().link;

while(s!=NULLX

if(ga[s->adjvex].flag){

q.push(ga[s->adjvex]);

ga[s->adjvex].flag=false;

end++;

//printf('%s',ga[s->adjvex].name);

}

s=s->next

)

qpopO;

start++;

)

printf(*\n');

)

printf("%d\n",count);

)

return0;

)

14.字串转换

问题描述：

将输入的字符串（字符串仅包括小写字母才到'z'），按照如下规则，循环转交后输出：a->b,b->c，…,y->z,z->a;

若输入的字符串连续出现两个字母相卮时，后一个字母需要连续转换2次。例如：aa转换为be,zz转换为ab;当连

续相同字母超出两个时，第三个出现的字母按第一次出现算.

要求实现函数：

voidconvert(char*input,char*output)

【饰入】char"input,临入的宁符串

【输出】char"output,输出的字符串

【返回】无

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

voidconvert(char*input,char*output)

(

lf(input==NULL)

return;

chartemp='\0';

intlen_input=strlen(input);

inti;

intflag=0;

for(i=0;i<len_input;i++)

if(input[i]!=temp)

(

output。]一(input川-'a'+l)%26+'a';

temp=input(i];

flag=l;

)

else

(

if(flag==l)

(

output[i]=(input[i]-'a'+2)%26+'a';

temp=lnput(i];

flag=0;

)

else

(

output[i]=(input[i]-'a'+l)%26+'a';

temp=input[i];

flag=l;

)

)

)

output[i]-,\0';

)

voidmain()

{

char*input='xyz";

charoutput[256];

//scanf("%s\input);

convert(input,output);

prlntf('%s\n",output);

)

15在给定字符串中找出单词("单词’由大写字母和4与字母字符组成,其修E字母字符视为单词的间隔，如空格、

问号、数字等等；另外单个字母不算单词)；找到单词后，按照长度进行降序排序，(排序时假如长度相同，则按出现

的次序进行排列)，然后输出到一个新的字符串中；假如某个单词里复出现数次，则只输出一次；假如整个输入的字符

串中没有找到单词，请输出空率.输出的单词之间使用一个"空格"隔开，最后一个单词后不加空格.

要求实现函数：

voidmy_word(charinput[],charoutput。)

【输入】charinput。,输入的字符串

【输出】charoutputQ,输出的字符串

【返回】无

#include〈string.h、

#include<stdlib.h>

#include<stdio.h>

voidmy_word(charinput。,charoutput。)

(

char*p;

char*temp;

char*word[10];

Intlen_input=strlen(lnput);

inti,j;

charexceptQ=

char*blank="

i=0;

for(i=O;i<len_input;i++)

if(input(i]<'A'||(input[i]>'Z'&&input(i]<(a,)||input[i]>'z')

input[i]='；;

)

)

j=0;

/*保存取出的单词*/

p=strtok(input.except);

while(NULL!=p)

{

word[j++]=p;

p=strtok(NULL,except);

)

for(i=0;i<5;i++)

printf('%s",word[i]);

/*对单词按照长度降序排序，冒泡法*/

for(i=0;i<5;i++)

for(j=l;j<5-ij++)

if(strlen(word[j-l])<strlen(word(j]))

temp=word[j];

word(j]-word[j-l];

word[j-l)=temp;

)

/•删除相同单词*/

for(i=0;i<5;i++)

{

for(j=i+lj<5;j++)

(

if(strcmp(word[i],word(j])==0)

word[j]="\0";

)

)

/,将单词连接起来输出♦/

forG=O;j<5;j++)

if(O==j)

(

strncpy(output,wordUL£trl@n(word(j])+l);

)

else

{

strcat(output,blank);

strcat(output,word(j])；

)

)

return;

}

intmain()

{

charinputn="somelocalbuses,somel234123drivers";

printfC•筛选之前的字符串:％s'n'input);

charoutput(30];

my_word(input,output);

printf(•筛选之后的字符串:%s'output);

printfC\n");

return0;

)

16.数组中数字都两两相同，只有一个不一样，找出该数字：

intfindUnique(int*a,intlen)

(

inti=1;

inttemp=a[0];

for(;i<len;i++)

{

temp=tempAa[i];

)

printf(n%d",temp);

)

17.题目二：数组中数字前两相同，有两个不一样，找出这两个:

#include<stdlib.h>

inta[]={L124,3,325};

intfindXorSum(int*a,intlen)

(

inti=0;

inttemp=0;

for(;i<len;i++)

{

temp=tempAa[i];

)

returntemp;

)

intfindFirstBitl(intn)

(

intcount=1;

while(!(n&1))

(

n=n>>l;

count++；

)

returncount;

)

intisBitl(inta,intcount)

(

a=a>>count-1;

return(a&1);

)

voidfindTwoUnique(int*a,intlen)

(

inti=0;

intm=0,n=0;

inttemp=findXorSum(a,len);

intcount=findFirstBitl(temp);

for(;i<len;i++)

if(isBitl(a[i],count))

m=mAa[i];

}

else

{

n=nAa[i];

)

)

printf("%d,%d\m,n);

)

intmain()

(

findTwoUnique(az8);

)

18.链表翻转。给出一个链表和一个数k,例如链表1—27-4-5-6,k=2,则翻转后2

-I-4T3-6T5，若k=3,翻转后3一2一1一6一5一4，若k=4,翻转后4T3-2-1-5

一6,用程序实现

思想：采取遍历链表，提成length/k组，对每组进行逆转，逆转的同时要将逆转后的尾和头连接起来

//#include'stdafx.h'

#include'stdio.h*

*include,s