面试真实经历某节跳动大厂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<String> queue = new LinkedList<>(Arrays.asList(nodes));
return deserializeHelper(queue);
}

       private TreeNode deserializeHelper(Queue<String> 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;
}
```