NC刷题笔记5-队列

本博客文章（学习笔记）导航 （点击这里访问）

NC82 滑动窗口最大值

描述
给定一个长度为 n 的数组 num 和滑动窗口的大小 size ，找出所有滑动窗口里数值的最大值。
例如，如果输入数组 {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]}。
窗口大于数组长度或窗口长度为0的时候，返回空。
数据范围：1 ≤ n ≤ 10000，0 ≤ size ≤ 10000，数组中每个元素的值满足0 ≤∣val∣≤10000
要求：空间复杂度 O(n)，时间复杂度 O(n)

示例1  输入：[2,3,4,2,6,2,5,1],3  返回值：[4,4,6,6,6,5]
示例2  输入：[9,10,9,-7,-3,8,2,-6],5  返回值：[10,10,9,8]
示例3  输入：[1,2,3,4],5  返回值：[]

思路：
	优先队列
	1 先放size-1个
	2 从第size个开始放，没放一次就移除过界元素

import java.util.*;
public class Solution {
    public ArrayList<Integer> maxInWindows(int [] num, int size) {
        PriorityQueue<int[]> queue=new PriorityQueue<int[]>((a1,a2)->{
            return a1[0]==a2[0]?a1[1]-a2[1]:a2[0]-a1[0];
        });
        ArrayList<Integer> res=new ArrayList<Integer>();
        if(num.length==0||size==0) return res;
        for(int i=0;i<size-1;i++){
            queue.offer(new int[]{num[i],i});
        }
        for(int i=size-1;i<num.length;i++){
            queue.offer(new int[]{num[i],i});
            while(queue.peek()[1]<(i-size+1)){
                queue.poll();
            }
            res.add(queue.peek()[0]);
        }
        return res;
    }
}

NC123 序列化二叉树

请实现两个函数，分别用来序列化和反序列化二叉树，不对序列化之后的字符串进行约束，但要求能够根据序列化之后的字符串重新构造出一棵与原二叉树相同的树。
二叉树的序列化(Serialize)是指：把一棵二叉树按照某种遍历方式的结果以某种格式保存为字符串，从而使得内存中建立起来的二叉树可以持久保存。序列化可以基于先序、中序、后序、层序的二叉树等遍历方式来进行修改，序列化的结果是一个字符串，序列化时通过 某种符号表示空节点（#）
二叉树的反序列化(Deserialize)是指：根据某种遍历顺序得到的序列化字符串结果str，重构二叉树。
层序序列化(即用函数Serialize转化)如上的二叉树转为"{1,2,3,#,#,6,7}"，再能够调用反序列化(Deserialize)将"{1,2,3,#,#,6,7}"构造成如上的二叉树。
当然你也可以根据满二叉树结点位置的标号规律来序列化，还可以根据先序遍历和中序遍历的结果来序列化。不对序列化之后的字符串进行约束，所以欢迎各种奇思妙想。
数据范围：节点数n≤100，树上每个节点的值满足0≤val≤150
要求：序列化和反序列化都是空间复杂度 O(n)，时间复杂度 O(n)

示例1
输入：{1,2,3,#,#,6,7}
返回值：{1,2,3,#,#,6,7}

示例2
输入：{8,6,10,5,7,9,11}
返回值：{8,6,10,5,7,9,11}

思路：
	序列化：递归先序遍历
	反序列化：递归先序解码

public class Solution {
    public String Serialize(TreeNode root) {
        StringBuilder sb = new StringBuilder();
        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();
  }
   
   int index = -1;   //计数变量
   public TreeNode Deserialize(String str) {
        index++;
        String[] strr = str.split(",");
        TreeNode node = null;
        if(!strr[index].equals("#")){
            node = new TreeNode(Integer.valueOf(strr[index]));
            node.left = Deserialize(str);
            node.right = Deserialize(str);
        }
        return node;
   }
}

NC267 从上往下打印二叉树

描述
不分行从上往下打印出二叉树的每个节点，同层节点从左至右打印。例如输入{8,6,10,#,#,2,1}，如以下图中的示例二叉树，则依次打印8,6,10,2,1(空节点不打印，跳过)，请你将打印的结果存放到一个数组里面，返回。

示例1
输入：{8,6,10,#,#,2,1}
返回值：[8,6,10,2,1]

示例2
输入：{5,4,#,3,#,2,#,1}
返回值：[5,4,3,2,1]

思路：
	队列：层序遍历

import java.util.*;
public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        Queue<TreeNode> q=new LinkedList<>();
        ArrayList<Integer> res=new ArrayList<>();
        if(root==null) return res;
        q.offer(root);
        while(!q.isEmpty()){
            int n=q.size();
            for(int i=0;i<n;i++){
                TreeNode temp=q.poll();
                res.add(temp.val);
                if(temp.left!=null)  q.offer(temp.left);
                if(temp.right!=null) q.offer(temp.right);
            }
        }
        return res;
    }
}