C语言算法面试真题及详细答案（职场实战版）

C语言算法面试真题及详细答案（职场实战版）本次题库精选互联网、嵌入式后端通用C语言算法面试高频题，涵盖基础语法算法、数组操作、字符串处理、链表算法、经典排序、查找算法，所有答案均为手写实战代码，解析通俗易懂，贴合真实面试答题逻辑，无冗余理论套话。一、基础算法题（入门高频）题目1：斐波那契数列（求第n项值）题目描述：斐波那契数列规则：第一项、第二项均为1，从第三项开始，每一项等于前两项之和。输入整数n，输出数列第n项的值。要求分别实现递归、非递归两种写法。解题思路：1.递归：利用数列递推公式f(n)=f(n-1)+f(n-2)，设置边界条件n=1、n=2时返回1；优点是代码简洁，缺点是n较大时重复计算多，效率低。2.非递归：通过循环迭代，用变量保存前两项数值，逐次累加，时间复杂度O(n)，空间复杂度O(1)，工程中优先使用。完整代码+答案：c

#include<stdio.h>

//递归写法

intfibRecursion(intn)

{

if(n==1||n==2)

{

return1;

}

returnfibRecursion(n-1)+fibRecursion(n-2);

}

//非递归（迭代）写法

intfibLoop(intn)

{

if(n==1||n==2)

{

return1;

}

inta=1,b=1,res;

for(inti=3;i<=n;i++)

{

res=a+b;

a=b;

b=res;

}

returnres;

}

intmain()

{

intn;

scanf("%d",&n);

printf("递归结果：%d\n",fibRecursion(n));

printf("迭代结果：%d\n",fibLoop(n));

return0;

}面试加分点：面试中需主动说明两种写法的优缺点，迭代法适合大数据量，递归法逻辑简洁但存在栈溢出风险。题目2：判断素数（质数）题目描述：输入一个正整数，判断该数是否为素数（素数定义：大于1，且只能被1和自身整除的整数）。解题思路：1.小于2的数直接判定为非素数；2是最小的素数；2.偶数（除2外）全部是非素数，可提前过滤，减少循环次数；3.只需遍历2到根号n即可，若n存在大于根号n的因数，必然对应一个小于根号n的因数，无需遍历全部数值。完整代码+答案：c

#include<stdio.h>

#include<math.h>

intisPrime(intnum)

{

//小于2不是素数

if(num<2)

return0;

//2是素数

if(num==2)

return1;

//偶数不是素数

if(num%2==0)

return0;

//遍历根号内的奇数

intlen=sqrt(num);

for(inti=3;i<=len;i+=2)

{

if(num%i==0)

return0;

}

return1;

}

intmain()

{

intnum;

scanf("%d",&num);

if(isPrime(num))

printf("%d是素数\n",num);

else

printf("%d不是素数\n",num);

return0;

}二、数组与字符串算法（面试必考）题目3：数组逆序输出题目描述：自定义一个整型数组，实现数组元素原地逆序，不借助额外数组，输出逆序后的结果。解题思路：利用双指针法，首尾元素两两交换，左指针从0开始，右指针从数组末尾开始，指针相遇时结束循环，原地修改数组，空间复杂度最优。完整代码+答案：c

#include<stdio.h>

//数组逆序函数

voidreverseArr(intarr[],intlen)

{

intleft=0;

intright=len-1;

//首尾交换

while(left<right)

{

inttemp=arr[left];

arr[left]=arr[right];

arr[right]=temp;

left++;

right--;

}

}

intmain()

{

intarr[]={1,2,3,4,5,6};

intlen=sizeof(arr)/sizeof(arr[0]);

reverseArr(arr,len);

//输出结果

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

{

printf("%d",arr[i]);

}

return0;

}输出结果：654321题目4：字符串反转（手动实现，禁止调用库函数）题目描述：输入一个字符串，手动编码实现字符串反转，不使用strrev等系统库函数。解题思路：先遍历字符串获取长度，再沿用双指针交换思路，交换首尾字符，实现原地反转。完整代码+答案：c

#include<stdio.h>

voidreverseStr(charstr[])

{

//计算字符串长度

intlen=0;

while(str[len]!='\0')

{

len++;

}

//双指针交换

intleft=0,right=len-1;

while(left<right)

{

chartemp=str[left];

str[left]=str[right];

str[right]=temp;

left++;

right--;

}

}

intmain()

{

charstr[100];

scanf("%s",str);

reverseStr(str);

printf("反转后：%s\n",str);

return0;

}题目5：移除数组重复元素题目描述：给定一个有序整型数组，原地移除重复元素，只保留唯一元素，返回去重后的数组长度，无需考虑超出新长度后的元素。解题思路：快慢指针法。慢指针记录唯一元素位置，快指针遍历数组，当快慢指针元素不同时，快指针元素覆盖慢指针下一位，完成去重。完整代码+答案：c

#include<stdio.h>

intremoveDuplicate(intarr[],intlen)

{

if(len==0)

return0;

intslow=0;

for(intfast=1;fast<len;fast++)

{

if(arr[fast]!=arr[slow])

{

slow++;

arr[slow]=arr[fast];

}

}

returnslow+1;

}

intmain()

{

intarr[]={1,1,2,2,3,3,4};

intlen=sizeof(arr)/sizeof(arr[0]);

intnewLen=removeDuplicate(arr,len);

printf("去重后长度：%d\n",newLen);

printf("去重数组：");

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

{

printf("%d",arr[i]);

}

return0;

}输出结果：去重后长度：4去重数组：1234三、经典排序算法（面试核心）题目6：手写冒泡排序题目描述：手动实现冒泡排序，对整型数组进行升序排序，优化冒泡排序的无效循环。解题思路：相邻元素两两比较，逆序则交换，每轮循环将最大值冒泡到末尾；设置标记位，若某一轮无交换，说明数组已有序，直接退出循环，优化时间效率。完整代码+答案：c

#include<stdio.h>

voidbubbleSort(intarr[],intlen)

{

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

{

intflag=0;//标记本轮是否交换

for(intj=0;j<len-1-i;j++)

{

if(arr[j]>arr[j+1])

{

inttemp=arr[j];

arr[j]=arr[j+1];

arr[j+1]=temp;

flag=1;

}

}

//无交换则直接结束

if(flag==0)

break;

}

}

intmain()

{

intarr[]={5,2,9,1,5,6};

intlen=sizeof(arr)/sizeof(arr[0]);

bubbleSort(arr,len);

printf("排序后：");

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

{

printf("%d",arr[i]);

}

return0;

}算法复杂度：最优O(n)，最坏O(n²)，稳定排序。题目7：手写快速排序题目描述：实现经典快速排序，数组升序排列。解题思路：选取基准值，将数组分为左右两部分，左侧元素小于基准值，右侧大于基准值，递归排序左右子数组，是工程中最常用的排序算法。完整代码+答案：c

#include<stdio.h>

voidquickSort(intarr[],intleft,intright)

{

if(left>=right)

return;

inti=left,j=right;

intbase=arr[left];//选取最左侧为基准值

while(i<j)

{

//从右往左找小于基准的值

while(i<j&&arr[j]>=base)

j--;

arr[i]=arr[j];

//从左往右找大于基准的值

while(i<j&&arr[i]<=base)

i++;

arr[j]=arr[i];

}

arr[i]=base;//基准值归位

//递归排序左右区间

quickSort(arr,left,i-1);

quickSort(arr,i+1,right);

}

intmain()

{

intarr[]={3,1,4,2,7,5};

intlen=sizeof(arr)/sizeof(arr[0]);

quickSort(arr,0,len-1);

printf("快排结果：");

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

{

printf("%d",arr[i]);

}

return0;

}算法复杂度：平均O(nlogn)，最坏O(n²)，不稳定排序，实际运行效率最高。四、链表算法（高阶面试题）题目8：单链表反转题目描述：定义单链表结构，迭代法实现单链表整体反转，返回反转后的链表头节点。解题思路：定义三个指针，前驱、当前、后继，逐次改变节点指向，让当前节点指向前驱节点，依次遍历完成整体反转，无额外空间开销。完整代码+答案：c

#include<stdio.h>

#include<stdlib.h>

//定义单链表节点

structListNode

{

intval;

structListNode*next;

};

//链表反转函数

structListNode*reverseList(structListNode*head)

{

structListNode*pre=NULL;//前驱节点

structListNode*cur=head;//当前节点

structListNode*next=NULL;//后继节点

while(cur!=NULL)

{

next=cur->next;//保存后继节点

cur->next=pre;//反转指向

pre=cur;//前驱后移

cur=next;//当前后移

}

returnpre;//pre为新的头节点

}

//打印链表

voidprintList(structListNode*head)

{

structListNode*p=head;

while(p!=NULL)

{

printf("%d",p->val);

p=p->next;

}

}

intmain()

{

//手动创建链表1->2->3->4

structListNoden1={1,NULL};

structListNoden2={2,NULL};

structListNoden3={3,NULL};

structListNoden4={4,NULL};

n1.next=&n2;

n2.next=&n3;

n3.next=&n4;

structListNode*newHead=reverseList(&n1);

printf("反转后链表：");

printList(newHead);

return0;

}输出结果：4321五、查找算法题目9：二分查找（折半查找）题目描述：在有序数组中实现二分查找，输入目标值，返回数组下标，未找到返回-1。解题思路：针对有序数组，每次取中间值对比目标值，缩小一半查找区间，大幅提升查找效率。完整代码+答案：c

#include<stdio.h>

intbinarySearch(intarr[],intlen,inttarget)

{

intleft=0;

intright=len-1;

while(left<=right)

{

intmid=left+(right-left)