# 用这样的方法，我解决了leetcode的大部分的这种题型！

#### 第一题，leetcode中等难度题目

``````public List<Integer> lexicalOrder(int n) {
List<String> list = new ArrayList<>();
for(int i = 1; i <= n; i++){
}
Collections.sort(list,(o1,o2)->{
return o1.compareTo(o2);
});
List<Integer> iList = new ArrayList<>();
list.stream().forEach((str)->{
});
return iList;
}
``````

#### 第二题，leetcode中等难度题目

``````class Solution {
public int[] topKFrequent(int[] nums, int k) {
Queue<Obj> queue = new PriorityQueue<>(k,(o1,o2)->{
return o2.num - o1.num;
});

HashMap<Integer,Integer> map = new HashMap<>();

for(int i = 0; i < nums.length; i++){
map.put(nums[i],map.getOrDefault(nums[i],0) + 1);
}

for(int key : map.keySet()){
queue.offer(new Obj(key,map.get(key)));
}

int[] ans = new int[k];
int i = 0;
while(i < k){
ans[i] = queue.poll().target;
i++;
}

return ans;

}

class Obj {
public int target;
public int num;

public Obj(int target, int num){
this.target = target;
this.num = num;
}
}
}
``````

``````class Solution {
public List<Integer> topKFrequent(int[] nums, int k) {
HashMap<Integer, Integer> map = new HashMap();
for (int n: nums) {
map.put(n, map.getOrDefault(n, 0) + 1);
}

PriorityQueue<Integer> heap =
new PriorityQueue<Integer>((n1, n2) -> map.get(n1) - map.get(n2));

for (int n: map.keySet()) {
if (heap.size() > k)
heap.poll();
}

while (!heap.isEmpty())
Collections.reverse(top_k);
}
}

``````

``````Queue<Obj> queue = new PriorityQueue<>(k,(o1,o2)->{
return o2.num - o1.num;
});
``````

``````PriorityQueue<Integer> heap =
new PriorityQueue<Integer>((n1, n2) -> map.get(n1) - map.get(n2));
``````

``````Collections.sort(list,(o1,o2)->{
return o1.compareTo(o2);
});
``````

#### 第三题，更复杂点的

• 排序规则：按照先H高度降序，K个数升序排序
• 遍历排序后的数组，根据K插入到K的位置上

``````public int[][] reconstructQueue(int[][] people) {
// [7,0], [7,1], [6,1], [5,0], [5,2], [4,4]
// 再一个一个插入过程
// [7,0]
// [7,0], [7,1]
// [7,0], [6,1], [7,1]
// [5,0], [7,0], [6,1], [7,1]
// [5,0], [7,0], [5,2], [6,1], [7,1]
// [5,0], [7,0], [5,2], [6,1], [4,4], [7,1]
Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);

for (int[] i : people) {
//在i位置，插入数：i[1]是[7,0], [7,1], [6,1], [5,0], [5,2], [4,4]的第一个数，表示前面有几个比我高的。
}

return list.toArray(new int[list.size()][2]);
}
``````

``````Arrays.sort(people, (o1, o2) -> o1[0] == o2[0] ? o1[1] - o2[1] : o2[0] - o1[0]);
``````

#### 有收获？希望老铁们来个三连击，给更多的人看到这篇文章

1、老铁们，关注我的原创微信公众号「程序员的技术圈子」，专注于 Java、数据结构和算法、微服务、中间件等技术分享，保证你看完有所收获。

2、给俺点个赞呗，可以让更多的人看到这篇文章，顺便激励下我继续写作，嘻嘻。

3、另外，原创文章首发在我的个人博客：blog.ouyangsihai.cn，欢迎访问。

↓↓↓↓↓↓