iOS 面试高频算法题及详细答案（实战无机器话术）-1

iOS面试高频算法题及详细答案（实战无机器话术）前言：本文题目为字节、阿里、腾讯、美团iOS岗高频笔试面试原题，全部使用Swift实现，解法贴合移动端面试解题习惯，侧重思路通俗、代码简洁、适配面试手写场景，无过度学术化表述。一、字符串类（iOS必考基础）题目1：反转字符串题目描述：输入一个字符串，原地反转所有字符，不使用系统反转API。面试考察点：双指针思想、字符串遍历、原地优化解题思路：定义左右两个指针，左指针从头部、右指针从尾部开始，两两交换字符，指针向中间靠拢，直到两指针相遇，实现原地反转，空间复杂度为O(1)。swift

funcreverseString(_s:inout[Character]){

varleft=0

varright=s.count-1

whileleft<right{

//交换左右指针元素

s.swapAt(left,right)

left+=1

right-=1

}

}

//测试用例

varstr:[Character]=["h","e","l","l","o"]

reverseString(&str)

print(str)//输出：["o","l","l","e","h"]题目2：有效的字母异位词题目描述：给定两个字符串，判断是否由相同字母、不同顺序组成（字母异位词），仅包含小写字母。面试考察点：哈希计数、字符统计、边界处理解题思路：先判断长度，长度不同直接返回false。创建长度为26的数组统计每个字母出现次数，第一个字符串字母计数+1，第二个字符串字母计数-1，最终数组全为0则是异位词。swift

funcisAnagram(_s:String,_t:String)->Bool{

guards.count==t.countelse{returnfalse}

varcount=[Int](repeating:0,count:26)

letaASCII=Character("a").asciiValue!

forcharins{

letidx=Int(char.asciiValue!-aASCII)

count[idx]+=1

}

forcharint{

letidx=Int(char.asciiValue!-aASCII)

count[idx]-=1

ifcount[idx]<0{

returnfalse

}

}

returntrue

}

//测试用例

print(isAnagram("anagram","nagaram"))//true

print(isAnagram("rat","car"))//false二、数组类（移动端最常考）题目3：两数之和题目描述：给定一个整数数组和一个目标值，找出数组中两个相加等于目标值的数，返回对应下标，同一个元素不能重复使用，假设仅有一个唯一解。面试考察点：哈希表应用、时间复杂度优化解题思路：暴力遍历时间复杂度O(n²)，面试不推荐。使用字典做哈希缓存，遍历数组，每次计算当前值的互补值（目标值-当前值），若字典中存在互补值，直接返回下标；不存在则将当前值和下标存入字典，时间复杂度优化至O(n)。swift

functwoSum(_nums:[Int],_target:Int)->[Int]{

vardict=[Int:Int]()

for(index,num)innums.enumerated(){

letcomplement=target-num

ifletcomplementIndex=dict[complement]{

return[complementIndex,index]

}

dict[num]=index

}

return[]

}

//测试用例

print(twoSum([2,7,11,15],9))//输出：[0,1]题目4：移除数组重复元素题目描述：给有序数组，原地删除重复元素，让每个元素只出现一次，返回新数组长度，不额外开辟数组空间。面试考察点：快慢指针、原地数组操作解题思路：快慢指针解法。慢指针记录唯一元素的位置，快指针遍历数组。快慢指针元素不同时，说明快指针找到新唯一元素，慢指针后移并覆盖值，遍历结束后慢指针+1即为新长度。swift

funcremoveDuplicates(_nums:inout[Int])->Int{

guard!nums.isEmptyelse{return0}

varslow=0

forfastin1..<nums.count{

ifnums[fast]!=nums[slow]{

slow+=1

nums[slow]=nums[fast]

}

}

returnslow+1

}

//测试用例

varnums=[1,1,2]

print(removeDuplicates(&nums))//输出：2

print(nums.prefix(2))//输出：[1,2]三、链表类（iOS中层面试必问）题目5：反转单链表题目描述：给定一个单链表，返回反转后的新链表头节点。面试考察点：链表指针操作、迭代思维（面试优先迭代，递归可作为拓展）解题思路：迭代法，定义前驱、当前、后继三个指针。遍历链表时，先保存当前节点下一个节点，再让当前节点指向前驱节点，随后前驱、当前节点依次后移，遍历完成后前驱节点即为新链表头。swift

//定义链表节点

classListNode{

varval:Int

varnext:ListNode?

init(_val:Int){

self.val=val

self.next=nil

}

}

funcreverseList(_head:ListNode?)->ListNode?{

varprev:ListNode?

varcurr=head

whilecurr!=nil{

//保存后继节点

letnext=curr?.next

//反转指针

curr?.next=prev

//指针后移

prev=curr

curr=next

}

returnprev

}题目6：判断链表是否有环题目描述：判断单链表是否存在环，存在返回true，否则false。面试考察点：快慢指针（龟兔赛跑算法）、空间优化解题思路：快指针每次走两步，慢指针每次走一步。若无环，快指针会先走到链表末尾；若有环，快慢指针一定会在环内相遇。该解法无需额外存储节点，空间O(1)。swift

funchasCycle(_head:ListNode?)->Bool{

varslow=head

varfast=head

whilefast!=nil,fast?.next!=nil{

slow=slow?.next

fast=fast?.next?.next

ifslow===fast{

returntrue

}

}

returnfalse

}四、递归与基础思维题目7：斐波那契数列题目描述：求斐波那契数列第n项，F(0)=0，F(1)=1，F(n)=F(n-1)+F(n-2)。面试考察点：递归缺陷、迭代优化、动态规划基础解题思路：纯递归存在大量重复计算，面试不推荐。采用迭代滚动更新，仅保存前两项值，空间复杂度O(1)，效率更高。swift

funcfib(_n:Int)->Int{

guardn>1else{returnn}

vara=0,b=1

for_in2...n{

lettemp=a+b

a=b

b=temp

}

returnb

}

//测试用例

print(fib(10))//输出：55五、动态规划（中高级iOS面试）题目8：爬楼梯题目描述：楼梯共有n阶，每次可以爬1阶或2阶，求爬到楼顶共有多少种不同方法。面试考察点：动态规划状态转移、递推思维解题思路：状态推导：爬到第n阶的方法数=爬到n-1阶（再走1步）+爬到n-2阶（再走2步）。初始状态：n=1，1种；n=2，2种。后续逐项递推即可。swift

funcclimbStairs(_n:Int)->Int{

guardn>2else{returnn}

varfirst=1

varsecond=2

varres=0

for_in3...n{

res=first+second

first=second

second=res

}

returnres

}

//测试用例

print(climbStairs(5))//输出：8题目9：最大子数组和题目描述：给定整数数组（含正负），找出和最大的连续子数组，返回其和。面试考察点：贪心算法、动态规划、经典Kadane算法解题思路：遍历数组，维护当前子数组和，若当前和为负数，直接舍弃，重新从当前元素累加；同时全程记录遍历过程中的最大值，即为答案。swift

funcmaxSubArray(_nums:[Int])->Int{

varcurrentSum=nums[0]

varmaxSum=nums[0]

foriin1..<nums.count{

currentSum=max(nums[i],currentSum+nums[i])

maxSum=max(maxSum,currentSum)

}

returnmaxSum

}

//测试用例

print(maxSubArray([-2,1,-3,4,-1,2,1,-5,4]))//输出：6六、面试高频简答思考题（iOS专属）题目10：算法时间、空间复杂度面试口述答案1.时间复杂度：衡量代码执行耗时随数据量增长的变化趋势，只保留最高阶项，忽略常数。常见排序：O(1)常数、O(logn)二分、O(n)遍历、O(nlogn)快排/归并、O(n²)双层循环。2.空间复杂度：衡量代码执行过程中额外开辟的内存空间，不包含原始输入空间。原地算法一般为O(1)，递归、哈希