字节跳动技术团队面试问题集及答案

2026年字节跳动技术团队面试问题集及答案一、编程基础（共5题，每题10分，总分50分）1.题目：实现一个函数，输入一个正整数`n`，返回`n`的阶乘。要求不使用递归，并考虑大数相乘的情况。答案：javaimportjava.math.BigInteger;publicclassFactorial{publicstaticBigIntegerfactorial(intn){BigIntegerresult=BigInteger.ONE;for(inti=2;i<=n;i++){result=result.multiply(BigInteger.valueOf(i));}returnresult;}publicstaticvoidmain(String[]args){intn=100;System.out.println("100!="+factorial(n));}}解析：使用`BigInteger`类处理大数相乘，避免普通整数溢出。循环从2开始乘到`n`，时间复杂度为O(n)。2.题目：实现一个无重复字符的最长子串，输入一个字符串`s`，返回其长度。答案：javapublicclassLongestSubstring{publicstaticintlengthOfLongestSubstring(Strings){int[]charIndex=newint[128];Arrays.fill(charIndex,-1);intmaxLength=0;intstart=0;for(inti=0;i<s.length();i++){charc=s.charAt(i);if(charIndex[c]>=start){start=charIndex[c]+1;}charIndex[c]=i;maxLength=Math.max(maxLength,i-start+1);}returnmaxLength;}publicstaticvoidmain(String[]args){Strings="abcabcbb";System.out.println("Longestsubstringlength:"+lengthOfLongestSubstring(s));}}解析：使用哈希数组记录字符上一次出现的位置，滑动窗口法维护无重复字符的子串。时间复杂度O(n)，空间复杂度O(1)。3.题目：实现快速排序算法，并分析其时间复杂度。答案：javapublicclassQuickSort{publicstaticvoidquickSort(int[]arr,intleft,intright){if(left<right){intpivotIndex=partition(arr,left,right);quickSort(arr,left,pivotIndex-1);quickSort(arr,pivotIndex+1,right);}}privatestaticintpartition(int[]arr,intleft,intright){intpivot=arr[right];inti=left-1;for(intj=left;j<right;j++){if(arr[j]<=pivot){i++;swap(arr,i,j);}}swap(arr,i+1,right);returni+1;}privatestaticvoidswap(int[]arr,inti,intj){inttemp=arr[i];arr[i]=arr[j];arr[j]=temp;}publicstaticvoidmain(String[]args){int[]arr={3,1,4,1,5,9,2,6};quickSort(arr,0,arr.length-1);System.out.println(Arrays.toString(arr));}}解析：快速排序是分治算法，平均时间复杂度O(nlogn)，最坏情况O(n²)。通过选择枢轴（pivot）将数组分为两部分，递归排序。4.题目：实现一个LRU（最近最少使用）缓存，支持`get`和`put`操作。答案：javaimportjava.util.HashMap;importjava.util.Map;classLRUCache{privateMap<Integer,Node>cache;privateintcapacity;privateNodehead,tail;classNode{intkey;intvalue;Nodeprev;Nodenext;}publicLRUCache(intcapacity){this.capacity=capacity;cache=newHashMap<>();head=newNode();tail=newNode();head.next=tail;tail.prev=head;}publicintget(intkey){Nodenode=cache.get(key);if(node==null)return-1;moveToHead(node);returnnode.value;}publicvoidput(intkey,intvalue){Nodenode=cache.get(key);if(node!=null){node.value=value;moveToHead(node);}else{NodenewNode=newNode();newNode.key=key;newNode.value=value;cache.put(key,newNode);addToHead(newNode);if(cache.size()>capacity){NodetailPrev=tail.prev;removeNode(tailPrev);cache.remove(tailPrev.key);}}}privatevoidmoveToHead(Nodenode){removeNode(node);addToHead(node);}privatevoidaddToHead(Nodenode){node.prev=head;node.next=head.next;head.next.prev=node;head.next=node;}privatevoidremoveNode(Nodenode){node.prev.next=node.next;node.next.prev=node.prev;}}解析：使用双向链表+哈希表实现。哈希表记录键值对，链表维护访问顺序。`get`操作将节点移动到头部，`put`操作插入新节点并淘汰最久未使用的节点。5.题目：实现一个二叉树的深度优先遍历（前序、中序、后序）。答案：javaclassTreeNode{intval;TreeNodeleft;TreeNoderight;TreeNode(intx){val=x;}}publicclassTreeTraversal{//前序遍历（根-左-右）publicstaticList<Integer>preorderTraversal(TreeNoderoot){List<Integer>result=newArrayList<>();dfsPreorder(root,result);returnresult;}privatestaticvoiddfsPreorder(TreeNodenode,List<Integer>list){if(node==null)return;list.add(node.val);dfsPreorder(node.left,list);dfsPreorder(node.right,list);}//中序遍历（左-根-右）publicstaticList<Integer>inorderTraversal(TreeNoderoot){List<Integer>result=newArrayList<>();dfsInorder(root,result);returnresult;}privatestaticvoiddfsInorder(TreeNodenode,List<Integer>list){if(node==null)return;dfsInorder(node.left,list);list.add(node.val);dfsInorder(node.right,list);}//后序遍历（左-右-根）publicstaticList<Integer>postorderTraversal(TreeNoderoot){List<Integer>result=newArrayList<>();dfsPostorder(root,result);returnresult;}privatestaticvoiddfsPostorder(TreeNodenode,List<Integer>list){if(node==null)return;dfsPostorder(node.left,list);dfsPostorder(node.right,list);list.add(node.val);}publicstaticvoidmain(String[]args){TreeNoderoot=newTreeNode(1);root.left=newTreeNode(2);root.right=newTreeNode(3);root.left.left=newTreeNode(4);root.left.right=newTreeNode(5);System.out.println("Preorder:"+preorderTraversal(root));System.out.println("Inorder:"+inorderTraversal(root));System.out.println("Postorder:"+postorderTraversal(root));}}解析：递归实现三种遍历。前序直接访问根节点，中序先左后根，后序先左后右再根。时间复杂度均为O(n)。二、算法设计（共4题，每题12分，总分48分）1.题目：设计一个算法，找出数组中和为特定值的最长子数组，返回其长度。答案：javapublicclassLongestSubarrayWithSum{publicstaticintlongestSubarrayWithSum(int[]nums,inttarget){Map<Integer,Integer>map=newHashMap<>();map.put(0,-1);intsum=0;intmaxLength=0;for(inti=0;i<nums.length;i++){sum+=nums[i];if(map.containsKey(sum-target)){maxLength=Math.max(maxLength,i-map.get(sum-target));}if(!map.containsKey(sum)){map.put(sum,i);}}returnmaxLength;}publicstaticvoidmain(String[]args){int[]nums={1,2,3,7,5};inttarget=12;System.out.println("Longestsubarraylength:"+longestSubarrayWithSum(nums,target));}}解析：前缀和+哈希表。记录前缀和首次出现的位置，当`sum-target`存在于哈希表中时，表示子数组和为`target`。时间复杂度O(n)，空间复杂度O(n)。2.题目：设计一个算法，找出所有出现超过一半次数的元素。答案：javaimportjava.util.ArrayList;importjava.util.HashMap;importjava.util.List;publicclassMajorityElements{publicstaticList<Integer>majorityElements(int[]nums){HashMap<Integer,Integer>map=newHashMap<>();intn=nums.length/2;List<Integer>result=newArrayList<>();for(intnum:nums){map.put(num,map.getOrDefault(num,0)+1);if(map.get(num)>n){result.add(num);if(result.size()==2)break;//至多有两个多数元素}}returnresult;}publicstaticvoidmain(String[]args){int[]nums={3,2,3};System.out.println("Majorityelements:"+majorityElements(nums));}}解析：哈希表统计每个元素的频率，超过一半的元素直接加入结果。最多有两个多数元素，提前终止。3.题目：设计一个算法，将一个无符号整数右旋转`k`位。答案：javapublicclassRotateRight{publicstaticintrotateRight(intnum,intk){intn=Integer.toBinaryString(num).length();k%=n;if(k==0)returnnum;num=num&((1<<k)-1);//取低k位num=num<<(n-k);//左移n-k位num=num|(num>>>k);//合并returnnum;}publicstaticvoidmain(String[]args){intnum=858993459;//1000...1000intk=3;System.out.println("Rotatednumber:"+rotateRight(num,k));}}解析：位运算实现。右旋转等价于将低k位移动到高位，高n-k位移动到低k位。时间复杂度O(1)。4.题目：设计一个算法，找出所有无重复数字的三元组，使得三元组的和等于特定值。答案：javaimportjava.util.ArrayList;importjava.util.Arrays;importjava.util.List;publicclassThreeSum{publicstaticList<List<Integer>>threeSum(int[]nums,inttarget){Arrays.sort(nums);List<List<Integer>>result=newArrayList<>();for(inti=0;i<nums.length-2;i++){if(i>0&&nums[i]==nums[i-1])continue;//跳过重复intleft=i+1,right=nums.length-1;while(left<right){intsum=nums[i]+nums[left]+nums[right];if(sum==target){result.add(Arrays.asList(nums[i],nums[left],nums[right]));while(left<right&&nums[left]==nums[left+1])left++;while(left<right&&nums[right]==nums[right-1])right--;left++;right--;}elseif(sum<target){left++;}else{right--;}}}returnresult;}publicstaticvoidmain(String[]args){int[]nums={1,2,-2,-1,0,1};inttarget=0;System.out.println("Triplets:"+threeSum(nums,target));}}解析：排序后双指针法。固定一个数，用左右指针遍历剩余部分，找到和为`target`的三元组。时间复杂度O(n²)。三、系统设计（共3题，每题20分，总分60分）1.题目：设计一个微博系统，要求支持用户发布、关注、点赞、查看时间线等功能。答案：系统架构：1.前端：Web/App（React/Vue），负责用户界面。2.后端：微服务架构（SpringCloud/Go），拆分为：-用户服务（注册登录、信息管理）。-发布服务（发布微博、转发、评论）。-关注服务（关注/取关、关系维护）。-点赞服务（点赞/取消、计数）。-时间线服务（聚合关注用户的动态）。3.数据库：-用户：MySQL（用户信息）。-微博：MongoDB（动态内容，支持稀疏字段）。-关注：Redis（关注关系，高并发读取）。-点赞：Redis（点赞计数，原子操作）。4.缓存：Redis缓存热点用户的时间线。5.消息队列：Kafka/RabbitMQ处理异步任务（如通知）。核心模块设计：-发布服务：-接口：POST/posts（发布微博）。-数据流：入库微博+转发关系，更新关注者时间线。-时间线服务：-接口：GET/timeline（返回用户时间线）。-逻辑：按关注顺序合并动态，优先展示最新。-关注服务：-接口：POST/follow（关注用户）。-数据：Redis存储关注关系（用户I