剑指offer——java刷题总结【七】
Note
- 题解汇总：剑指offer题解汇总
- 代码地址：Github 剑指offer Java实现汇总
- 点击目录中的题名链接可直接食用题解~
- 有些解法博文中未实现，不代表一定很难，可能只是因为博主太懒```(Orz)
- 如果博文中有明显错误或者某些题目有更加优雅的解法请指出，谢谢~
目录
| 题号 | 题目名称 |
|---|---|
| 61 | 序列化二叉树 |
| 62 | 二叉搜索树的第k个节点 |
| 63 | 数据流中的中位数 |
| 64 | 滑动窗口的最大值 |
| 65 | 矩阵中的路径 |
| 66 | 机器人的运动范围 |
| 67 | 剪绳子 |
正文
61、序列化二叉树
题目描述
请实现两个函数，分别用来序列化和反序列化二叉树。
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过某种符号表示空节点（#），以 ！表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
题目分析
解法一： 我们根据前序遍历序列来序列化二叉树，因为前序遍历序列是从根结点开始的，且遍历顺序是中左右，方便我们依次往后遍历字符串数组，并依次生成左子树和右子树。当在遍历二叉树过程中碰到Null指针时，这些Null指针被序列化为一个特殊的字符“#”，结点之间用感叹号隔开。首先将序列化后的字符串根据分隔符分隔成字符串数组，使用一个全局变量来标识当前遍历到哪个字符。
代码实现
解法一：
String Serialize(TreeNode root) {
if (root == null) return "#!";
return root.val + "!" + Serialize(root.left) + Serialize(root.right);
}
TreeNode Deserialize(String str) {
String[] strings = str.split("!");
return helper(strings);
}
int index = -1;
TreeNode helper(String[] strings) {
index++;
if (index >= strings.length) return null;
TreeNode tNode = null;
if (!strings[index].equals("#")) {
tNode = new TreeNode(Integer.parseInt(strings[index]));
tNode.left = helper(strings);
tNode.right = helper(strings);
}
return tNode;
}
62、二叉搜索树的第k个节点
题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如，（5，3，7，2，4，6，8）中，按结点数值大小顺序第三小结点的值为4。
题目分析
解法一： 递归法。因为二叉搜索树的中序遍历是有序递增的，所以可以使用递归版的中序遍历对二叉搜索树进行遍历，当遍历到第k个节点时则返回。
代码实现
解法一：
int index = -1;
TreeNode res = null;
TreeNode KthNode(TreeNode pRoot, int k) {
if (pRoot == null) return null;
index = k;
inOrderTraverse(pRoot);
return res;
}
void inOrderTraverse(TreeNode root) {
if (root != null) {
inOrderTraverse(root.left);
index--;
if (index == 0) {
res = root;
return;
}
inOrderTraverse(root.right);
}
}
63、数据流中的中位数
题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
题目分析
解法一： 优先队列法。设置一个小根堆和一个大根堆，在Java中使用PriorityQueue即可实现，默认是小根堆，本解法通过lambda表达式重写了比较器，实现大根堆，大根堆和小根堆各放一半的数据即可，保证大根堆中的数据量永远比小根堆中的数据量相等或多一个。当两个堆大小一样时，两个堆顶元素的平均数即为中位数；当两个堆大小不等时，由于大根堆中的元素数量会多一个，所以大根堆的堆顶元素即为中位数。在数据插入堆时，为了保证该数据放在合理的堆中，可以通过先插入大根堆，然后再将大根堆的堆顶元素取出插入小根堆的方式，使得该数据放在应有的位置。每次调整的时间复杂度为O(logn)。
代码实现
解法一： O(logn)
PriorityQueue<Integer> lHeap = new PriorityQueue<>((a, b) -> b - a); //大根堆
PriorityQueue<Integer> sHeap = new PriorityQueue<>(); //小根堆
void Insert(int num) {
lHeap.add(num);
sHeap.add(lHeap.remove());
if (sHeap.size() > lHeap.size()) {
lHeap.add(sHeap.remove());
}
}
Double GetMedian() {
if (sHeap.size() == lHeap.size()) {
return (sHeap.peek() + lHeap.peek()) / 2.0;
} else {
return (double) lHeap.peek();
}
}
64、滑动窗口的最大值
题目描述
给定一个数组和滑动窗口的大小，找出所有滑动窗口里数值的最大值。例如，如果输入数组{2,3,4,2,6,2,5,1}及滑动窗口的大小3，那么一共存在6个滑动窗口，他们的最大值分别为{4,4,6,6,6,5}； 针对数组{2,3,4,2,6,2,5,1}的滑动窗口有以下6个：{[2,3,4],2,6,2,5,1}，{2,[3,4,2],6,2,5,1}，{2,3,[4,2,6],2,5,1}，{2,3,4,[2,6,2],5,1}，{2,3,4,2,[6,2,5],1}， {2,3,4,2,6,[2,5,1]}。
题目分析
解法一： 优先队列法。维护一个大小为size的大根堆，对数组进行遍历，每次将窗口头部元素移除并将窗口尾部元素加入堆中，然后将堆顶元素返回即可。
代码实现
解法一： O(nlogk)
public static ArrayList<Integer> maxInWindows(int [] num, int size) {
PriorityQueue<Integer> queue = new PriorityQueue<>((a, b) -> b - a);
ArrayList<Integer> list = new ArrayList<>();
if (num.length < size || size == 0) {
return list;
}
for (int i = 0; i < size; i++) {
queue.offer(num[i]);
}
list.add(queue.peek());
for (int p1 = 0, p2 = size; p2 < num.length; p1++, p2++) {
queue.remove(num[p1]);
queue.offer(num[p2]);
list.add(queue.peek());
}
return list;
}
65、矩阵中的路径
题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如 a b c e s f c s a d e e 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
题目分析
解法一： 回溯法。
1、根据给定数组，初始化一个标志位数组，false表示未走过，true表示已经走过。因为题目规定不能走进同一个格子两次；
2、根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge，判断是否能够走通；
3、根据i和j确定当前点在一维数组matrix中的位置；
4、确定递归终止条件：越界、当前找到的矩阵值不等于数组对应位置的值、已经走过的点，这三类情况说明此路不通，返回false；
5、如果待判定字符串str的索引已经判断到了最后一位，此时说明匹配成功，返回true；
6、递归寻找当前格子周围的四个格子是否符合条件，只要有一条路满足条件则返回true；
7、如果周围的四个格子递归都没有找到路径，则说明当条路径寻找失败，将走过路径的数组flag重新标记为false。
此类问题都可以用回溯法解决，在递归过程中对数组越界进行判定是一种较为优雅的解法。
代码实现
解法一：
public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
boolean[] flag = new boolean[matrix.length];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
if (judge(matrix, i, j, rows, cols, str, 0, flag)) {
return true;
}
}
}
return false;
}
public boolean judge(char[] matrix, int i, int j, int rows, int cols, char[] str, int k, boolean[] flag) {
int index = i * cols + j;
if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[index] != str[k] || flag[index]) {
return false;
}
if (k == str.length - 1) {
return true;
}
flag[index] = true;
if (judge(matrix, i - 1, j, rows, cols, str, k + 1, flag)
|| judge(matrix, i + 1, j, rows, cols, str, k + 1, flag)
|| judge(matrix, i, j - 1, rows, cols, str, k + 1, flag)
|| judge(matrix, i, j + 1, rows, cols, str, k + 1, flag)) {
return true;
}
flag[index] = false;
return false;
}
66、机器人的运动范围
题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
题目分析
解法一： 回溯法。与岛问题类似的解法。
1、根据给定的行列，创建并初始化二维数组，判断每一个位置是否满足小于threshold的要求，满足为1，不满足为0；
2、机器人从原点出发，开始递归。数组越界和数组当前值不为1说明此路走不通，返回能够到达的格子数0。注意：数组当前值不为1有两种情况——0或2。数组值为0说明该格子不满足题目中小于threshold的要求，数组值为2说明当前位置已经走过，不再重复走；
3、如果此路可以走通，则对该位置的值进行+1操作，用来标记该位置已经走过并计数；
4、对当前格子的上下左右方向能够到达的格子个数进行计数累加，并做+1操作，意味着当前格子可达。
代码实现
解法一：
public static int movingCount(int threshold, int rows, int cols) {
int[][] matrix = new int[rows][cols];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++) {
matrix[i][j] = isAccess(threshold, i, j);
}
}
return helper(matrix, 0, 0, rows, cols);
}
public static int helper(int[][] matrix, int i, int j, int rows, int cols) {
if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[i][j] != 1) {
return 0;
}
matrix[i][j]++;
return helper(matrix, i - 1, j, rows, cols)
+ helper(matrix, i + 1, j, rows, cols)
+ helper(matrix, i, j - 1, rows, cols)
+ helper(matrix, i, j + 1, rows, cols)
+ 1;
}
public static int isAccess(int threshold, int row, int col) {
int count = 0;
while (row != 0) {
count += row % 10;
row /= 10;
}
while (col != 0) {
count += col % 10;
col /= 10;
}
return count <= threshold ? 1 : 0;
}
67、剪绳子
题目描述
给你一根长度为n的绳子，请把绳子剪成整数长的m段（m、n都是整数，n>1并且m>1），每段绳子的长度记为k[0],k[1],…,k[m]。请问k[0]xk[1]x…xk[m]可能的最大乘积是多少？例如，当绳子的长度是8时，我们把它剪成长度分别为2、3、3的三段，此时得到的最大乘积是18。
题目分析
解法一： 动态规划。本解法采用非递归实现，节省空间。m[i]代表着当长度为i时能够剪成若干长度的最大乘积，其实就是对组成每个长度的可能性进行遍历，比如求解长度为10的绳子，可以划分成1+9、2+8、3+7、4+6、5+5这五个子问题，这五个子问题的最大值就是m[10]，而子问题的解已经在之前已经被求解。所以可以直接使用for循环遍历的方式，而不需要采用递归求解，节省对某个值多次遍历的额外空间。而之所以要对子问题求max(i, m[i])，是因为题目要求至少对绳子剪一次，所以当绳子长度为10时，我们不能直接返回10，即结果不可能是它本身。但是在求后续问题的解中，m[i]只是一个子问题，可以不再进行划分，例如我们计算12时，需要2+10这两个子问题，而对于长度为10的这段绳子，我们可以不再对它进行剪切，而是把10作为一个乘数考虑进来。
代码实现
解法一： O(n²)
public int cutRope(int target) {
if (target == 1) return 1;
int[] m = new int[target + 1];
m[1] = 1;
for (int i = 2; i <= target; i++) {
int max = m[i];
for (int j = 1; j <= i / 2; j++) {
max = Math.max(max, Math.max(j, m[j]) * Math.max(i - j, m[i - j]));
}
m[i] = max;
}
return m[target];
}