常见的C语言面试编程题.docx

常见的C语言面试编程题.docx

《常见的C语言面试编程题.docx》由会员分享，可在线阅读，更多相关《常见的C语言面试编程题.docx（18页珍藏版）》请在冰豆网上搜索。

常见的C语言面试编程题

常见的C语言面试编程题

（1）求n的阶乘，这是一个比较简单的题目，有很多方法，但用递归方法是最简单的了:

#include#include

intmain（）

{

longfactorial（longn）;

longn;

scanf（"%ld",&n）;

printf（"%ld",factorial（n））;

return0;

}

longfactorial（longd）//求阶乘

{

longm;

if（d<0）

{

printf（"d的阶乘不存在!

"）;

}

elseif（d==0||d==1）

{

m=1;

}

else

{

m=d*factorial（d-1）;

}

returnm;

}

（2）从一个文件读取整数，对其进行排序，然后再将排序的结果输入到原来文件当中，这

是一个经常考的题目，即考你的文件操作，又考了排序，我在这里用的是选择排序

#include#include

intreadtoarray（int*a,FILE*fp）//从文件里将整数读到数组里{

inti=0;

if（fp==NULL）

{

exit（0）;

}

while（fgetc（fp）!

=EOF）

{

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

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

i++;

}

returni;

}

voidwritetofile（inta[],FILE*fp,inti）//将数组写到文件里去

{

intk=0;

if（fp==NULL）

{

exit（0）;

}

while（k

{

fprintf（fp,"%c%d",'',a[k++]）;

}

}

voidselectionSort（int*a,inti）//选择排序{

intm,n;

inttmp,min;

for（m=0;m

{

min=m;

for（n=m+1;n

{

if（a[n]

min=n;

}

tmp=a[m];

a[m]=a[min];

a[min]=tmp;

}

}

intmain（）

{

FILE*fp,*fpwrite;

inti;

inta[10];

fp=fopen（"2.txt","r"）;

i=readtoarray（a,fp）;

fclose（fp）;

selectionSort（a,i）;

fpwrite=fopen（"2.txt","w"）;

writetofile（a,fpwrite,i）;

fclose（fpwrite）;

return0;

}

1，单向链表的插入，删除，逆序操作

#include

#include

typedefstructNode{

intkey;

structNode*next;}*node;

nodenewNode（intk）{

noden=（node）malloc（sizeof（node））;

n->key=k;

n->next=NULL;

returnn;

}

voidprintlist（noden）{

if（!

n）

{

printf（"nisNULLlist\n"）;

}

while（n）

{

printf（"%d",n->key）;

printf（""）;

n=n->next;

}

printf（"\n"）;

}

nodenewList（）

{

intk;

nodehead=（node）malloc（sizeof（node））;;

scanf（"%d",&k）;

if（k==0）

{

head=NULL;

returnhead;

}

else

{

noden=newNode（k）;

head=n;

while（k）

{

scanf（"%d",&k）;

if（k!

=0）

{

noden1=newNode（k）;

n->next=n1;

n=n->next;

}

}

n->next=NULL;

returnhead;

}

}

nodeinsertNode（noden,intp,intk）

{

noden1=newNode（k）;

nodehead=（node）malloc（sizeof（node））;

head=n;

if（head==NULL）

{

n1->next=head;

returnn1;

}

else

{

if（p==1）

{

n1->next=head;

head=n1;

returnhead;

}

else

{

inti=2;

while（i!

=p&&（n->next））

{

n=n->next;

i++;

}

if（n->next==NULL）

{

printf（"thepcan'tbefound\n"）;

returnhead;

}

else

{

n1->next=n->next;

n->next=n1;

returnhead;

}

}

}

}

nodedeleteNode（noden,intk）

{

noden1=（node）malloc（sizeof（node））;

nodehead=（node）malloc（sizeof（node））;

head=n;

if（head==NULL）

{

printf（"listisNULL\n"）;

returnhead;

}

else

{

if（head->key==k）

{

head=head->next;

returnhead;

}

while（n->key!

=k&&n->next）

{

n1=n;

n=n->next;

}

if（n==NULL）

{

printf（"can'tfindthesamevalueaskinthislist\n"）;

returnhead;

}

else

{

n1->next=n->next;

n=NULL;

returnhead;

}

}

}

nodereverse（noden）{

noden1[10];

nodehead=（node）malloc（sizeof（node））;

noden2=（node）malloc（sizeof（node））;

head=n;

if（head==NULL）

{

returnhead;

}

else

{

inti=0;

while（head!

=NULL）

{

n2=head;

head=head->next;

n2->next=NULL;

n1[i]=n2;

i++;

}

head=n1[i-1];

for（intj=i-1;j>0;j--）

{

n1[j]->next=n1[j-1];

}

returnhead;

}

}

intmain（）

{

noden=newList（）;

printlist（n）;

//插入操作

intk,p;

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

nodenn=insertNode（n,p,k）;

printlist（nn）;

//删除操作

intq;

scanf（"%d",&q）;

nodend=deleteNode（nn,q）;

printlist（nd）;

//链表的倒置操作

nodem=reverse（n）;

printlist（m）;

return0;

}

2，双向链表的插入删除操作

#include#include

typedefstructNode{

intkey;

structNode*pre;

structNode*next;

}*node;

nodenewNode（inti）{

noden=（node）malloc（sizeof（node））;

n->key=i;

n->pre=NULL;

n->next=NULL;

returnn;

}

nodenewduplinklist（）{

inti;

scanf（"%d",&i）;

noden;

if（i==0）

{

n=NULL;

returnn;

}

n=newNode（i）;

nodehead=n;

intk=1;

while（k!

=0）

{

scanf（"%d",&k）;

if（k!

=0）

{

noden1=newNode（k）;

n->next=n1;

n1->pre=n;

n=n1;

}

}

n->next=head;

head->pre=n;

returnhead;

}

intsizeduplinklist（noden）

{if（n==NULL）return0;

nodehead=n;

inti=1;

while（head->next!

=n）

{

head=head->next;

i++;

}

returni;

}

voidprint（noden）{

if（n==NULL）

printf（"此时链表为空!

"）;

else

{

printf（"输出链表:

\n"）;

for（inti=0;i

{

printf（"%-2d",n->key）;

n=n->next;

}

printf（"\n"）;

}

}

nodeinsertNode（noden）{

intp,k;

printf（"插入位置p:

\n"）;

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

printf（"\n"）;

if（p>sizeduplinklist（n））

{

printf（"此位置超出链表的长度!

\n"）;

returnn;

}

elseif（p<1）

{

printf（"此位置不存在!

\n"）;

returnn;

}

else

{

noden1,head,m;

m=newNode（k）;

head=n;

if（p==1）

{

m->pre=n->pre;

n->pre->next=m;

m->next=n;

n->pre=m;

returnm;

}

else

{

inti=1;

while（i!

=p）

{

n1=n;

n=n->next;

i++;

}

n1->next=m;

m->pre=n1;

m->next=n;

n->pre=m;

returnhead;

}

}

}

nodedelNode（noden）

{

intp;

printf（"删除位置p:

\n"）;

scanf（"%d",&p）;

printf（"\n"）;

if（p>sizeduplinklist（n））

{

printf（"此位置超出链表的长度!

\n"）;

returnn;

}

elseif（p<1）

{

printf（"此位置不存在!

\n"）;

returnn;

}

else

{

noden1,head;

if（p==1）

{head=n->next;

n->pre->next=n->next;

n->next->pre=n->pre;

returnhead;

}

else

{

head=n;

inti=1;

while（i!

=p）

{

n1=n;

n=n->next;

i++;

}

n1->next=n->next;

n->next->pre=n1;

returnhead;

}

}

}

intmain（）

{

noden=newduplinklist（）;

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

print（n）;

nodem=insertNode（n）;print（m）;

nodem1=delNode（m）;print（m1）;

return0;

}

3，栈操作，用数组实现的包含出栈，入栈的操作

#include#include

typedefstructSta{

inta[20];

intnum;

}*sta;

staNullStack（）

{

stas=（sta）malloc（sizeof（sta））;

s->num=0;

returns;

}

stapushstack（stas,inti）

{

s->a[s->num]=i;

s->num=s->num+1;

returns;

}

stapopstack（stas）{

if（s->num==0）

{

printf（"stackisNULL\n"）;

returns;

}

s->num=s->num-1;

returns;

}

voidprintstack（stas）{

if（s->num==0）

{

printf（"stackisNULL\n"）;

}

else

{

for（inti=s->num-1;i>=0;i--）

{

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

}

}

}

intmain（）

{

stas=NullStack（）;s=pushstack（s,1）;s=pushstack（s,2）;printstack（s）;

s=popstack（s）;

s=popstack（s）;

printstack（s）;

return0;

}

4，队列操作，类似于栈，

#include#include

typedefstructQue{

inta[20];

intnum;

}*que;

queNullQueue（）{

queq=（que）malloc（sizeof（que））;

q->num=0;

returnq;

}

queenq（queq,inti）{

q->a[q->num]=i;

q->num=q->num+1;

returnq;

}

quedeq（queq）

{

if（q->num==0）

{

printf（"queueisNULL\n"）;

returnq;

}

for（inti=1;inum;i++）

{

q->a[i-1]=q->a[i];

}

q->num=q->num-1;

returnq;

}

voidprintqueue（queq）{

if（q->num==0）

{

printf（"queueisNULL\n"）;

}

else

{

for（inti=q->num-1;i>=0;i--）

{

printf（"%3d",q->a[i]）;

}

}

}

intmain（）

{

queq=NullQueue（）;q=enq（q,1）;

q=enq（q,2）;

q=enq（q,3）;

q=enq（q,4）;

printqueue（q）;

printf（"\n"）;

q=deq（q）;

//printf（"%d",s->a[0]）;

//q=deq（q）;

printqueue（q）;

return0;

}