Java面试问题与解答
- 常见的GC回收器
- Serial GC: 适合单线程环境，暂停时间较长。
- Parallel GC: 多线程垃圾回收，适合多核处理器，停顿时间较短。
- CMS (Concurrent Mark-Sweep): 适合响应时间要求高的应用，通过多线程并发清除垃圾。
- G1 GC: 适用于大内存系统，目标是尽量减少GC停顿时间，分区回收。编辑
- SpringMVC的请求过程
- 流程： 用户发起请求 → 前端控制器（DispatcherServlet）接收请求 → HandlerMapping根据请求路径找到对应的控制器 → Controller执行业务逻辑 → 返回ModelAndView → 视图解析器返回视图 → 渲染页面返回给用户。
编辑
算法面试问题与解答
编辑
- 每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; } - 二叉搜索树转链表
- 思路： 中序遍历二叉搜索树，将遍历结果按顺序链接为链表。
- 解法： 使用递归或迭代的方式进行中序遍历并修改节点指针：
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; } - 负载均衡算法
- 思路： 负载均衡算法有很多种，常见的有轮询（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);
}
}
```
- 排序算法哪些是稳定的
- 稳定排序： 排序后，相等元素的顺序不变。常见的稳定排序包括：
- 冒泡排序（Bubble Sort）
- 插入排序（Insertion Sort）
- 归并排序（Merge Sort）
- 稳定的选择排序
- 快速排序（Quick Sort）一般不稳定。 - 二叉树求和
- 思路： 递归遍历二叉树并累加每个节点的值。
java public int sumOfTree(TreeNode root) { if (root == null) return 0; return root.val + sumOfTree(root.left) + sumOfTree(root.right); } - 序列化和反序列化二叉树
- 思路： 序列化将二叉树转换为字符串，反序列化则将字符串转换回二叉树。
- 解法： 使用前序遍历进行序列化：
```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;
}
}
```
- 如何判断一颗树是否是完全二叉树
- 思路： 完全二叉树的特点是：除最底层外，其他每一层都必须完全填充，且最底层节点从左到右排列。
- 解法： 使用层序遍历，判断是否遇到空节点后还有非空节点。
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; } - 求数组的极值点
- 思路： 极值点是数组中比相邻两个元素大的点（局部最大）或比相邻两个元素小的点（局部最小）。
- 解法： 使用遍历的方法找出极值点：
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; } - 最大连续子序列
- 思路： 采用动态规划的方法来求解最大连续子序列的和。
- 解法：
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; } - 回文链表
- 思路： 使用快慢指针找中点，然后反转后半部分进行比较。
- 解法：
```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;
}
```
《面试真实经历某节跳动大厂Java和算法问答以及答案总结(一)》 是转载文章，点击查看原文。
