0915 算法题
文章目录
- 0915 算法题
-
- 重建二叉树
- 判断是否为二叉搜索树树的合法后序遍历
- 滑动窗口中位数 lt 480
- 二叉树前序遍历
- 任务分配所需的工人数
- 给定数组，查找符合要求的数子集
0915 算法题
重建二叉树
左子树长度为i-1,左闭右开就是i，i为根节点在中序遍历中的位置。左子树确定后，右子树的下标位置也就确定了。
root.left=reConstructBinaryTree(Arrays.copyOfRange(pre,1,1+i),Arrays.copyOfRange(vin,0,i));
root.right=reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,m),Arrays.copyOfRange(vin,i+1,n));
import java.util.*;
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
int m=pre.length;
int n=vin.length;
if(m==0 | n==0)
{
return null;
}
TreeNode root=new TreeNode(pre[0]);
for(int i=0;i判断是否为二叉搜索树树的合法后序遍历
最后一个元素为根节点，找到右子树的起始点，若起始点之后全部大于根节点为true，反之为false。再递归检查左右子树。
public boolean checkValid(int [] sequence)
{
if(sequence.length)
{
return true;
}
int root=sequence[sequence.length-1];
for(int i=0;i=root)
{
break;
}
}
for(int j=i;j 滑动窗口中位数 lt 480
给定数组nums，以及大小为k的窗口，每次向右滑动1个数字，请给出窗口每次滑动后的中位数，以数组形式返回。
通过一个大顶堆和小顶堆维护了窗口的中位数值，直接从堆中取出即可。
class Solution {
public double[] medianSlidingWindow(int[] nums, int k) {
/*
滑窗+对顶堆:
我们创建两个堆left和right,其中left是大顶堆存储小的一半元素,right为小顶堆存储大的一半元素
假定right存储的元素数目总是>=left存储的元素数目
1.当窗口元素总数为奇数时:中位数为排序k/2的数字,此时直接right堆顶就是答案
2.当窗口元素总数为偶数时:中位数为排序k/2与(k-1)/2的均值,此时将left堆顶与right堆顶取均值即可\
还要注意的是:窗口滑动过程中我们加入与删除元素后记得调整堆使得堆平衡
*/
int len = nums.length;
int cnt = len - k + 1; // 滑窗个数
double[] res = new double[cnt];
// Integer.compare(b, a)逻辑为:(x < y) ? -1 : ((x == y) ? 0 : 1) 只比较不会加减
PriorityQueue left = new PriorityQueue<>((a, b) -> Integer.compare(b, a)); // 大顶堆(注意不要b-a防止溢出)
PriorityQueue right = new PriorityQueue<>((a, b) -> Integer.compare(a, b)); // 小顶堆
// 初始化堆:[0,k-1] 使得right>=left
for (int i = 0; i < k; i++) {
right.add(nums[i]);
}
for (int i = 0; i < k / 2; i++) {
left.add(right.poll()); // 弹出最小的数字给left
}
// 首个中位数加入res
res[0] = getMid(left, right);
// 这里的i代表即将加入窗口的右端元素
for (int i = k; i < len; i++) {
int a = nums[i], b = nums[i - k]; // a为即将加入窗口的元素,b为即将退出窗口的元素
if (a >= right.peek()) {
right.add(a);
} else {
left.add(a);
}
if (b >= right.peek()) {
right.remove(b);
} else {
left.remove(b);
}
// 调整堆
adjust(left, right);
// 该窗口中位数加入结果
res[i - k + 1] = getMid(left, right);
}
return res;
}
// 调整堆使得堆平衡
private void adjust(PriorityQueue left, PriorityQueue right) {
while (left.size() > right.size()) right.add(left.poll()); // 左边比右边多,左边必定不符合条件,往右边搬
while (right.size() > left.size() + 1) left.add(right.poll()); // 右边比左边多1以上,右边必定多了,往左边搬
}
// 根据left与right两个堆返回中位数
private double getMid(PriorityQueue left, PriorityQueue right) {
if (left.size() == right.size()) return left.peek() / 2.0 + right.peek() / 2.0; // 范围不知道防止溢出
else return (double) right.peek();
}
}
二叉树前序遍历
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return int整型一维数组
*/
LinkedList result=new LinkedList<>();
public int[] preorderTraversal (TreeNode root) {
// write code here
answer(root);
int[] res=new int[result.size()];
for (int i = 0; i < result.size(); i++) {
res[i]=result.get(i);
}
return res;
}
public void answer (TreeNode root) {
if(root==null) return;
result.add(root.val);
answer(root.left);
answer(root.right);
}
}
任务分配所需的工人数
给定二维数组nx2，表示n个任务，2用来表示开始时间和结束时间。例如[[1,3],[2,4]]
一个工人同时只能处理一个任务，如图所示例子需要两个工人处理。
#暴力法：先排序，然后遍历每个任务，查找是否有开始时间小于当前任务结束时间的任务，如果有则表示两者相交，统计出最大相交次数。时间复杂度为O（n^2）。
#挑选：每次遍历取不相交的最大任务子集，多少次遍历取完就是需要多少个工人。
给定数组，查找符合要求的数子集
给定数组，查找三个数，使得他们互相相乘的和最大，输出最大值
给定数组，查找n个数，使得他们互相相乘的和最大,输出这些数
使用回溯法，这是一个子集树空间，第i层表示第i个元素取或者不取。当取到n个数，或者到达数组结尾则退出递归。