- 61.序列化二叉树
- 62.二叉搜索树的第k个节点
- 63.数据流中的中位数
- 64.滑动窗口的最大值
- 65.矩阵中的路径
- 66.机器人的运动范围
- 67.剪绳子
写在前面：本随笔是剑指Offer系列最后一篇。后续会记录一些Java、Spring、数据库、分布式等方面的内容。
61.序列化二叉树
请实现两个函数，分别用来序列化和反序列化二叉树
二叉树的序列化是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#），以 ！ 表示一个结点值的结束（value!）。
二叉树的反序列化是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
递归；非递归。选择相应的遍历顺序。
1.递归：
public class Solution {
int index=-1;
String Serialize(TreeNode root) {
//以 !表示结点值的结束，#表示空节点
StringBuffer sb=new StringBuffer();
if(root==null){
sb.append("#!");
return sb.toString();
}
//前序遍历
sb.append(root.val+"!");
sb.append(Serialize(root.left));
sb.append(Serialize(root.right));
return sb.toString();
}
TreeNode Deserialize(String str) {
index++;//依次后移判断对应结点
TreeNode root=null;
String[] node=str.split("!");
if(!node[index].equals("#")){
root=new TreeNode(Integer.valueOf(node[index]));
root.left=Deserialize(str);
root.right=Deserialize(str);
}
return root;
}
}
2.非递归（层次遍历）：
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
import java.util.Queue;
import java.util.LinkedList;
public class Solution {
int index=-1;
String Serialize(TreeNode root) {
//以 !表示结点值的结束，#表示空节点
if(root==null)
return "#!";
Queue queue=new LinkedList<>();
StringBuffer sb=new StringBuffer();
int width=0;//宽度，当前层结点个数
int count=0;//当前层已遍历结点数
TreeNode temp=null;//存储遍历的结点
queue.offer(root);
sb.append(root.val+"!");
while(!queue.isEmpty()){
width=queue.size();
while(count 62.二叉搜索树的第k个节点
给定一棵二叉搜索树，请找出其中的第k小的结点。例如， （5，3，7，2，4，6，8） 中，按结点数值大小顺序第三小结点的值为4。
辅助栈：递归将结点按右根左的顺序入栈，最后从栈顶到栈底是升序排列。
1.辅助栈：
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
import java.util.Stack;
public class Solution {
Stack stack=new Stack<>();
TreeNode KthNode(TreeNode pRoot, int k)
{
// 根大于左，小于右；最左子节点是最小值 中序遍历
if(pRoot==null || k<1)
return null;
//从最左子节点开始计数
helper(pRoot);
TreeNode temp=null;
while(!stack.empty() && k>0){
temp=stack.pop();
k--;
}
if(k>0)//当k大于结点个数时
return null;
return temp;
}
//从右到左入栈，从栈顶到栈底是升序
void helper(TreeNode root){
if(root!=null){
if(root.right!=null)
helper(root.right);//将右子节点入栈
stack.push(root);//将根入栈
if(root.left!=null)
helper(root.left);//将左子节点入栈
}
}
}
2.非递归：
假设有二叉搜索树为 2 3 4，求第三小的结点，以下过程为：
3入栈，2入栈（最左子节点），然后2出栈，不等，又因为2的右结点为空，所以3出栈，不等，但3的右结点非空，所以4入栈，然后4出栈。
import java.util.Stack;
public class Solution {
TreeNode KthNode(TreeNode pRoot, int k)
{
// 根大于左，小于右；最左子节点是最小值 中序遍历
if(pRoot==null || k<1)
return null;
//从最左子节点开始计数
TreeNode temp=pRoot;
Stack stack=new Stack<>();
int count=0;
while(temp!=null || !stack.isEmpty()){
if(temp!=null){//一直入左子节点，直到空
stack.push(temp);
temp=temp.left;
}else{
temp=stack.pop();//第一次出栈是最小值
count++;
if(count==k)
return temp;
temp=temp.right;//赋为右结点，若非空则将入栈即栈顶，此时左 根已遍历，下一个遍历结点即该右结点；空则接着出栈顶元素
}
}
return null;
}
}
63.数据流中的中位数
如何得到一个数据流中的中位数？如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。我们使用Insert()方法读取数据流，使用GetMedian()方法获取当前读取数据的中位数。
暴力解（时空复杂度过高）：ArrayList存储数字，然后赋值给数组排序，返回中位数；
大顶堆和小顶堆：大顶堆用来存较小的数，从大到小排列；小顶堆存较大的数，从小到大的顺序排序，显然中位数就是大顶堆的根节点与小顶堆的根节点和的平均数。
1.暴力解：
import java.util.Arrays;
import java.util.ArrayList;
public class Solution {
ArrayList res=new ArrayList<>();
public void Insert(Integer num) {
res.add(num);
}
public Double GetMedian() {
if(res.isEmpty())
return null;
double arr[]=new double[res.size()];
for(int i=0;i 2.堆排序（大顶堆、小顶堆）：
import java.util.PriorityQueue;
import java.util.Comparator;
public class Solution {
//小顶堆
private PriorityQueue minHeap = new PriorityQueue();
//大顶堆
private PriorityQueue maxHeap = new PriorityQueue(15, new Comparator() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
//记录偶数个还是奇数个
int count = 0;
//每次插入小顶堆的是当前大顶堆中最大的数
//每次插入大顶堆的是当前小顶堆中最小的数
//这样保证小顶堆中的数永远大于等于大顶堆中的数
//中位数就可以方便地从两者的根结点中获取了
public void Insert(Integer num) {
//奇数或偶数时入大或入小都可，关键是需要先入然后出最大或最小值入另一个堆中
//已有个数为偶数的话，则先插入到大顶堆，然后将大顶堆中最大的数插入小顶堆中
if(count % 2 == 0){
maxHeap.offer(num);
int max = maxHeap.poll();
minHeap.offer(max);
}else{
//已有个数为奇数的话，则先插入到小顶堆，然后将小顶堆中最小的数插入大顶堆中
minHeap.offer(num);
int min = minHeap.poll();
maxHeap.offer(min);
}
count++;
}
public Double GetMedian() {
//当前为偶数个，则取小顶堆和大顶堆的堆顶元素求平均
if(count % 2 == 0){
return new Double(minHeap.peek() + maxHeap.peek())/2;
}else{
//当前为奇数个，则直接从小顶堆中取元素即可
return new Double(minHeap.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]}。
暴力解；每次移动后遍历当前滑动窗口；
双端队列：对新来的元素k，将其与双端队列中的元素相比较 1）前面比k小的，直接移出队列（因为不再可能成为后面滑动窗口的最大值了!）,2）前面比k大的X，比较两者下标，判断X是否已不在窗口之内，不在了，直接移出队列队列的第一个元素是滑动窗口中的最大值
1.暴力解：
import java.util.ArrayList;
public class Solution {
public ArrayList maxInWindows(int [] num, int size)
{
//窗口里的最大值
ArrayList res=new ArrayList<>();
if(num.length<=0 || size<=0)//异常输入
return res;
int fir=0;//起始位置
int last=size-1;//末尾
int max=0;
if(size>num.length)//若只存在一个滑动窗口
return res;
while(lastmax)
max=num[i];
}
res.add(max);
fir++;
last++;
}
return res;
}
}
2.利用双端队列：
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
public class Solution {
public ArrayList maxInWindows(int [] num, int size)
{
//窗口里的最大值
ArrayList res=new ArrayList<>();
if(num.length<=0 || size<=0)//异常输入
return res;
Deque q=new LinkedList<>();
for(int i=0;iq.peekFirst())//此时队列内元素下标个数超过滑动窗口大小
q.pollFirst();//弹出队首元素
while(!q.isEmpty() && num[q.peekLast()]<= num[i])//若队尾元素小于当前元素，该步删除队列内比当前元素小的元素
q.pollLast();//将队尾元素弹出，即删除比当前元素小的元素的下标
q.add(i);//将当前元素下标入队
if(flag>=0)//说明当前是滑动窗口
res.add(num[q.peekFirst()]);//队首下标即当前滑动窗口内最大元素的下标
}
return res;
}
}
65.矩阵中的路径
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。如果一条路径经过了矩阵中的某一个格子，则该路径不能再进入该格子。 例如
\( \left[ \begin{matrix} a&b&c&e\\ s&f&c&s\\ a&d&e&e \end{matrix} \right] \)
矩阵中包含一条字符串"bcced"的路径，但是矩阵中不包含"abcb"路径，因为字符串的第一个字符b占据了矩阵中的第一行第二个格子之后，路径不能再次进入该格子。
回溯：找到第一个相同的然后开始递归判断，递归过程中如果不符合条件返回false，同时将当前位的访问状态重置。
1.回溯：
public class Solution {
public boolean hasPath(char[] matrix, int rows, int cols, char[] str)
{
int count=0;//第几个字符
boolean flag[]=new boolean[matrix.length];
if(rows<1 || cols<1 || str.length<1)
return false;
for(int i=0;i66.机器人的运动范围
地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。请问该机器人能够达到多少个格子？
递归。
1.递归：
public class Solution {
public int movingCount(int threshold, int rows, int cols)
{
boolean flag[]=new boolean[rows*cols];
if(rows<=0 || cols<=0 || threshold<0)
return 0;
int count=helper(rows,cols,0,0,threshold,flag);
return count;
}
int helper(int rows,int cols,int row,int col,int k,boolean[] flag){
//退出条件
if(row<0 || col<0 || row==rows || col==cols || flag[row*cols+col] || !checkSum(row,col,k))
return 0;
flag[row*cols+col]=true;//置为已访问
return helper(rows,cols,row-1,col,k,flag)+
helper(rows,cols,row+1,col,k,flag)+
helper(rows,cols,row,col-1,k,flag)+
helper(rows,cols,row,col+1,k,flag)+1;
}
//检查数位和
boolean checkSum(int row,int col,int k){
int sum=0;
while(row!=0 || col!=0){
if(row!=0){
sum+=row%10;
row=row/10;
}
if(col!=0){
sum+=col%10;
col/=10;
}
}
if(sum>k)
return false;
return true;
}
}
2.非递归：
public class Solution {
public int movingCount(int threshold, int rows, int cols)
{
if(rows<=0 || cols<=0 || threshold<0)
return 0;
int count=0;
//遍历每个点
for(int i=0;ik)
return false;
return true;
}
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。
输入描述：输入一个数n，意义见题面。（2 <= n <= 60）
找到规律：当都是2和3时乘积最大，且3的个数大于2的个数。
5<2*3,6<3*3,比6更大的数字我们就更不用考虑了，肯定要继续分。
1.：
public class Solution {
public int cutRope(int target) {
//m>1,n>1
//根据规律可看出是 2 和 3的乘积
int multi=1;
//小值判断
if(target<=3)
return target-1;
while(target>4){//只有5才可分为 2+3，比5小的直接当作一段时乘积最大
target-=3;
multi*=3;
}
return multi*target;
}
}
如有错误，欢迎指正