更多大厂面试内容可见 -> http://11come.cn

字节秋招高频算法汇总

接下来讲一下 字节秋招 中的高频算法题，分为三个部分： 基础篇 、 中级篇 、 进阶篇

目的就是为了应对秋招中的算法题，其实过算法题的诀窍就在于 理解的基础上 + 背会

看到一个题目，首先要了解题目考察的算法是什么，这个算法要理解，至于具体实现的话，就靠背会了（多写、多练），没有什么捷径，可以 尝试一个题目手写 3-5 遍 ，加强一下记忆！

还有一点要注意的是，在大厂的笔试中， 可能考察算法的方式是 ACM 模式 ，这一点和力扣上不同，ACM 模式需要我们自己去引入对应的包，以及自己写算法，力扣是将方法框架给定，只需要在方法内写代码就可以了，这一点要注意！

进阶篇

在进阶篇主要考察 多次二分查找 、 反转链表（区间反转） 、 树形 DP（较为复杂） ，如下：

LC 852. 山脉数组的峰顶索引（中等）

题目描述：

符合下列属性的数组 arr 称为 山脉数组 ：

• arr.length >= 3
• 存在 i（0 < i < arr.length - 1）使得：
  • arr[0] < arr[1] < ... arr[i-1] < arr[i]
  • arr[i] > arr[i+1] > ... > arr[arr.length - 1]

给你由整数组成的山脉数组 arr ，返回满足 arr[0] < arr[1] < ... arr[i - 1] < arr[i] > arr[i + 1] > ... > arr[arr.length - 1] 的下标 i 。

你必须设计并实现时间复杂度为 O(log(n)) 的解决方案。

输入：arr = [0,1,0]
输出：1

这道题目是让找出山顶的坐标，并且要求时间复杂度为 O(Logn) ，那么显然 二分查找 的时间复杂度符合要求，并且题目中的数组也符合二分查找的 二段性 ，即分为了 左边升序 的数组和 右边降序 的数组

那么如果发现我们当前二分的 mid 点是在 左边升序数组 中，就令 l = mid ，如果发现 mid 点在右边降序数组中，就令 r = mid - 1

最后 r 指针就是山顶的下标

class Solution {public int peakIndexInMountainArray(int[] arr) {int n = arr.length;// 令 l 为第二个点，r 为 n-2 个点// 这样 l-1 就不会小于 0 了int l = 1, r = n - 2;while (l < r) {// 如果 r = mid - 1，则 mid = l + r + 1 >> 1// 如果 r = mid，则 mid = l + r >> 1int mid = l + r + 1 >> 1;// 判断在左边升序还是右边降序if (arr[mid] > arr[mid - 1]) {l = mid;} else {r = mid - 1;}}return r;}
}

LC 92. 反转链表 II（中等）

题目描述：

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

该题目考察的还是 链表的翻转 ，我们只需要对题目中指定的区间内链表翻转即可

那么只要找到 需要翻转的链表区间 ，将该区间链表翻转，再和前边的区间和后边的区间连接起来即可

那么需要翻转指定的链表区间，就需要 2 个指针：

• start ：当前翻转区间的开始节点
• end ：当前翻转区间的结束节点

翻转之后要和前边、后边的链表区间连接起来，还需要 2 个指针：

• pre ：上一个区间的最后一个节点
• nextStart ：下一个区间的开始节点

4 个指针位置如下图：

这个和中级篇中的 K 个一组翻转链表的题目类似， 代码如下：

/*** Definition for singly-linked list.* public class ListNode {*     int val;*     ListNode next;*     ListNode() {}*     ListNode(int val) { this.val = val; }*     ListNode(int val, ListNode next) { this.val = val; this.next = next; }* }*/
class Solution {public ListNode reverseBetween(ListNode head, int left, int right) {// 定义一个虚拟节点，方便定位下边 4 个指针的位置ListNode dummy = new ListNode(-1);dummy.next = head;// 上一个区间的最后一个点ListNode pre = dummy;// 下一个区间的第一个点ListNode nextStart = new ListNode(-1);// 翻转区间的第一个点ListNode start = new ListNode(-1);// 翻转区间的最后一个点ListNode end = new ListNode(-1);ListNode cur = dummy;while (cur != null) {left --;if (left == 0) {pre = cur;start = cur.next;}cur = cur.next;}cur = dummy;while (cur != null) {right --;cur = cur.next;if (right == 0) {end = cur;nextStart = cur.next;}}end.next = null;reverse(start);pre.next = end;start.next = nextStart;return dummy.next;}public void reverse(ListNode start) {ListNode last = null;ListNode now = start;while (now != null) {ListNode tmp = now.next;now.next = last;last = now;now = tmp;}}
}

LC 310. 最小高度树（中等）

题目描述：

树是一个无向图，其中任何两个顶点只通过一条路径连接。 换句话说，任何一个没有简单环路的连通图都是一棵树。

给你一棵包含 n 个节点的树，标记为 0 到 n - 1 。给定数字 n 和一个有 n - 1 条无向边的 edges 列表（每一个边都是一对标签），其中 edges[i] = [ai, bi] 表示树中节点 ai 和 bi 之间存在一条无向边。

可选择树中任何一个节点作为根。当选择节点 x 作为根节点时，设结果树的高度为 h 。在所有可能的树中，具有最小高度的树（即，min(h)）被称为 最小高度树 。

请你找到所有的 最小高度树 并按 任意顺序 返回它们的根节点标签列表。

树的 高度 是指根节点和叶子节点之间最长向下路径上边的数量。

输入：n = 4, edges = [[1,0],[1,2],[1,3]]
输出：[1]
解释：如图所示，当根是标签为 1 的节点时，树的高度是 1 ，这是唯一的最小高度树。

这道题目使用 树形 DP 来做，树形 DP 要么上边的节点使用到了下边节点的状态，要么下边节点使用到了上边节点的状态

这道题目比较复杂，对于一个节点，既使用到了上边、又使用到了下边节点的状态

题目要求我们找到 最小高度 的树，将他们的根节点返回即可，那么如果 暴力 来做的话，只需要去枚举所有的节点，对该节点遍历所有的子树，求出该节点的高度，暴力计算中是会包含许多重复计算的，因此使用 DP 来保存节点的状态，减少计算（暴力解的话，会超时）

要知道一个节点的高度，分为两种情况：

• 该节点向上走的最大高度
• 该节点向下走的最大高度

要计算该节点（设为 x）向上走的最大高度，就是计算该节点的父节点（设为 p）的最大高度 + 1，那么 p 的最大高度也分为了两种情况：

• p 的最大高度是经过 x 的：那么这种情况，在计算 x 的最大高度时，使用到了 p 的最大高度，而 p 的最大高度又是走到 x 了，这样就重复了，所以还需要记录一个数组记录节点的次大高度，这样当 p 的最大高度是走到 x 的话，我们直接使用 p 的次大高度即可
• p 的最大高度不是经过 x 的：这种情况，就直接使用 p 的最大高度 + 1 来计算 x 的最大高度即可

那么在计算的时候，需要使用 d1[i] 来计算 i 节点的最大高度，使用 d2[i] 计算 i 节点的次大高度，使用 up[i] 计算 i 节点向上的最大高度，使用 p[i] 表示 i 节点最大高度是走向的哪个节点（避免重复的计算）

代码如下：

class Solution {int[] d1;int[] d2;int[] p;int[] up;Map<Integer, List<Integer>> g = new HashMap<>();// 计算 u 节点的最大高度和次大高度public void dfs1(int u, int father) {List<Integer> toNodes = g.getOrDefault(u, new ArrayList<>());for (int i = 0; i < toNodes.size(); i ++) {int x = g.get(u).get(i);if (x == father) continue;dfs1(x, u);int d = d1[x] + 1;if (d >= d1[u]) {d2[u] = d1[u];d1[u] = d;p[u] = x;} else if (d > d2[u]) {d2[u] = d;}}}// 计算 u 节点向上走的最大高度void dfs2(int u, int father) {List<Integer> toNodes = g.getOrDefault(u, new ArrayList<>());for (int i = 0; i < toNodes.size(); i ++) {int x = g.get(u).get(i);if (x == father) continue;if (p[u] == x) up[x] = Math.max(up[u], d2[u]) + 1;else up[x] = Math.max(up[u], d1[u]) + 1;dfs2(x, u);}}public List<Integer> findMinHeightTrees(int n, int[][] edges) {List<Integer> res = new ArrayList<>();d1 = new int[n]; d2 = new int[n];up = new int[n]; p = new int[n];// 先遍历边，将所有的边放到 g 中去，g[u] 表示 u 节点可以到达节点for (int i = 0; i < edges.length; i ++) {int a = edges[i][0];int b = edges[i][1];// a 和 b 节点之间存在一条边，是无向边，因此向 g[a]、g[b] 中都存储一份g.computeIfAbsent(a, k->new ArrayList<>()).add(b);g.computeIfAbsent(b, k->new ArrayList<>()).add(a);}// 计算 u 节点向下走的最大高度和次大高度dfs1(0, -1);// 计算 u 节点向上走的最大高度dfs2(0, -1);// 先找到最低高度int minDepth = n + 1;for (int i = 0; i < n; i ++) {minDepth = Math.min(minDepth, Math.max(up[i], d1[i]));}// 将最低高度的节点加入到结果集中for (int i = 0; i < n; i ++) {if (Math.max(up[i], d1[i]) == minDepth) {res.add(i);}}return res;}
}

LC 121. 买卖股票的最佳时机（简单）

题目描述：

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

输入：[7,1,5,3,6,4]
输出：5
解释：在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格；同时，你不能在买入前卖出股票。

这道题目在力扣中有一个系列，都是 买卖股票 问题，可以把相关的题目都看一下

这道题目比较简单，遍历一遍，就就可以计算出来最大利润

代码如下：

class Solution {public int maxProfit(int[] prices) {int n = prices.length;// minv：最低价格// res：结果int minv = prices[0], res = 0;for (int i = 1; i < n; i ++) {minv = Math.min(minv, prices[i]);res = Math.max(res, prices[i] - minv);}return res;}
}