面试真实经历某节跳动大厂Java和算法问答以及答案总结(一)

Java面试问题与解答

1. 常见的GC回收器

   • Serial GC : 适合单线程环境，暂停时间较长。

   • Parallel GC : 多线程垃圾回收，适合多核处理器，停顿时间较短。

   • CMS (Concurrent Mark-Sweep) : 适合响应时间要求高的应用，通过多线程并发清除垃圾。

   • G1 GC : 适用于大内存系统，目标是尽量减少GC停顿时间，分区回收。​编辑

2. SpringMVC的请求过程

   • 流程： 用户发起请求 → 前端控制器（DispatcherServlet）接收请求 → HandlerMapping根据请求路径找到对应的控制器 → Controller执行业务逻辑 → 返回ModelAndView → 视图解析器返回视图 → 渲染页面返回给用户。

​编辑

算法面试问题与解答​编辑

1. 每K个节点翻转链表（链表k个一旋转）

   • 思路： 每次遍历K个节点进行翻转，翻转时注意更新连接的指针。

   • 解法： 使用一个指针来跟踪当前链表的位置，每次翻转K个节点，注意边界条件（如剩余节点数小于K）：
     java public ListNode reverseKGroup(ListNode head, int k) { if (head == null || k == 1) return head; ListNode dummy = new ListNode(0); dummy.next = head; ListNode prev = dummy, curr = head, next = null; int count = 0; while (curr != null) { count++; curr = curr.next; } curr = dummy.next; while (count >= k) { curr = prev.next; next = curr.next; for (int i = 1; i < k; i++) { curr.next = next.next; next.next = prev.next; prev.next = next; next = curr.next; } prev = curr; count -= k; } return dummy.next; }

2. 二叉搜索树转链表

   • 思路： 中序遍历二叉搜索树，将遍历结果按顺序链接为链表。

   • 解法： 使用递归或迭代的方式进行中序遍历并修改节点指针：
     java public TreeNode flatten(TreeNode root) { if (root == null) return null; flatten(root.left); flatten(root.right); TreeNode tmp = root.right; root.right = root.left; root.left = null; while (root.right != null) root = root.right; root.right = tmp; return root; }

3. 负载均衡算法

   • 思路： 负载均衡算法有很多种，常见的有轮询（Round Robin）、加权轮询（Weighted Round Robin）、一致性哈希等。

   • 解法： 一致性哈希（Consistent Hashing）是解决分布式系统中负载均衡和节点增减的问题。​编辑

   ```java

   public class ConsistentHashing {

   private final TreeMap<Integer, String> circle = new TreeMap<>();

   private final int virtualNodeCount = 100;

public void addNode(String node) {

for (int i = 0; i < virtualNodeCount; i++) {

circle.put((node + i).hashCode(), node);

}

}

public String getNode(String key) {

int hash = key.hashCode();

if (!circle.containsKey(hash)) {

hash = circle.ceilingKey(hash);

}

return circle.get(hash);

}

}

```

4. 排序算法哪些是稳定的

   • 稳定排序： 排序后，相等元素的顺序不变。常见的稳定排序包括：

   • 冒泡排序（Bubble Sort）

   • 插入排序（Insertion Sort）

   • 归并排序（Merge Sort）

   • 稳定的选择排序

   • 快速排序（Quick Sort）一般不稳定。

5. 二叉树求和

   • 思路： 递归遍历二叉树并累加每个节点的值。
     java public int sumOfTree(TreeNode root) { if (root == null) return 0; return root.val + sumOfTree(root.left) + sumOfTree(root.right); }

6. 序列化和反序列化二叉树

   • 思路： 序列化将二叉树转换为字符串，反序列化则将字符串转换回二叉树。

   • 解法： 使用前序遍历进行序列化：

   ```java

   public class Codec {

   public String serialize(TreeNode root) {

   StringBuilder sb = new StringBuilder();

   serializeHelper(root, sb);

   return sb.toString();

   }

   private void serializeHelper(TreeNode node, StringBuilder sb) {

   if (node == null) {

   sb.append("null,");

   return;

   }

   sb.append(node.val).append(",");

   serializeHelper(node.left, sb);

   serializeHelper(node.right, sb);

   }

public TreeNode deserialize(String data) {

String[] nodes = data.split(",");

Queue queue = new LinkedList<>(Arrays.asList(nodes));

return deserializeHelper(queue);

}

private TreeNode deserializeHelper(Queue queue) {

String val = queue.poll();

if (val.equals("null")) return null;

TreeNode node = new TreeNode(Integer.parseInt(val));

node.left = deserializeHelper(queue);

node.right = deserializeHelper(queue);

return node;

}

}

```

7. 如何判断一颗树是否是完全二叉树

   • 思路： 完全二叉树的特点是：除最底层外，其他每一层都必须完全填充，且最底层节点从左到右排列。

   • 解法： 使用层序遍历，判断是否遇到空节点后还有非空节点。
     java public boolean isCompleteTree(TreeNode root) { if (root == null) return true; Queue<TreeNode> queue = new LinkedList<>(); queue.offer(root); boolean flag = false; while (!queue.isEmpty()) { TreeNode node = queue.poll(); if (node == null) flag = true; else { if (flag) return false; queue.offer(node.left); queue.offer(node.right); } } return true; }

8. 求数组的极值点

   • 思路： 极值点是数组中比相邻两个元素大的点（局部最大）或比相邻两个元素小的点（局部最小）。

   • 解法： 使用遍历的方法找出极值点：
     java public List<Integer> findLocalExtrema(int[] nums) { List<Integer> extrema = new ArrayList<>(); for (int i = 1; i < nums.length - 1; i++) { if ((nums[i] > nums[i - 1] && nums[i] > nums[i + 1]) || (nums[i] < nums[i - 1] && nums[i] < nums[i + 1])) { extrema.add(nums[i]); } } return extrema; }

9. 最大连续子序列

   • 思路： 采用动态规划的方法来求解最大连续子序列的和。

   • 解法：
     java public int maxSubArray(int[] nums) { int maxSum = nums[0], currentSum = nums[0]; for (int i = 1; i < nums.length; i++) { currentSum = Math.max(nums[i], currentSum + nums[i]); maxSum = Math.max(maxSum, currentSum); } return maxSum; }

10. 回文链表

    • 思路： 使用快慢指针找中点，然后反转后半部分进行比较。

    • 解法：

    ```java

    public boolean isPalindrome(ListNode head) {

    if (head == null || head.next == null) return true;

    ListNode slow = head, fast = head;

    while (fast != null && fast.next != null) {

    slow = slow.next;

    fast = fast.next.next;

    }

    ListNode secondHalf = reverse(slow);

    ListNode firstHalf = head;

    while (secondHalf != null) {

    if (firstHalf.val != secondHalf.val) return false;

    firstHalf = firstHalf.next;

    secondHalf = secondHalf.next;

    }

    return true;

    }

private ListNode reverse(ListNode head) {

ListNode prev = null, curr = head;

while (curr != null) {

ListNode next = curr.next;

curr.next = prev;

prev = curr;

curr = next;

}

return prev;

}

```