NET 算法面试题（含详细真实面试答案）

.NET算法面试题（含详细真实面试答案）说明：所有题目为后端.NET岗位校招/社招高频笔试、手撕面试题，答案为工程化手写代码，贴合C#实际开发场景，无冗余话术，适配面试官打分标准。一、基础算法（必问基础）1.斐波那契数列（递归+非递归实现，面试高频）题目：输入n，输出斐波那契数列第n项，数列规则：F(1)=1，F(2)=1，F(n)=F(n-1)+F(n-2)解题思路：递归写法简单但存在重复计算，n较大时效率低；工作中优先用迭代非递归方式，时间复杂度O(n)，空间复杂度O(1)。参考答案（C#）csharp

//非递归（工程常用，推荐）

publicstaticintFib(intn)

{

if(n<=0)return0;

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

inta=1,b=1,res=0;

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

{

res=a+b;

a=b;

b=res;

}

returnres;

}

//递归写法（面试备用，需说明弊端）

publicstaticintFibRecursion(intn)

{

if(n<=0)return0;

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

returnFibRecursion(n-1)+FibRecursion(n-2);

}面试加分话术：递归写法时间复杂度是指数级，大量重复递归栈帧，n超过35就会明显卡顿，生产环境一律用迭代写法，也可通过数组缓存实现动态规划优化。2.判断一个数是否为质数题目：输入正整数，判断是否是质数（只能被1和自身整除的大于1的整数）解题思路：无需遍历到n，只需遍历到根号n即可，减少循环次数；小于2的数直接判定非质数。参考答案（C#）csharp

publicstaticboolIsPrime(intnum)

{

if(num<2)returnfalse;

//遍历到平方根，优化效率

for(inti=2;i*i<=num;i++)

{

if(num%i==0)

returnfalse;

}

returntrue;

}二、字符串高频算法题（.NET面试核心）1.字符串反转（不使用自带Reverse方法）题目：手写代码实现字符串反转，禁止调用C#内置反转方法解题思路：字符串转字符数组，双指针头尾交换，最后拼接为字符串，是面试最标准解法。参考答案（C#）csharp

publicstaticstringReverseString(stringstr)

{

if(string.IsNullOrEmpty(str))

returnstr;

char[]chars=str.ToCharArray();

intleft=0;

intright=chars.Length-1;

while(left<right)

{

//交换头尾字符

chartemp=chars[left];

chars[left]=chars[right];

chars[right]=temp;

left++;

right--;

}

returnnewstring(chars);

}2.统计字符串中每个字符出现的次数题目：输入任意字符串，输出每个字符的出现次数，区分大小写解题思路：利用Dictionary键值对存储字符和次数，遍历字符串逐一统计，.NET后端高频业务算法。参考答案（C#）csharp

publicstaticDictionary<char,int>CountChar(stringstr)

{

Dictionary<char,int>dic=newDictionary<char,int>();

if(string.IsNullOrEmpty(str))

returndic;

foreach(varcinstr)

{

if(dic.ContainsKey(c))

{

dic[c]++;

}

else

{

dic.Add(c,1);

}

}

returndic;

}3.判断字符串是否为回文字符串题目：判断一个字符串正读和反读是否一致解题思路：双指针法，头尾字符依次对比，全程无需额外开辟数组，空间复杂度O(1)。参考答案（C#）csharp

publicstaticboolIsPalindrome(stringstr)

{

if(string.IsNullOrEmpty(str))

returntrue;

intleft=0;

intright=str.Length-1;

while(left<right)

{

if(str[left]!=str[right])

returnfalse;

left++;

right--;

}

returntrue;

}三、数组高频算法题1.数组去重（手写实现，不用Distinct）题目：手写int数组去重逻辑，禁止使用LINQDistinct方法解题思路：遍历原数组，用集合存储已出现的元素，自动过滤重复值，最后转为数组。参考答案（C#）csharp

publicstaticint[]RemoveDuplicate(int[]arr)

{

if(arr==null||arr.Length==0)

returnnewint[0];

List<int>list=newList<int>();

foreach(variteminarr)

{

if(!list.Contains(item))

{

list.Add(item);

}

}

returnlist.ToArray();

}2.两数之和题目：给定一个整数数组和一个目标值，找出数组中两个相加等于目标值的元素下标，假设仅有一组解解题思路：用哈希表存储遍历过的值和下标，一次遍历即可完成，时间复杂度O(n)，优于双层循环。参考答案（C#）csharp

publicstaticint[]TwoSum(int[]nums,inttarget)

{

Dictionary<int,int>dic=newDictionary<int,int>();

for(inti=0;i<nums.Length;i++)

{

inttemp=target-nums[i];

if(dic.ContainsKey(temp))

{

//返回之前存储的下标和当前下标

returnnewint[]{dic[temp],i};

}

if(!dic.ContainsKey(nums[i]))

{

dic.Add(nums[i],i);

}

}

returnnewint[0];

}3.找出数组最大值、最小值题目：手写代码找出int数组的最大值和最小值，不用自带Max/Min方法参考答案（C#）csharp

publicstaticvoidGetMaxMin(int[]arr,outintmax,outintmin)

{

max=arr[0];

min=arr[0];

for(inti=1;i<arr.Length;i++)

{

if(arr[i]>max)max=arr[i];

if(arr[i]<min)min=arr[i];

}

}四、经典排序算法（.NET必考手撕）1.冒泡排序原理：相邻元素两两对比，大的往后排，每轮循环确定一个最大值，双层循环实现。参考答案（C#）csharp

publicstaticvoidBubbleSort(int[]arr)

{

if(arr==null||arr.Length<=1)return;

for(inti=0;i<arr.Length-1;i++)

{

for(intj=0;j<arr.Length-1-i;j++)

{

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

{

//交换

inttemp=arr[j];

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

arr[j+1]=temp;

}

}

}

}2.快速排序（面试重点）原理：选取基准值，将数组分为左右两部分，小于基准值放左边，大于放右边，递归排序左右区间，平均时间复杂度O(nlogn)，工程最常用。参考答案（C#）csharp

publicstaticvoidQuickSort(int[]arr,intleft,intright)

{

if(left>=right)return;

//取最左侧为基准值

inttemp=arr[left];

intl=left;

intr=right;

while(l<r)

{

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

while(l<r&&arr[r]>=temp)

r--;

arr[l]=arr[r];

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

while(l<r&&arr[l]<=temp)

l++;

arr[r]=arr[l];

}

//基准值归位

arr[l]=temp;

//递归排序左右区间

QuickSort(arr,left,l-1);

QuickSort(arr,l+1,right);

}五、链表基础算法（后端中级岗必考）1.单链表反转题目：手写实现单链表反转，遍历迭代法（最优解）解题思路：定义前驱、当前、后继节点，逐个改变节点指向，无递归栈溢出风险。参考答案（C#）csharp

//定义链表节点

publicclassListNode

{

publicintVal{get;set;}

publicListNodeNext{get;set;}

publicListNode(intval)

{

Val=val;

Next=null;

}

}

//链表反转方法

publicstaticListNodeReverseList(ListNodehead)

{

ListNodepre=null;

ListNodecur=head;

ListNodetemp=null;

while(cur!=null)

{

//保存下一个节点

temp=cur.Next;

//反转当前节点指向

cur.Next=pre;

//前驱、当前节点后移

pre=cur;

cur=temp;

}

returnpre;

}六、综合笔试真题（企业真题）1.移除数组中指定元素题目：给定数组和目标值，原地移除所有等于目标值的元素，返回新数组长度参考答案（C#）csharp

publicstaticintRemoveElement(int[]nums,intval)

{

intindex=0;

for(inti=0;i<nums.Length;i++)

{

if(nums[i]!=val)

{

nums[index]=nums[i];

index++;

}

}

returnindex;

}2.二分查找（有序数组查找）题目：有序数组中查找目标值，返回下标，不存在返回-1解题思路：折半查找，时间复杂度O(logn)，有序数组最优查找算法参考答案（C#）csharp

publicstaticintBinarySearch(int[]nums,inttarget)

{

intleft=0;

intright=nums.Length-1;

while(left<=right)

{

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

if(nums[mid]==