剑指offer之61-66题解
目录
61. 序列化二叉树
（一）题目描述
请实现两个函数，分别用来序列化和反序列化二叉树
（二）思路
二叉树被记录成文件的过程叫作二叉树的序列化，通过文件内容重建原来的二叉树过程叫做二叉树反序列化。
通过先序遍历来实现序列化和反序列化过程。
- 序列化二叉树
- 先遍历二叉树，如果遇到null节点，就在str的末尾加上“#!","#“表示这个节点为空，
节点值不存在，“!”表示一个值结束；如果遇到不为空的节点，假设值为3，就在值的末尾加上“3!”。如下可以表示成：1!2!4!#!7!#!#!#!3!5!#!#!6!#!#!
- 先遍历二叉树，如果遇到null节点，就在str的末尾加上“#!","#“表示这个节点为空，
- 反序列化二叉树
- 按 “!” 分割，如果是 "#"表示null。
（三）代码实现
- 按 “!” 分割，如果是 "#"表示null。
import java.util.LinkedList;
import java.util.Queue;
public class Solution {
String Serialize(TreeNode root) {
if (root==null){
return "#!";
}
String res = root.val+"!";
res += Serialize(root.left);
res += Serialize(root.right);
return res;
}
TreeNode Deserialize(String str) {
String[] value = str.split("!");
Queue<String> queue = new LinkedList<>();
for (int i = 0; i !=value.length; i++) {
queue.offer(value[i]);
}
return getDeserialize(queue);
}
private TreeNode getDeserialize(Queue<String> queue) {
String value = queue.poll();
if (value.equals("#")){
return null;
}
TreeNode head = new TreeNode(Integer.valueOf(value));
head.left = getDeserialize(queue);
head.right = getDeserialize(queue);
return head;
}
}
62. 二叉搜索树的第k个节点
（一）题目描述
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
（二）思路
- 二叉搜索树的特点是中序遍历结果，是递增的。
- 所以可以利用中序遍历结果，找到第k个即为第几小的数。
（三）代码实现
import java.util.*;
public class Solution {
private TreeNode ret;
private int cnt = 0;
TreeNode KthNode(TreeNode pRoot, int k) {
inOrder(pRoot, k);
return ret;
}
private void inOrder(TreeNode root, int k) {
if (root == null || k < 0)
return;
inOrder(root.left, k);
cnt++;
if (cnt == k)
ret = root;
inOrder(root.right, k);
}
}
63. 数据流中的中位数
（一）题目描述
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
（二）思路
- 创建一个大根堆和小根堆，中位数就是两者堆顶元素中的一个，返回即可
- 即创建一个大顶堆，存储左半边元素
- 创建一个小顶堆，存储右半边元素，并且右半边元素都大于左半边
- 创建一个变量N记录当前数据流读入的元素个数，如果N为偶数的情况下插入到右半边，但是由于新插入的元素不一定比左半边的元素大，因此需要先将元素插入左半边，利用左半边大根堆的特点，取出堆顶元素即最大元素，插入右半边
（三）代码实现
import java.util.PriorityQueue;
public class Solution {
private PriorityQueue<Integer> left = new PriorityQueue<>((o1, o2) -> o2 - o1);
private PriorityQueue<Integer> right = new PriorityQueue<>();
private int N = 0;
public void Insert(Integer num) {
if (N % 2 ==0){
left.add(num);
right.add(left.poll());
}else {
right.add(num);
left.add(right.poll());
}
N++;
}
public Double GetMedian() {
if (N%2==0)
return (left.peek()+right.peek())/2.0;
else
return (double)right.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的队列。
- 创建遍历 i，j进行维护操作，num[i] 弹出，num[j]进入。
（三）代码实现
import java.util.ArrayList;
import java.util.PriorityQueue;
public class Solution {
public ArrayList<Integer> maxInWindows(int[] num, int size) {
ArrayList<Integer> ret = new ArrayList<>();
if (size > num.length || size < 1)
return ret;
PriorityQueue<Integer> heap = new PriorityQueue<>((o1, o2) -> o2 - o1);
for (int i = 0; i < size; i++)
heap.add(num[i]);
ret.add(heap.peek());
for (int i = 0, j = i + size; j < num.length; i++, j++) {
heap.remove(num[i]);
heap.add(num[j]);
ret.add(heap.peek());
}
return ret;
}
}
65. 矩阵中的路径
（一）题目描述
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。 例如 a b c e s f c s a d e e 这样的3 X 4 矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
（二）思路
- 根据给定数组，初始化一个标志位数组，初始化为false，表示未走过，true表示已经走过，不能走第二次
- 根据行数和列数，遍历数组，先找到一个与str字符串的第一个元素相匹配的矩阵元素，进入judge
- 根据i和j先确定一维数组的位置，因为给定的matrix是一个一维数组
- 确定递归终止条件：越界，当前找到的矩阵值不等于数组对应位置的值，已经走过的，这三类情况，都直接false，说明这条路不通
- 若k，就是待判定的字符串str的索引已经判断到了最后一位，此时说明是匹配成功的
- 下面就是本题的精髓，递归不断地寻找周围四个格子是否符合条件，只要有一个格子符合条件，就继续再找这个符合条件的格子的四周是否存在符合条件的格子，直到k到达末尾或者不满足递归条件就停止。
- 走到这一步，说明本次是不成功的，我们要还原一下标志位数组index处的标志位，进入下一轮的判断。
（三）代码实现
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str) {
int[] flag = new int[matrix.length];
for (int i = 0; i < rows; i++) {
for (int j = 0; j < cols; j++)
if (helper(matrix, rows, cols, i, j, 0, str, flag)) {
return true;
}
}
return false;
}
private boolean helper(char[] matrix, int rows, int cols, int i, int j, int k, char[] str, int[] flag) {
int index = i * rows + j;
if (i < 0 || i >= rows || j < 0 || j >= cols || matrix[index] != str[k] || flag[index] == 1)
return false;
if (k == str.length - 1)
return true;
flag[index] = 1;
if (
helper(matrix, rows, cols, i - 1, j, k + 1, str, flag) ||
helper(matrix, rows, cols, i + 1, j, k + 1, str, flag) ||
helper(matrix, rows, cols, i, j - 1, k + 1, str, flag) ||
helper(matrix, rows, cols, i, j + 1, k + 1, str, flag)) {
return true;
}
flag[index] = 0;
return false;
}
}
66. 机器人的运动范围
（一）题目描述
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
（二）思路
- 思路和上题差不多。看代码即能理解。
（三）代码实现
public class Solution {
public int movingCount(int threshold, int rows, int cols) {
int flag[][] = new int[rows][cols]; //记录是否已经走过
return helper(0, 0, rows, cols, flag, threshold);
}
private int helper(int i, int j, int rows, int cols, int[][] flag, int threshold) {
if (i < 0 || i >= rows || j < 0 || j >= cols || numSum(i) + numSum(j) > threshold || flag[i][j] == 1) return 0;
flag[i][j] = 1;
return helper(i - 1, j, rows, cols, flag, threshold)
+ helper(i + 1, j, rows, cols, flag, threshold)
+ helper(i, j - 1, rows, cols, flag, threshold)
+ helper(i, j + 1, rows, cols, flag, threshold)
+ 1;
}
private int numSum(int i) {
int sum = 0;
do {
sum += i % 10;
} while ((i = i / 10) > 0);
return sum;
}
}
138
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
