2026年阿里巴软件开发面试题集及详解

2026年阿里巴软件开发面试题集及详解一、编程基础（5题，每题10分，共50分）1.题目：请用Java实现一个方法，输入一个整数数组，返回数组中的最大值和最小值，要求时间复杂度为O(n)。答案与解析：javapublicclassMaxMinFinder{publicstaticint[]findMaxMin(int[]arr){if(arr==null||arr.length==0){thrownewIllegalArgumentException("数组不能为空");}intmax=arr[0];intmin=arr[0];for(inti=1;i<arr.length;i++){if(arr[i]>max){max=arr[i];}if(arr[i]<min){min=arr[i];}}returnnewint[]{max,min};}publicstaticvoidmain(String[]args){int[]arr={3,1,4,1,5,9,2,6,5,3};int[]result=findMaxMin(arr);System.out.println("最大值："+result[0]+"，最小值："+result[1]);}}解析：该方法通过一次遍历数组，同时更新最大值和最小值，时间复杂度为O(n)。关键在于初始化时将max和min设置为数组的第一个元素，然后依次与后续元素比较。如果数组为空或长度为0，方法抛出异常，确保鲁棒性。2.题目：请用Python实现一个函数，输入一个字符串，返回该字符串中所有重复字符的频率（以字典形式返回）。答案与解析：pythondefcount_duplicate_chars(s):frequency={}forcharins:ifcharinfrequency:frequency[char]+=1else:frequency[char]=1return{char:freqforchar,freqinfrequency.items()iffreq>1}示例s="helloworld"print(count_duplicate_chars(s))解析：通过遍历字符串，统计每个字符的出现次数，最后过滤出出现次数大于1的字符及其频率。字典的键为字符，值为频率。时间复杂度为O(n)，空间复杂度为O(n)。3.题目：请用C++实现一个链表节点类（ListNode），并实现一个方法，反转链表。答案与解析：cppinclude<iostream>structListNode{intval;ListNodenext;ListNode(intx):val(x),next(nullptr){}};ListNodereverseList(ListNodehead){ListNodeprev=nullptr;ListNodecurrent=head;while(current!=nullptr){ListNodenext=current->next;current->next=prev;prev=current;current=next;}returnprev;}intmain(){ListNodehead=newListNode(1);head->next=newListNode(2);head->next->next=newListNode(3);ListNodereversed=reverseList(head);while(reversed!=nullptr){std::cout<<reversed->val<<"";reversed=reversed->next;}return0;}解析：通过迭代法反转链表，使用三个指针：prev、current和next。初始时prev为nullptr，current为head。每次将current的next指向prev，然后移动prev和current到下一个节点。最后返回prev作为新的头节点。时间复杂度为O(n)，空间复杂度为O(1)。4.题目：请用JavaScript实现一个函数，输入一个数组，返回一个新数组，其中包含原数组中的所有偶数，且顺序不变。答案与解析：javascriptfunctionfilterEvenNumbers(arr){returnarr.filter(num=>num%2===0);}//示例constarr=[1,2,3,4,5,6];console.log(filterEvenNumbers(arr));//[2,4,6]解析：使用数组的filter方法，检查每个元素是否为偶数（num%2===0），如果是则保留，否则过滤掉。时间复杂度为O(n)，空间复杂度为O(n)。5.题目：请用Go实现一个函数，输入一个整数，返回该整数的二进制表示中1的个数。答案与解析：gopackagemainimport"fmt"funccountOnes(nint)int{count:=0forn!=0{count+=n&1n>>=1}returncount}funcmain(){fmt.Println(countOnes(13))//13的二进制是1101，返回3}解析：通过不断右移整数n，并检查最低位是否为1，统计1的个数。每次右移后，最低位被移出，直到n为0。时间复杂度为O(logn)，空间复杂度为O(1)。二、数据结构与算法（5题，每题10分，共50分）1.题目：请解释什么是二叉搜索树（BST），并给出一个递归方法，检查一个二叉树是否为BST。答案与解析：二叉搜索树（BST）是一种二叉树，其中每个节点的左子树中的所有值都小于该节点的值，右子树中的所有值都大于该节点的值，且左右子树也都是BST。递归检查BST的方法如下：pythonclassTreeNode:def__init__(self,val=0,left=None,right=None):self.val=valself.left=leftself.right=rightdefisBST(root,min_val=float('-inf'),max_val=float('inf')):ifrootisNone:returnTrueifroot.val<=min_valorroot.val>=max_val:returnFalsereturnisBST(root.left,min_val,root.val)andisBST(root.right,root.val,max_val)解析：递归检查每个节点的值是否在允许的范围内（min_val,max_val）。初始时，min_val为负无穷，max_val为正无穷。对于左子树，max_val更新为当前节点的val；对于右子树，min_val更新为当前节点的val。如果任何节点不满足BST性质，返回False。2.题目：请实现一个LRU（LeastRecentlyUsed）缓存，使用哈希表和双向链表。答案与解析：pythonclassDLinkedNode:def__init__(self,key=0,value=0):self.key=keyself.value=valueself.prev=Noneself.next=NoneclassLRUCache:def__init__(self,capacity:int):self.capacity=capacityself.cache={}self.head=DLinkedNode()self.tail=DLinkedNode()self.head.next=self.tailself.tail.prev=self.headdefget(self,key:int)->int:ifkeynotinself.cache:return-1node=self.cache[key]self._move_to_head(node)returnnode.valuedefput(self,key:int,value:int)->None:ifkeyinself.cache:node=self.cache[key]node.value=valueself._move_to_head(node)else:node=DLinkedNode(key,value)self.cache[key]=nodeself._add_node(node)iflen(self.cache)>self.capacity:lru=self.tail.prevself._remove_node(lru)delself.cache[lru.key]def_move_to_head(self,node):self._remove_node(node)self._add_node(node)def_add_node(self,node):node.prev=self.headnode.next=self.head.nextself.head.next.prev=nodeself.head.next=nodedef_remove_node(self,node):prev_node=node.prevnext_node=node.nextprev_node.next=next_nodenext_node.prev=prev_node解析：LRU缓存通过双向链表维护访问顺序，哈希表实现O(1)的get和put操作。头节点指向链表开头，尾节点指向链表末尾。get操作将节点移动到头部，put操作将新节点添加到头部，如果超出容量则删除尾节点。时间复杂度：get和put均为O(1)，空间复杂度为O(capacity)。3.题目：请解释什么是动态规划（DP），并给出一个斐波那契数列的DP实现。答案与解析：动态规划（DP）是一种通过将问题分解为子问题并存储子问题解来解决问题的方法，避免重复计算。斐波那契数列的DP实现如下：pythondeffib(n):ifn<=1:returnndp=[0](n+1)dp[1]=1foriinrange(2,n+1):dp[i]=dp[i-1]+dp[i-2]returndp[n]解析：斐波那契数列的递归解法有大量重复计算，DP通过存储子问题解（dp数组）来优化。初始dp[0]=0，dp[1]=1，然后依次计算dp[2]到dp[n]。时间复杂度为O(n)，空间复杂度为O(n)。可以进一步优化空间复杂度为O(1)。4.题目：请解释什么是贪心算法，并给出一个用贪心算法解决的活动选择问题的实现。答案与解析：贪心算法在每一步选择当前最优解，希望最终得到全局最优解。活动选择问题：给定n个活动，每个活动有开始时间和结束时间，选择最多不冲突的活动。贪心策略：按活动结束时间排序，每次选择结束时间最早且不冲突的活动。pythondefactivity_selection(start,finish):n=len(start)activities=list(zip(start,finish))activities.sort(key=lambdax:x[1])selected=[]last_end=0fors,finactivities:ifs>=last_end:selected.append((s,f))last_end=freturnselected示例start=[1,3,0,5,8,5]finish=[2,4,6,7,9,9]print(activity_selection(start,finish))#[(1,2),(3,4),(5,7),(8,9)]解析：首先将活动按结束时间排序，然后初始化last_end为0。遍历活动，如果当前活动的开始时间大于last_end，则选择该活动，并更新last_end。最终selected为选中的活动序列。时间复杂度为O(nlogn)，空间复杂度为O(n)。5.题目：请解释什么是图，并给出一个用BFS（广度优先搜索）遍历无向图的实现。答案与解析：图是由节点（顶点）和边组成的集合。BFS是一种遍历图的方法，从起始节点开始，逐层遍历相邻节点。实现如下：pythonfromcollectionsimportdequedefbfs(graph,start):visited=set()queue=deque([start])whilequeue:node=queue.popleft()ifnodenotinvisited:visited.add(node)forneighboringraph[node]:ifneighbornotinvisited:queue.append(neighbor)returnvisited示例graph={'A':['B','C'],'B':['A','D','E'],'C':['A','F'],'D':['B'],'E':['B','F'],'F':['C','E']}print(bfs(graph,'A'))#{'A','B','C','D','E','F'}解析：使用队列实现BFS，初始将起始节点入队。每次出队一个节点，遍历其所有未访问的邻接节点并入队。继续直到队列为空。时间复杂度为O(V+E)，空间复杂度为O(V)，其中V为节点数，E为边数。三、系统设计（3题，每题15分，共45分）1.题目：请设计一个高并发的短链接系统，要求支持高并发访问，且能够快速生成和解析短链接。答案与解析：短链接系统设计要点：1.短链接生成：使用哈希算法（如SHA-256）对长链接进行哈希，取哈希的一部分作为短链接。例如，取前6位十六进制字符。2.数据库设计：使用关系型数据库（如MySQL）存储短链接和长链接的映射，索引short_url字段以加速查找。3.缓存：使用Redis缓存短链接对应的长链接，减少数据库访问。4.分布式架构：使用负载均衡（如Nginx）分发请求，多个后端节点处理请求。5.高可用：使用主从复制和分布式缓存，确保系统可用性。伪代码：pythondefgenerate_short_url(long_url):hash_val=hashlib.sha256(long_url.encode()).hexdigest()short_url=hash_val[:6]db.save(short_url,long_url)returnshort_urldefresolve_short_url(short_url):ifshort_urlinredis_cache:returnredis_cache.get(short_url)long_url=db.get(short_url)redis_cache.set(short_url,long_url)returnlong_url解析：通过哈希算法生成短链接，数据库存储映射关系，缓存加速查找，分布式架构提高并发能力。关键在于优化短链接生成和解析的效率，确保高并发下的性能。2.题目：请设计一个实时消息推送系统，要求支持大规模用户，低延迟推送，且能够处理消息丢失。答案与解析：实时消息推送系统设计要点：1.消息队列：使用Kafka或RabbitMQ作为消息队列，处理高并发消息。2.推送服务：使用WebSocket或长轮询实现实时推送，WebSocket更高效。3.用户管理：使用Redis存储用户在线状态和设备信息。4.消息重试：使用消息队列的持久化机制和重试策略，确保消息不丢失。5.分布式部署：使用负载均衡和多个推送节点，提高并发能力和容错性。伪代码：pythondefpush_message(user_id,message):queue.send(user_id,message)监听队列，推送消息defon_message(user_id,message):ifuser_idinredis_online:send_to_user(user_id,message)else:用户离线，缓存消息或重试queue.save