C语言算法面试高频题（含详细答案解析）

C语言算法面试高频题（含详细答案解析）本次整理为互联网企业C语言算法面试高频原题，涵盖数组、字符串、链表、递归、排序、查找六大核心考点，题目难度贴合初级、中级开发面试，代码可直接编译运行，解析通俗易懂，无冗余理论，适配面试备考、笔试刷题。一、基础算法题（笔试必考）题目1：反转整数（简单）题目描述：给一个32位有符号整数x，返回将x中的数字部分反转后的整数。如果反转后的整数超出32位有符号整数的范围[-2³¹,2³¹-1]，返回0。示例：输入123，输出321；输入-123，输出-321；输入120，输出21c

#include<stdio.h>

#include<limits.h>

intreverse(intx){

intres=0;

while(x!=0){

//取末尾数字

inttail=x%10;

//溢出预判：正数最大值/10小于当前结果||等于且尾数大于7

if(res>INT_MAX/10||(res==INT_MAX/10&&tail>7)){

return0;

}

//负数最小值/10大于当前结果||等于且尾数小于-8

if(res<INT_MIN/10||(res==INT_MIN/10&&tail<-8)){

return0;

}

res=res*10+tail;

x=x/10;

}

returnres;

}

intmain(){

intnum;

scanf("%d",&num);

printf("%d\n",reverse(num));

return0;

}详细解析：1.核心思路：循环取数字末尾位，逐步拼接成新数，每次循环将原数除以10消去末尾位；2.关键难点：整数溢出判断。不能等拼接完成再判断，必须每一步预判。32位int最大值为2147483647，最小值为-2147483648；3.无需单独处理负数，取模运算会自动保留符号，逻辑统一；4.时间复杂度O(logn)，n为输入数字，循环次数为数字位数。题目2：回文数判断（简单）题目描述：给一个整数，判断该数是否为回文数。回文数指正读和反读完全相同的整数，负数默认不是回文数。示例：输入121，输出1（是）；输入-121，输出0（否）；输入10，输出0（否）c

#include<stdio.h>

intisPalindrome(intx){

//负数、末尾为0的非0数直接排除

if(x<0||(x%10==0&&x!=0)){

return0;

}

intreverseNum=0;

//只反转一半数字，减少运算

while(x>reverseNum){

reverseNum=reverseNum*10+x%10;

x=x/10;

}

//偶数位：前后相等；奇数位：去掉中间位后相等

returnx==reverseNum||x==reverseNum/10;

}

intmain(){

intnum;

scanf("%d",&num);

printf("%d\n",isPalindrome(num));

return0;

}详细解析：1.特殊场景过滤：负数一定不是回文数；末尾为0的数，首位不可能为0，直接排除；2.优化思路：无需反转全部数字，只反转后半段，对比前半段即可，提升效率；3.奇偶处理：偶数位数前后两段完全相等，奇数位数反转后的数去掉最后一位（中间位）后相等；4.时间复杂度O(logn)，空间复杂度O(1)。二、数组与字符串算法（高频笔试）题目3：两数之和（简单，面试经典）题目描述：给定一个整数数组nums和一个目标值target，请在数组中找出和为目标值的两个整数，返回它们的数组下标。假设每个输入只对应一个答案，同一个元素不能重复使用。示例：nums=[2,7,11,15],target=9，返回[0,1]c

#include<stdio.h>

//返回数组下标

voidtwoSum(int*nums,intnumsSize,inttarget,int*res){

//双层循环遍历

for(inti=0;i<numsSize;i++){

for(intj=i+1;j<numsSize;j++){

if(nums[i]+nums[j]==target){

res[0]=i;

res[1]=j;

return;

}

}

}

}

intmain(){

intnums[]={2,7,11,15};

intres[2]={0};

twoSum(nums,4,9,res);

printf("%d%d\n",res[0],res[1]);

return0;

}详细解析：1.基础解法：双层for循环，固定第一个数，遍历后续所有数，匹配和为target的组合；2.下标规则：j从i+1开始，避免重复使用同一个元素，同时避免重复匹配；3.输出方式：通过数组传参返回结果（C语言无多返回值，数组传参为地址传递）；4.时间复杂度O(n²)，空间复杂度O(1)，适合笔试快速解题，面试可延伸哈希优化解法。题目4：字符串反转（原地修改）题目描述：给定一个字符数组（字符串），原地反转字符串，不使用额外数组空间。示例：输入["h","e","l","l","o"]，输出["o","l","l","e","h"]c

#include<stdio.h>

#include<string.h>

voidreverseString(char*s,intsSize){

intleft=0;

intright=sSize-1;

//双指针交换

while(left<right){

chartemp=s[left];

s[left]=s[right];

s[right]=temp;

left++;

right--;

}

}

intmain(){

charstr[]="hello";

intlen=strlen(str);

reverseString(str,len);

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

return0;

}详细解析：1.核心思路：双指针法，左指针从头部、右指针从尾部开始，两两交换字符；2.原地修改：仅使用一个临时变量，无额外内存开销，空间复杂度O(1)；3.循环终止条件：left>=right时，所有字符交换完成，避免中间字符重复交换；4.时间复杂度O(n)，n为字符串长度。三、排序与查找算法（核心面试考点）题目5：二分查找（有序数组）题目描述：给定一个升序排列的整数数组nums和一个目标值target，返回目标值在数组中的下标，若不存在返回-1。示例：nums=[-1,0,3,5,9,12],target=9，返回4；target=2，返回-1c

#include<stdio.h>

intsearch(int*nums,intnumsSize,inttarget){

intleft=0;

intright=numsSize-1;

while(left<=right){

//避免溢出，不使用(left+right)/2

intmid=left+(right-left)/2;

if(nums[mid]==target){

returnmid;

}elseif(nums[mid]<target){

//目标在右区间

left=mid+1;

}else{

//目标在左区间

right=mid-1;

}

}

return-1;

}

intmain(){

intnums[]={-1,0,3,5,9,12};

printf("%d\n",search(nums,6,9));

return0;

}详细解析：1.适用场景：仅针对有序数组，是面试必考查找算法；2.防溢出优化：mid=left+(right-left)/2替代(left+right)/2，避免左右下标过大导致整数溢出；3.区间更新：匹配不到时，缩小区间必须±1，否则会出现死循环；4.时间复杂度O(logn)，远优于遍历查找，空间复杂度O(1)。题目6：冒泡排序（手写实现）题目描述：手写冒泡排序算法，对int数组进行升序排序，优化版（减少无效循环）。c

#include<stdio.h>

voidbubbleSort(int*nums,intn){

//外层控制排序轮数

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

//标记本轮是否发生交换，优化有序数组场景

intflag=0;

//内层两两比较，每轮结束末尾i个数字已有序

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

if(nums[j]>nums[j+1]){

inttemp=nums[j];

nums[j]=nums[j+1];

nums[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);

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

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

}

return0;

}详细解析：1.算法原理：相邻元素两两对比，逆序则交换，每轮排序将当前最大值冒泡到数组末尾；2.优化点：加入flag标记，若某一轮无任何交换，证明数组已经完全有序，直接终止循环；3.边界优化：内层循环无需遍历已排序的末尾元素，减少循环次数；4.时间复杂度：最坏O(n²)，最优O(n)（有序数组），空间复杂度O(1)，稳定排序。四、链表算法（面试高频手写题）题目7：单链表反转（重中之重）题目描述：给一个单链表头节点，反转整个链表，返回反转后的头节点。c

#include<stdio.h>

#include<stdlib.h>

//定义链表节点

structListNode{

intval;

structListNode*next;

};

//迭代法反转链表

structListNode*reverseList(structListNode*head){

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

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

while(cur!=NULL){

//保存后续节点

structListNode*next=cur->next;

//反转当前节点指针

cur->next=pre;

//前驱、当前节点后移

pre=cur;

cur=next;

}

//pre为新链表头节点

returnpre;

}

//创建新节点

structListNode*createNode(intval){

structListNode*node=(structListNode*)malloc(sizeof(structListNode));

node->val=val;

node->next=NULL;

returnnode;

}

//遍历打印链表

voidprintList(structListNode*head){

while(head!=NULL){

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

head=head->next;

}

}

intmain(){

//构建链表1->2->3->4->5

structListNode*head=createNode(1);

head->next=createNode(2);

head->next->next=createNode(3);

structListNode*newHead=reverseList(head);

printList(newHead);

return0;

}详细解析：1.核心思路：迭代法，用三个指针pre、cur、next逐个反转节点指向；2.步骤拆解：先保存下一个节点→将当前节点指向前驱节点→前驱、当前节点依次后移；3.初始状态：pre为NULL，原链表尾节点反转后指向NULL，符合链表规则；4.结束条件：cur遍历到NULL时，pre指向最后一个节点，即新链表头节点；5.时间复杂度O(n)，空间复杂度O(1)，