2022-8-22 剑指offer-优先队列-每日一题-二叉树-搜索/递归

剑指 Offer II 060. 出现频率最高的 k 个数字

难度中等36收藏分享切换为英文接收动态反馈

给定一个整数数组 nums 和一个整数 k ，请返回其中出现频率前 k 高的元素。可以按 任意顺序 返回答案。

 1 class Solution {
 2     public int[] topKFrequent(int[] nums, int k) {
 3         Map<Integer,Integer> map=new HashMap<>();
 4         for (int x:nums){
 5             map.put(x,map.getOrDefault(x,0)+1);
 6         }
 7         PriorityQueue<Pair> q=new PriorityQueue<>(
 8                 (a,b)->(b.fre-a.fre)
 9         );
10         for (Map.Entry<Integer, Integer> e : map.entrySet()) {
11             q.offer(new Pair(e.getKey(),e.getValue()));
12         }
13         int[] ans=new int[k];
14         for (int i=0;i<k;i++){
15             ans[i]=q.poll().num;
16         }
17         return ans;
18     }
19 
20 
21 }
22 class Pair{
23     int num;
24     int fre;
25     Pair(int n,int f){
26         num=n;
27         fre=f;
28     }
29 }

思路：遍历一遍，得到统计次数，再用优先队列排序，输出。

655. 输出二叉树

难度中等151收藏分享切换为英文接收动态反馈

给你一棵二叉树的根节点 root ，请你构造一个下标从 0 开始、大小为 m x n 的字符串矩阵 res ，用以表示树的 格式化布局 。构造此格式化布局矩阵需要遵循以下规则：

• 树的 高度 为 height ，矩阵的行数 m 应该等于 height + 1 。
• 矩阵的列数 n 应该等于 2height+1 - 1 。
• 根节点 需要放置在 顶行 的 正中间 ，对应位置为 res[0][(n-1)/2] 。
• 对于放置在矩阵中的每个节点，设对应位置为 res[r][c] ，将其左子节点放置在 res[r+1][c-2height-r-1] ，右子节点放置在 res[r+1][c+2height-r-1] 。
• 继续这一过程，直到树中的所有节点都妥善放置。
• 任意空单元格都应该包含空字符串 "" 。

返回构造得到的矩阵 res 。

 1 /**
 2  * Definition for a binary tree node.
 3  * public class TreeNode {
 4  *     int val;
 5  *     TreeNode left;
 6  *     TreeNode right;
 7  *     TreeNode() {}
 8  *     TreeNode(int val) { this.val = val; }
 9  *     TreeNode(int val, TreeNode left, TreeNode right) {
10  *         this.val = val;
11  *         this.left = left;
12  *         this.right = right;
13  *     }
14  * }
15  */
16 class Solution {
17     public List<List<String>> printTree(TreeNode root) {
18         int height=getHeight(root);
19         int[][] arr=new int[height][(1<<height)-1];
20         //System.out.println((1<<height)-2);
21         for (int i=0;i<height;i++){
22             Arrays.fill(arr[i],-100);
23         }
24         Queue<Pair> q=new LinkedList<>();
25         q.offer(new Pair(root,((1<<height)-2)/2));
26         arr[0][((1<<height)-2)/2]=root.val;
27 
28         int h=1;
29         while (!q.isEmpty()){
30             int len=q.size();
31             for (int i=0;i<len;i++){
32                 Pair pair=q.poll();
33                 TreeNode node=pair.tree;
34                 if (node.left!=null) {
35                     
36                     arr[h][pair.pos-(1<<(height-h-1))]=node.left.val;
37                     
38                     q.offer(new Pair(node.left,pair.pos-(1<<(height-h-1))));
39                 }
40                 if (node.right!=null) {
41                     System.out.println(pair.pos+(1<<(height-h-1)));
42                     arr[h][pair.pos+(1<<(height-h-1))]=node.right.val;
43                     q.offer(new Pair(node.right,pair.pos+(1<<(height-h-1))));
44                 }
45             }
46             h++;
47         }
48         List<List<String>> ans=new ArrayList<>();
49         for (int i=0;i<height;i++){
50             List<String> l=new ArrayList<>();
51             for (int j=0;j<(1<<height)-1;j++){
52                 if (arr[i][j]==-100) l.add("");
53                 else l.add(String.valueOf(arr[i][j]));
54             }
55             ans.add(l);
56         }
57         return ans;
58     }
59 
60 
61 
62     public int getHeight(TreeNode root){
63         if (root==null) return 0;
64         return Math.max(getHeight(root.left),getHeight(root.right))+1;
65     }
66 }
67 
68 class Pair{
69     TreeNode tree;
70     int pos;
71     Pair(TreeNode t,int p){
72         tree=t;
73         pos=p;
74     }
75 }

思路：广度优先搜索，层序遍历。注意可以不开通arr数组，因为list也支持指定位置插入。

 

标签：TreeNode,val,22,offer,int,res,矩阵,二叉树,new
来源： https://www.cnblogs.com/benbicao/p/16612085.html