1 给你一个整数 num，请你找出同时满足下面全部要求的两个整数：
两数乘积等于 num + 1 或 num + 2
以绝对差进行度量，两数大小最接近
你可以按任意顺序返回这两个整数。
示例 1：
输入：num = 8
输出：[3,3]
解释：对于 num + 1 = 9，最接近的两个因数是 3 & 3；对于 num + 2 = 10, 最接近的两个因数是 2 & 5，因此返回 3 & 3 。
示例 2：
输入：num = 123
输出：[5,25]
示例 3：
输入：num = 999
输出：[40,25]
提示：
1 <= num <= 10^9
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/closest-divisors
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.company;
import java.io.*;
import java.util.*;
public class Main {
public static void main(String[] args) throws IOException {
int[] ints = closestDivisors(929467870);
System.out.println(ints);
}
/**
* 1 num1=num+1
* 2 num2=num+2
* 1..num1 % i==0 存一下值对a
* 2..num2 % i==0 存一下值对
*
* @param num
* @return
*/
public static int[] closestDivisors(int num) {
List<Pair> pairs1=new ArrayList<Pair>();
List<Pair> pairs2=new ArrayList<Pair>();
int num1=num+1;
int num2=num+2;
for(int i=1;i<num1;i++){
if(num1%i==0){
int x=num1/i;
pairs1.add(new Pair(i,x));
}
}
for(int i=1;i<num2;i++){
if(num2%i==0){
int x=num2/i;
pairs2.add(new Pair(i,x));
}
}
pairs1.addAll(pairs2);
int[] intArray = getIntArray(pairs1);
return intArray;
}
public static int[] getIntArray(List<Pair> pairs1){
Collections.sort(pairs1, new Comparator<Pair>() {
@Override
public int compare(Pair o1, Pair o2) {
return o1.getDiv()-o2.getDiv();
}
});
Pair pair = pairs1.get(0);
int x = pair.getX();
int y = pair.getY();
return new int[]{x,y};
}
static class Pair{
private int x;
private int y;
private int div;
public int getDiv() {
return div;
}
public void setDiv(int div) {
this.div = div;
}
public Pair(int x, int y){
this.x=x;
this.y=y;
this.div=Math.abs((x-y));
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
}
}
2 如果在二叉树中，存在一条一直向下的路径，且每个点的数值恰好一一对应以 head 为首的链表中每个节点的值，那么请你返回 True ，否则返回 False 。
一直向下的路径的意思是：从树中某个节点开始，一直连续向下的路径。
示例 1：
输入：head = [4,2,8], root = [1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3]
输出：true
解释：树中蓝色的节点构成了与链表对应的子路径。
自解
package com.xiao.it;
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.atomic.AtomicReference;
public class TestAitoolsUtils {
public static void main(String[] args) {
Solution solution=new Solution();
Integer[] link={1,4,2,6,8};
Integer[] tree={1,4,4,null,2,2,null,1,null,6,8,null,null,null,null,1,3};
ListNode root = new ListNode(link[0]);
solution.initList(root,0,link);
TreeNode treeNode= solution.initTree(tree);
boolean subPath = solution.isSubPath(root, treeNode);
System.out.println(subPath);
}
}
class Solution {
public static boolean flag=false;
public boolean isSubPath(ListNode head, TreeNode root) {
Queue<TreeNode> treeNodes=new LinkedList<TreeNode>();
treeNodes.add(root);
while(treeNodes.size()!=0){
TreeNode poll = treeNodes.poll();
int val = poll.getVal();
if(head.getVal()==val){
testTreeResult(head.getNext(), poll);
}else{
TreeNode left = poll.getLeft();
TreeNode right = poll.getRight();
treeNodes.add(left);
treeNodes.add(right);
}
}
return flag;
}
private void testTreeResult(ListNode head, TreeNode poll) {
if(head!=null&&(poll.getLeft()!=null || poll.getRight()!=null)){
TreeNode left = poll.getLeft();
TreeNode right = poll.getRight();
Integer next = head.getVal();
if(null!=left && next==left.getVal()){
testTreeResult(head.getNext(),left);
}
if(null!=right && next==right.getVal()){
testTreeResult(head.getNext(),right);
}
}
if(head==null){
flag=true;
}
}
public void initList(ListNode root,int index,Integer[] list){
int nextIndex=index+1;
if(nextIndex<list.length){
Integer integer = list[nextIndex];
ListNode next=new ListNode(integer);
root.setNext(next);
initList(next,nextIndex,list);
}
}
public TreeNode initTree(Integer[] tree){
Queue<Integer> queue=new ArrayDeque<Integer>();
for(int i=0;i<tree.length;i++){
Integer ele=tree[i];
if(null==ele){
queue.add(-1);
}else{
queue.add(ele);
}
}
Integer poll = queue.poll();
TreeNode roots=new TreeNode(poll);
Queue<TreeNode> treeNodes=new LinkedList<>();
treeNodes.add(roots);
while(!treeNodes.isEmpty()){
TreeNode root = treeNodes.poll();
Integer left = queue.poll();
if(null!=left &&left!=-1){
TreeNode leftNode = new TreeNode(left);
treeNodes.add(leftNode);
root.setLeft(leftNode);
}
Integer right =queue.poll();
if(null!=right &&right!=-1){
TreeNode rightNode = new TreeNode(right);
treeNodes.add(rightNode);
root.setRight(rightNode);
}
}
return roots;
}
}
class TreeNode{
private int val;
private TreeNode left;
private TreeNode right;
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public TreeNode getLeft() {
return left;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public TreeNode getRight() {
return right;
}
public void setRight(TreeNode right) {
this.right = right;
}
public TreeNode(){
}
public TreeNode(int val){
this.val=val;
}
public TreeNode(int val,TreeNode left,TreeNode right){
this.val=val;
this.right=right;
this.left=left;
}
public void setChildrens(TreeNode left,TreeNode right){
this.left=left;
this.right=right;
}
}
class ListNode{
public int val;
private ListNode next;
public ListNode(){
}
public ListNode(int val){
this.val=val;
}
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public ListNode getNext() {
return next;
}
public ListNode(int val, ListNode next){
this.val=val;
this.next=next;
}
public void setNext(ListNode nextNode){
this.next=nextNode;
}
}
3 给你一棵以 root 为根的二叉树，二叉树中的交错路径定义如下：
选择二叉树中 任意 节点和一个方向（左或者右）。
如果前进方向为右，那么移动到当前节点的的右子节点，否则移动到它的左子节点。
改变前进方向：左变右或者右变左。
重复第二步和第三步，直到你在树中无法继续移动。
交错路径的长度定义为：访问过的节点数目 - 1（单个节点的路径长度为 0 ）。
请你返回给定树中最长 交错路径 的长度。
package com.xiao.it;
import com.sun.javafx.collections.MappingChange;
import javax.smartcardio.TerminalFactory;
import java.security.KeyStore;
import java.util.*;
import java.util.stream.Collectors;
public class CreateTreeNodes {
public static void main(String[] args) {
Integer[] tree={1,null,1,1,1,null,null,1,1,null,1,null,null,null,1,null,1};
TreeNode root=initTree(tree);
int wayLength = longestZigZag(root);
System.out.println(wayLength);
}
public static TreeNode initTree(Integer[] tree){
Deque<Integer> queue=new LinkedList<>();
for(int i=0;i<tree.length;i++){
if(i==0){ continue;}
if(null==tree[i]){
queue.add(-1);
}else{
queue.add(tree[i]);
}
}
TreeNode root=new TreeNode(tree[0]);
createTreeNodes(root,queue);
return root;
}
private static void createTreeNodes(TreeNode root, Queue<Integer> queue) {
Deque<TreeNode> treeNodes=new LinkedList<TreeNode>();
treeNodes.add(root);
while(!treeNodes.isEmpty()){
TreeNode poll = treeNodes.poll();
Integer lVal = queue.poll();
if(null!=lVal && lVal!=-1){
TreeNode lNode=new TreeNode(lVal);
poll.setLeft(lNode);
treeNodes.add(lNode);
}
Integer rVal = queue.poll();
if(rVal!=null && rVal!=-1){
TreeNode rNode=new TreeNode(rVal);
poll.setRight(rNode);
treeNodes.add(rNode);
}
}
}
public static int longestZigZag(TreeNode root) {
Queue<TreeNode> queue=new LinkedList<TreeNode>();
travalRree(root,queue);
List<Entry> collect = queue.stream().map(ele -> {
int left = tryLeftLenth(ele);
int right = tryRightLenth(ele);
if (left >= right) {
return new Entry(ele, left);
}
return new Entry(ele, right);
}).collect(Collectors.toList());
collect.sort(new Comparator<Entry>() {
@Override
public int compare(Entry o1, Entry o2) {
return o2.val-o1.val;
}
});
return collect.get(0).val-1;
}
private static int tryRightLenth(TreeNode ele) {
if(ele!=null){
TreeNode right = ele.getRight();
int left = tryLeftLenth(right);
return left+1;
}
return 0;
}
private static int tryLeftLenth(TreeNode ele) {
if(ele!=null){
TreeNode left = ele.getLeft();
int right = tryRightLenth(left);
return right+1;
}
return 0;
}
private static void travalRree(TreeNode root, Queue<TreeNode> queue) {
if(root!=null){
queue.add(root);
travalRree(root.getLeft(),queue);
travalRree(root.getRight(),queue);
}
}
static class Entry{
private TreeNode key;
private Integer val;
public Entry(){
}
public Entry(TreeNode key,Integer val){
this.key=key;
this.val=val;
}
}
static class TreeNode {
int val;
TreeNode left;
TreeNode right;
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public TreeNode getLeft() {
return left;
}
public void setLeft(TreeNode left) {
this.left = left;
}
public TreeNode getRight() {
return right;
}
public void setRight(TreeNode right) {
this.right = right;
}
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
}
4 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
图示两个链表在节点 c1 开始相交：
题目数据 保证 整个链式结构中不存在环。
注意，函数返回结果后，链表必须 保持其原始结构 。
if(headA==null||headB==null){
return null;
}
Set<Integer> listNodeList=new HashSet<>();
ListNode q=headA;
while(q!=null){
listNodeList.add(q.hashCode());
q=q.next;
}
if(null==listNodeList||listNodeList.size()==0){
return null;
}
ListNode p=headB;
while(p!=null){
if(listNodeList!=null&&listNodeList.contains(p.hashCode())){
return p;
}
p=p.next;
}
return null;5 给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
public ListNode detectCycle(ListNode head) {
if(head==null ||head.next==null) return null;
Set<Integer> sets=new HashSet<>();
ListNode p=head;
while(p!=null){
if(sets.size()>0 && sets.contains(p.hashCode())){
return p;
}
sets.add(p.hashCode());
p=p.next;
}
return null;
}6 请设计一个栈，除了常规栈支持的pop与push函数以外，还支持min函数，该函数返回栈元素中的最小值。执行push、pop和min操作的时间复杂度必须为O(1)。
package com.company;
import com.sun.org.apache.bcel.internal.generic.NEW;
import java.util.*;
import java.util.concurrent.*;
/**
* 给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。
*
* 图示两个链表在节点 c1 开始相交：
["TripleInOne", "push", "push", "push", "pop", "pop", "pop", "peek"]
[[2], [0, 1], [0, 2], [0, 3], [0], [0], [0], [0]]
* [null,null,null,1,0,0,true]
*
*/
public class LinkList {
public static void main(String[] args) throws Exception {
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
System.out.println(minStack.getMin()); // --> 返回 -3.
minStack.pop();
System.out.println(minStack.top()); // --> 返回 0.
System.out.println(minStack.getMin()); // --> 返回 -2.
}
static class MinStack {
Deque<Integer> xStack;
Deque<Integer> minStack;
public MinStack() {
xStack = new LinkedList<Integer>();
minStack = new LinkedList<Integer>();
minStack.push(Integer.MAX_VALUE);
}
public void push(int x) {
xStack.push(x);
minStack.push(Math.min(minStack.peek(), x));
}
public void pop() {
xStack.pop();
minStack.pop();
}
public int top() {
return xStack.peek();
}
public int getMin() {
return minStack.peek();
}
}
}
7 实现一个MyQueue类，该类用两个栈来实现一个队列。
static class MyQueue {
static private Deque<Integer> instack=null;
static private Deque<Integer> oustack=null;
/** Initialize your data structure here. */
public MyQueue() {
instack=new LinkedList<Integer>();
oustack=new LinkedList<Integer>();
}
/** Push element x to the back of queue. */
public void push(int x) {
instack.push(x);
}
/** Removes the element from in front of queue and returns that element. */
public int pop() {
if(!empty()){
in2to(instack);
return oustack.pop();
}
return -1;
}
private void in2to(Deque<Integer> instack) {
Iterator<Integer> iterator = instack.iterator();
while(iterator.hasNext()){
Integer next = iterator.next();
oustack.push(next);
}
}
/** Get the front element. */
public int peek() {
return oustack.peek();
}
/** Returns whether the queue is empty. */
public boolean empty() {
return instack.isEmpty();
}
}8 给定一棵二叉树，设计一个算法，创建含有某一深度上所有节点的链表（比如，若一棵树的深度为 D，则会创建出 D 个链表）。返回一个包含所有深度的链表的数组。
import java.util.*;
public class MainClassTest {
public static void main(String[] args) {
int[] numbers={1,2,3,4,5,-1,7,8};
TreeNode treeNode = initTree(numbers);
ListNode[] listNodes = listOfDepth(treeNode);
System.out.println(listNodes);
}
private static TreeNode initTree(int[] numbers) {
Queue<Integer> queue=new LinkedList<Integer>();
Queue<TreeNode> treeNodes=new LinkedList<TreeNode>();
for(int i=0;i<numbers.length;i++){
if(i!=0){
queue.add(numbers[i]);
}
}
TreeNode root=new TreeNode(numbers[0]);
treeNodes.add(root);
while(!treeNodes.isEmpty()){
TreeNode poll = treeNodes.poll();
Integer le = queue.poll();
Integer rh = queue.poll();
if(null!=le){
TreeNode left=new TreeNode(le);
treeNodes.add(left);
poll.left=left;
}
if(null!=rh){
TreeNode right=new TreeNode(rh);
treeNodes.add(right);
poll.right=right;
}
}
return root;
}
// Definition for a binary tree node.
public static class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode(int x) { val = x; }
}
public static ListNode[] listOfDepth(TreeNode root) {
Queue<TreeNode> treeNodes=new LinkedList<>();
treeNodes.add(root);
Deque stack=new LinkedList();
List<ListNode> listNodes=new ArrayList<ListNode>();
while(!treeNodes.isEmpty()||!stack.isEmpty()){
while(!treeNodes.isEmpty()){
TreeNode poll = treeNodes.poll();
if(poll!=null){
stack.push(poll);//压栈
}
}
List<Integer> intres=new ArrayList<Integer>();
while(!stack.isEmpty()){
TreeNode treeNode = (TreeNode)stack.pop();
if(treeNode.val!=-1){
intres.add(treeNode.val);
}
treeNodes.offer(treeNode.left);
treeNodes.offer(treeNode.right);
}
Integer[] arr=new Integer[intres.size()];
intres.toArray(arr);
ListNode listNode=translateToLinkList(arr);
if(null!=listNode){
listNodes.add(listNode);
}
}
ListNode[] nodes=new ListNode[listNodes.size()];
return listNodes.toArray(nodes);
}
/**
* 返回一个有头节点的列表
* @param intres
* @return
*/
private static ListNode translateToLinkList(Integer[] intres) {
if(intres==null||intres.length==0){
return null;
}
ListNode head=new ListNode(intres[0]);
ListNode tail=head;
for(int j=0;j<intres.length;j++){
if(j!=0){
ListNode newNode=new ListNode(intres[j]);
tail.next=newNode;
tail=tail.next;
}
}
return head;
}
// Definition for singly-linked list.
public static class ListNode {
int val;
ListNode next;
ListNode(int x) { val = x; }
}
}
9
请你仅使用两个栈实现先入先出队列。队列应当支持一般队列支持的所有操作（push、pop、peek、empty）：
实现 MyQueue 类：
void push(int x) 将元素 x 推到队列的末尾
int pop() 从队列的开头移除并返回元素
int peek() 返回队列开头的元素
boolean empty() 如果队列为空，返回 true ；否则，返回 false
package com.company;
import java.util.Deque;
import java.util.LinkedList;
import java.util.concurrent.ConcurrentLinkedDeque;
public class TestLine {
public static void main(String[] args) {
MyQueue obj = new MyQueue();
obj.push(1);
int param_2 = obj.pop();
int param_3 = obj.peek();
boolean param_4 = obj.empty();
}
static class MyQueue {
Deque<Integer> inStack;
Deque<Integer> outStack;
public MyQueue() {
inStack = new LinkedList<Integer>();
outStack = new LinkedList<Integer>();
}
public void push(int x) {
inStack.push(x);
}
public int pop() {
if (outStack.isEmpty()) {
in2out();
}
return outStack.pop();
}
public int peek() {
if (outStack.isEmpty()) {
in2out();
}
return outStack.peek();
}
public boolean empty() {
return inStack.isEmpty() && outStack.isEmpty();
}
private void in2out() {
while (!inStack.isEmpty()) {
outStack.push(inStack.pop());
}
}
}
}
10 给你两个整数数组 startTime（开始时间）和 endTime（结束时间），并指定一个整数 queryTime 作为查询时间。
已知，第 i 名学生在 startTime[i] 时开始写作业并于 endTime[i] 时完成作业。
请返回在查询时间 queryTime 时正在做作业的学生人数。形式上，返回能够使 queryTime 处于区间 [startTime[i], endTime[i]]（含）的学生人数。
示例 1：
输入：startTime = [1,2,3], endTime = [3,2,7], queryTime = 4
输出：1
解释：一共有 3 名学生。
第一名学生在时间 1 开始写作业，并于时间 3 完成作业，在时间 4 没有处于做作业的状态。
第二名学生在时间 2 开始写作业，并于时间 2 完成作业，在时间 4 没有处于做作业的状态。
第三名学生在时间 3 开始写作业，预计于时间 7 完成作业，这是是唯一一名在时间 4 时正在做作业的学生。
示例 2：
输入：startTime = [4], endTime = [4], queryTime = 4
输出：1
解释：在查询时间只有一名学生在做作业。
示例 3：
输入：startTime = [4], endTime = [4], queryTime = 5
输出：0
示例 4：
输入：startTime = [1,1,1,1], endTime = [1,3,2,4], queryTime = 7
输出：0
示例 5：
输入：startTime = [9,8,7,6,5,4,3,2,1], endTime = [10,10,10,10,10,10,10,10,10], queryTime = 5
输出：5
提示：
startTime.length == endTime.length
1 <= startTime.length <= 100
1 <= startTime[i] <= endTime[i] <= 1000
1 <= queryTime <= 1000
class Solution {
public int busyStudent(int[] startTime, int[] endTime, int queryTime) {
if(startTime.length<=0 || endTime.length<=0) return 0;
if(startTime.length!=endTime.length) return 0;
int count=0;
for(int i=0;i<startTime.length;i++){
int x=startTime[i];
int y=endTime[i];
if(queryTime>=x && queryTime<=y){
count+=1;
}
}
return count;
}
}11
「句子」是一个用空格分隔单词的字符串。给你一个满足下述格式的句子 text :
句子的首字母大写
text 中的每个单词都用单个空格分隔。
请你重新排列 text 中的单词，使所有单词按其长度的升序排列。如果两个单词的长度相同，则保留其在原句子中的相对顺序。
请同样按上述格式返回新的句子。
示例 1：
输入：text = "Leetcode is cool"
输出："Is cool leetcode"
解释：句子中共有 3 个单词，长度为 8 的 "Leetcode" ，长度为 2 的 "is" 以及长度为 4 的 "cool" 。
输出需要按单词的长度升序排列，新句子中的第一个单词首字母需要大写。
示例 2：
输入：text = "Keep calm and code on"
输出："On and keep calm code"
解释：输出的排序情况如下：
"On" 2 个字母。
"and" 3 个字母。
"keep" 4 个字母，因为存在长度相同的其他单词，所以它们之间需要保留在原句子中的相对顺序。
"calm" 4 个字母。
"code" 4 个字母。
示例 3：
输入：text = "To be or not to be"
输出："To be or to be not"
提示：
text 以大写字母开头，然后包含若干小写字母以及单词间的单个空格。
1 <= text.length <= 10^5
package com.company;
import com.sun.tools.javac.util.StringUtils;
import java.util.*;
import java.util.stream.Collectors;
public class Main {
public static void main(String[] args) {
String keep_calm_and_code_on = arrangeWords("Leetcode is cool");
System.out.println(keep_calm_and_code_on);
}
public static String arrangeWords(String text) {
Map<Integer, List<String>> map=new HashMap<Integer, List<String>>();
String[] array = text.split(" ");
for(int i=0;i<array.length;i++){
int length = array[i].length();
List<String> linkList = map.get(length);
if(null==linkList){
linkList=new LinkedList<String>();
linkList.add(0,array[i]);
map.put(length,linkList);
}else{
linkList.add(0,array[i]);
}
}
StringBuilder stringBuilder = new StringBuilder();
map.keySet().stream().sorted(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o1 - o2;
}
}).collect(Collectors.<Integer>toList()).forEach(ele->{
List<String> linkList = map.get(ele);
Collections.reverse(linkList);
linkList.stream().forEach(eles->{
stringBuilder.append(eles.toLowerCase());
stringBuilder.append(" ");
});
});
String s = stringBuilder.toString().trim();
if(s.length()>0){
String s1 = s.substring(0, 1).toUpperCase();
String substring = s.substring(1, s.length());
return s1+substring;
}
return null;
}
}
12 给定两个以升序排列的整数数组 nums1 和 nums2 , 以及一个整数 k 。
定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。
请找到和最小的 k 个数对 (u1,v1), (u2,v2) ... (uk,vk) 。(未完成 力扣)
示例 1:
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数：
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
示例 2:
输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2
输出: [1,1],[1,1]
解释: 返回序列中的前 2 对数：
[1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
示例 3:
输入: nums1 = [1,2], nums2 = [3], k = 3
输出: [1,3],[2,3]
解释: 也可能序列中所有的数对都被返回:[1,3],[2,3]
提示:
1 <= nums1.length, nums2.length <= 104
-109 <= nums1[i], nums2[i] <= 109
nums1, nums2 均为升序排列
1 <= k <= 1000
package com.company;
import java.util.*;
import java.util.stream.Collectors;
public class MainClassTest {
public static void main(String[] args) {
int[] nums1={1,7,11};
int[] nums2={2,4,6};
int k = 3;
List<List<Integer>> lists = kSmallestPairs(nums1, nums2, k);
lists.stream().forEach(ele->{
ele.stream().forEach(el->{
System.out.print(el);
});
System.out.println();
});
}
public static List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
Queue<Node> priorityQueue=new PriorityQueue<Node>(new Comparator<Node>() {
@Override
public int compare(Node o1, Node o2) {
int max = Math.max(o1.x, o1.y);
int max1 = Math.max(o2.x, o2.y);
return max-max1;
}
});
for(int i=0;i<nums1.length;i++){
for(int j=0;j<nums2.length;j++){
Node node=new Node(nums1[i],nums2[j]);
if(priorityQueue.size()<k){
addQueueNode(priorityQueue, node);
continue;
}
Node peek = getLastNode(priorityQueue);
int result = node.compareTo(peek);
if(result<0){
priorityQueue.remove(getLastNode(priorityQueue));
addQueueNode(priorityQueue, node);
}
if(result==0){
priorityQueue.remove(getLastNode(priorityQueue));
priorityQueue.add(node);
}
}
}
return priorityQueue.stream().map(ele -> {
List<Integer> resutl = new ArrayList<>();
resutl.add(ele.x);
resutl.add(ele.y);
return resutl;
}).collect(Collectors.toList());
}
private static Node getLastNode(Queue<Node> priorityQueue) {
int index = priorityQueue.size()-1;
List<Node> collect = priorityQueue.stream()
.map(ele -> {
return ele.getIndex() == index ? ele : null;
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
Node lastNode = collect.get(0);
return lastNode;
}
private static void addQueueNode(Queue<Node> priorityQueue, Node node) {
int index = getIndex(priorityQueue);
node.setIndex(index);
priorityQueue.add(node);
}
private static int getIndex(Queue<Node> priorityQueue) {
if(priorityQueue.size()-1<0){
return 0;
}
return priorityQueue.size();
}
static class Node implements Comparable<Node>{
private int index;
private int x;
private int y;
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public int getX() {
return x;
}
public void setX(int x) {
this.x = x;
}
public int getY() {
return y;
}
public void setY(int y) {
this.y = y;
}
public Node(int x, int y){
this.x=x;
this.y=y;
}
public Node(int x,int y,int index){
this.x=x;
this.y=y;
this.index=index;
}
@Override
public int compareTo(Node o) {
int max = Math.max(this.x, this.y);
int max1 = Math.max(o.x, o.y);
return max-max1;
}
@Override
public boolean equals(Object o) {
if(o instanceof Node){
Node o1 = (Node) o;
int i = this.x - o1.x;
if(i!=0) return false;
int i1 = this.y - o1.y;
if(i1!=0) return false;
}
return super.equals(o);
}
@Override
public int hashCode() {
return Objects.hash(x, y);
}
}
}
13 给定一个迭代器类的接口，接口包含两个方法： next() 和 hasNext()。设计并实现一个支持 peek() 操作的顶端迭代器 -- 其本质就是把原本应由 next() 方法返回的元素 peek() 出来。
示例:
假设迭代器被初始化为列表 [1,2,3]。
调用 next() 返回 1，得到列表中的第一个元素。
现在调用 peek() 返回 2，下一个元素。在此之后调用 next() 仍然返回 2。
最后一次调用 next() 返回 3，末尾元素。在此之后调用 hasNext() 应该返回 false。
(已完成 力扣)
package com.company;
import java.util.*;
import java.util.concurrent.ConcurrentLinkedDeque;
import java.util.stream.Collectors;
class PeekingIterator implements Iterator<Integer> {
Queue<Integer> queue=new ConcurrentLinkedDeque<>();
public PeekingIterator(Iterator<Integer> iterator) {
for(;iterator.hasNext();){
Integer nex=iterator.next();
queue.offer(nex);
}
}
// Returns the next element in the iteration without advancing the iterator.
public Integer peek() {
if(!queue.isEmpty()){
return queue.peek();
}
return -1;
}
// hasNext() and next() should behave the same as in the Iterator interface.
// Override them if needed.
@Override
public Integer next() {
if(!queue.isEmpty()){
return queue.poll();
}
return -1;
}
@Override
public boolean hasNext() {
if(!queue.isEmpty()) return true;
return false;
}
public static void main(String[] args) {
int[] inters={1,2,3};
List<Integer> cols=new ArrayList<>();
Arrays.stream(inters).forEach(ele->{
cols.add(ele);
});
Iterator<Integer> iterator = cols.iterator();
PeekingIterator peekingIterator=new PeekingIterator(iterator);
Integer next = peekingIterator.next();
Integer peek = peekingIterator.peek();
Integer next1 = peekingIterator.next();
Integer next2 = peekingIterator.next();
boolean b = peekingIterator.hasNext();
String s="ja:%s:%s:%s:%s:%s";
System.out.println(String.format(s,next,peek,next1,next2,b));
}
}14 给你一个仅由字符 '0' 和 '1' 组成的字符串 s 。一步操作中，你可以将任一 '0' 变成 '1' ，或者将 '1' 变成 '0' 。
交替字符串 定义为：如果字符串中不存在相邻两个字符相等的情况，那么该字符串就是交替字符串。例如，字符串 "010" 是交替字符串，而字符串 "0100" 不是。
返回使 s 变成 交替字符串 所需的 最少 操作数。
示例 1：
输入：s = "0100"
输出：1
解释：如果将最后一个字符变为 '1' ，s 就变成 "0101" ，即符合交替字符串定义。
示例 2：
输入：s = "10"
输出：0
解释：s 已经是交替字符串。
示例 3：
输入：s = "1111"
输出：2
解释：需要 2 步操作得到 "0101" 或 "1010" 。
package com.company;
public class Leedcood {
public static void main(String[] args) {
//s = "0100"
String str="10010100";
int inter = minOperations(str);
System.out.println(inter);
}
public static int minOperations(String s) {
if(s.length()!=0){
char[] chars = s.toCharArray();
return Math.min(getResult(chars, '0'),getResult(chars,'1'));
}
return 0;
}
private static int getResult(char[] chars, char alenth) {
int result=0;
for(int i = 0; i< chars.length; i++){
if(i%2==0){
if(chars[i]!= alenth){
result +=1;
}
}else{
int is = Integer.parseInt(String.valueOf(alenth));
int i1 = is ^ 1;
if(Integer.parseInt(String.valueOf(chars[i]))!=i1){
result +=1;
}
}
}
return result;
}
}
15 我们有一个由平面上的点组成的列表 points。需要从中找出 K 个距离原点 (0, 0) 最近的点。
（这里，平面上两点之间的距离是欧几里德距离。）
你可以按任何顺序返回答案。除了点坐标的顺序之外，答案确保是唯一的。
示例 1：
输入：points = [[1,3],[-2,2]], K = 1
输出：[[-2,2]]
解释：
(1, 3) 和原点之间的距离为 sqrt(10)，
(-2, 2) 和原点之间的距离为 sqrt(8)，
由于 sqrt(8) < sqrt(10)，(-2, 2) 离原点更近。
我们只需要距离原点最近的 K = 1 个点，所以答案就是 [[-2,2]]。
示例 2：
输入：points = [[3,3],[5,-1],[-2,4]], K = 2
输出：[[3,3],[-2,4]]
（答案 [[-2,4],[3,3]] 也会被接受。）
package com.xxl.job.admin.util;
import java.util.Comparator;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Queue;
public class FindKleast {
public static void main(String[] args) {
int[][] pint={{3,3},{5,-1},{-2,4}};
int[][] ints = kClosest(pint, 2);
System.out.println(ints[0]);
}
public static int[][] kClosest(int[][] points, int k) {
Queue<Point> queue=new PriorityQueue<>(new Comparator<Point>() {
@Override
public int compare(Point o1, Point o2) {
return o2.getPow()-o1.getPow();
}
});
for (int i=0;i<points.length;i++){
int[] point = points[i];
Point poin = new Point(point[0], point[1]);
Point peek = queue.peek();
if(null==peek){
queue.add(poin);
continue;
}
if(queue.size()<k){
queue.add(poin);
continue;
}
Point pee = queue.peek();
int pow = pee.getPow();
int pow1 = poin.getPow();
if(pow-pow1>=0){
queue.poll();
queue.add(poin);
}
}
int[][] result=new int[queue.size()][2];
int index=0;
while(!queue.isEmpty()){
Point poll = queue.poll();
int[] array = poll.getArray();
result[index]=array;
index++;
}
return result;
}
static class Point implements Comparable<Point>{
private int x;
private int y;
Point(int x,int y){
this.x=x;
this.y=y;
}
public int[] getArray(){
return new int[]{x,y};
}
@Override
public int compareTo(Point newPoint) {
return newPoint.getPow()-this.getPow();
}
public int getPow(){
return (int)(Math.pow(this.x,2)+Math.pow(this.y,2));
}
}
}
16 给你一个由一些多米诺骨牌组成的列表 dominoes。
如果其中某一张多米诺骨牌可以通过旋转 0 度或 180 度得到另一张多米诺骨牌，我们就认为这两张牌是等价的。
形式上，dominoes[i] = [a, b] 和 dominoes[j] = [c, d] 等价的前提是 a==c 且 b==d，或是 a==d 且 b==c。
在 0 <= i < j < dominoes.length 的前提下，找出满足 dominoes[i] 和 dominoes[j] 等价的骨牌对 (i, j) 的数量。
示例：
输入：dominoes = [[1,2],[2,1],[3,4],[5,6]]
输出：1
public class Mutils {
public static void main(String[] args) {
int[][] dominoes={{1,2},{2,1},{3,4},{5,6}};
int i = numEquivDominoPairs(dominoes);
System.out.println(i);
}
public static int numEquivDominoPairs(int[][] dominoes) {
int[] num = new int[100];
int ret = 0;
for (int[] domino : dominoes) {
int val = domino[0] < domino[1] ? domino[0] * 10 + domino[1] : domino[1] * 10 + domino[0];
ret += num[val];
num[val]++;
}
return ret;
}
}
17 给定一个数组 nums，编写一个函数将所有 0 移动到数组的末尾，同时保持非零元素的相对顺序。
示例:
输入: [0,1,0,3,12]
输出: [1,3,12,0,0]
public class MoveZeroes {
public static void main(String[] args) {
int[] news={0,1,0,3,12};
Integer[] integers = moveZeroes(news);
Arrays.stream(integers).forEach(el->{
System.out.println(el);
});
}
public static Integer[] moveZeroes(int[] nums) {
int count=0;
List<Integer> numsx=new ArrayList<>();
for (int num : nums) {
if(num==0){
count++;
continue;
}else{
numsx.add(num);
}
}
for(int j=count;j>0;j--){
numsx.add(0);
}
Integer[] arrays=new Integer[numsx.size()];
return numsx.toArray(arrays);
}
}18 给你一个 严格递增 的整数数组 rungs ，用于表示梯子上每一台阶的 高度 。当前你正站在高度为 0 的地板上，并打算爬到最后一个台阶。
另给你一个整数 dist 。每次移动中，你可以到达下一个距离你当前位置（地板或台阶）不超过 dist 高度的台阶。当然，你也可以在任何正 整数 高度处插入尚不存在的新台阶。
返回爬到最后一阶时必须添加到梯子上的 最少 台阶数。
示例 1：
输入：rungs = [1,3,5,10], dist = 2
输出：2
解释：
现在无法到达最后一阶。
在高度为 7 和 8 的位置增设新的台阶，以爬上梯子。
梯子在高度为 [1,3,5,7,8,10] 的位置上有台阶。
示例 2：
输入：rungs = [3,6,8,10], dist = 3
输出：0
解释：
这个梯子无需增设新台阶也可以爬上去。
示例 3：
输入：rungs = [3,4,6,7], dist = 2
输出：1
解释：
现在无法从地板到达梯子的第一阶。
在高度为 1 的位置增设新的台阶，以爬上梯子。
梯子在高度为 [1,3,4,6,7] 的位置上有台阶。
示例 4：
输入：rungs = [5], dist = 10
输出：0
解释：这个梯子无需增设新台阶也可以爬上去。
public class AddRungs {
public static void main(String[] args) {
int rang[]={4,8,12,16};
int step = addRungs(rang, 3);
System.out.println(step);
}
public static int addRungs(int[] rungs, int dist) {
int[] array=new int[rungs.length+1];
if(rungs[0]!=0){
System.arraycopy(rungs,0,array,1,rungs.length);
}
int numRang=0;
for(int i=0;i<array.length;i++){
int j=i+1;
if(j>=array.length){
break;
}
boolean bigger=array[i]+dist>=array[j];
if(!bigger){
int d= array[j]-array[i]-1;
numRang+=d/dist;
}
}
return numRang<0?0:numRang;
}
}19.
有 3n 堆数目不一的硬币，你和你的朋友们打算按以下方式分硬币：
每一轮中，你将会选出 任意 3 堆硬币（不一定连续）。
Alice 将会取走硬币数量最多的那一堆。
你将会取走硬币数量第二多的那一堆。
Bob 将会取走最后一堆。
重复这个过程，直到没有更多硬币。
给你一个整数数组 piles ，其中 piles[i] 是第 i 堆中硬币的数目。
返回你可以获得的最大硬币数目。
示例 1：
输入：piles = [2,4,1,2,7,8]
输出：9
解释：选出 (2, 7, 8) ，Alice 取走 8 枚硬币的那堆，你取走 7 枚硬币的那堆，Bob 取走最后一堆。
选出 (1, 2, 4) , Alice 取走 4 枚硬币的那堆，你取走 2 枚硬币的那堆，Bob 取走最后一堆。
你可以获得的最大硬币数目：7 + 2 = 9.
考虑另外一种情况，如果选出的是 (1, 2, 8) 和 (2, 4, 7) ，你就只能得到 2 + 4 = 6 枚硬币，这不是最优解。
示例 2：
输入：piles = [2,4,5]
输出：4
示例 3：
输入：piles = [9,8,7,6,5,1,2,3,4]
输出：18
解题提示：每次让Bob取走最少的，就能保证你取到的是最大的
package com.xxl.job.admin.util;
import java.util.Arrays;
public class MaxCoins {
public static void main(String[] args) {
int[] piles={2,4,1,2,7,8};
int maxCoins = maxCoins(piles);
System.out.println(maxCoins);
}
public static int maxCoins(int[] piles) {
Arrays.sort(piles);
int round=(int)piles.length/3;
int sumCoin=0;
int index=piles.length-2;
for(int i=0;i<round;i++){
sumCoin=sumCoin+piles[index];
index=index-2;
}
return sumCoin;
}
}
20 实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/shu-zhi-de-zheng-shu-ci-fang-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
public class MyPow {
public static void main(String[] args) {
double result = myPow(2, -2147483648);
System.out.println(result);
}
public static double myPow(double x, int n) {
double result=1;
if(n==0 ||x==1){
return result;
}
if(x==-1 && n%2==0){
return 1;
}
if(x==-1 && n%2!=0){
return -1;
}
if(n>0){
for(int i=n;i>0;i--){
result=result*x;
}
return result;
}
String substring = String.valueOf(n).substring(1);
long num=Long.valueOf(substring);
for(long i=num;i>0;i--){
result=result/x;
if(result==0){
break;
}
}
return result;
}
}
21
给你一个字符串 s ，字符串的「能量」定义为：只包含一种字符的最长非空子字符串的长度。
请你返回字符串的能量。
示例 1：
输入：s = "leetcode"
输出：2
解释：子字符串 "ee" 长度为 2 ，只包含字符 'e' 。
示例 2：
输入：s = "abbcccddddeeeeedcba"
输出：5
解释：子字符串 "eeeee" 长度为 5 ，只包含字符 'e' 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/consecutive-characters
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
public class MaxPower {
public static void main(String[] args) {
String subString="tourist";
int time = maxPower(subString);
System.out.println(time);
}
public static int maxPower(String subString) {
char[] chars = subString.toCharArray();
int result=0;
for(int i=0;i<chars.length;i++){
int count=1;
for(int j=i+1;j<chars.length;j++){
if(chars[i]==chars[j]){
count++;
}else {
break;
}
}
if(count>=result){
result=count;
}
}
return result;
}
}
22. 给你一个字符串 s ，由 n 个字符组成，每个字符不是 'X' 就是 'O' 。
一次 操作 定义为从 s 中选出 三个连续字符 并将选中的每个字符都转换为 'O' 。注意，如果字符已经是 'O' ，只需要保持 不变 。
返回将 s 中所有字符均转换为 'O' 需要执行的 最少 操作次数。
示例 1：
输入：s = "XXX"
输出：1
解释：XXX -> OOO
一次操作，选中全部 3 个字符，并将它们转换为 'O' 。
示例 2：
输入：s = "XXOX"
输出：2
解释：XXOX -> OOOX -> OOOO
第一次操作，选择前 3 个字符，并将这些字符转换为 'O' 。
然后，选中后 3 个字符，并执行转换。最终得到的字符串全由字符 'O' 组成。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/minimum-moves-to-convert-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
public class MinimumMoves {
public static void main(String[] args) {
String str = "XXXOOXXX";
int i = minimumMoves(str);
System.out.println(i);
}
public static int minimumMoves(String s) {
char[] chars = s.toCharArray();
if (chars.length < 3) {
return 0;
}
int result = 0;
boolean flag = false;
int step=0;
for (int i = 0; i < chars.length; i++) {
char aChar = chars[i];
if (aChar == 'X') {
chars[i] = 'O';
flag = true;
}
if(flag){
step++;
}
int index = i + 1;
if ((step==3 && flag) || (index == chars.length && flag)) {
result += 1;
step=0;
flag = false;
}
}
return result;
}
}
23 给你一个整数数组 arr 。请你将数组中的元素按照其二进制表示中数字 1 的数目升序排序。
如果存在多个数字二进制中 1 的数目相同，则必须将它们按照数值大小升序排列。
请你返回排序后的数组。(面试好题)
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-integers-by-the-number-of-1-bits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
import java.util.*;
public class SortByBits {
private static List link=new ArrayList();
public static void main(String[] args) {
int arr[]={0,1,2,3,4,5,6,7,8};
int[] ints = sortByBits(arr);
for(int i=0;i<ints.length;i++){
System.out.print(ints[i]);
}
}
public static int[] sortByBits(int[] arr) {
Map<Integer,List> maps=new HashMap<>();
for(int i=0;i<arr.length;i++){
String str = Integer.toBinaryString(arr[i]);
int oneNumber = getOneNumber(str);
List list = maps.get(oneNumber);
if(list==null){
List arrs=new ArrayList();
arrs.add(arr[i]);
maps.put(oneNumber,arrs);
}else {
list.add(arr[i]);
}
}
Set<Integer> integerSet = maps.keySet();
List li=new ArrayList(integerSet);
Collections.sort(li);
List result=new ArrayList();
for(int i=0;i<li.size();i++){
List list = maps.get(li.get(i));
Collections.sort(list);
result.addAll(list);
}
int[] finalints = result
.stream()
.mapToInt(k -> (int) k)
.toArray();
return finalints;
}
/**wo
* 获取字符串中1的个数
* @param str
* @return
*/
private static int getOneNumber(String str) {
int count=0;
char[] chars = str.toCharArray();
for(int i=0;i<chars.length;i++){
if(chars[i]=='1'){
count++;
}
}
return count;
}
}
24 给你一个字符串 s ，请你判断它是否 有效 。
字符串 s 有效 需要满足：假设开始有一个空字符串 t = "" ，你可以执行 任意次 下述操作将 t 转换为 s ：
将字符串 "abc" 插入到 t 中的任意位置。形式上，t 变为 tleft + "abc" + tright，其中 t == tleft + tright 。注意，tleft 和 tright 可能为 空 。
如果字符串 s 有效，则返回 true；否则，返回 false。
示例 1：
输入：s = "aabcbc"
输出：true
解释：
"" -> "abc" -> "aabcbc"
因此，"aabcbc" 有效。
示例 2：
输入：s = "abcabcababcc"
输出：true
解释：
"" -> "abc" -> "abcabc" -> "abcabcabc" -> "abcabcababcc"
因此，"abcabcababcc" 有效。
示例 3：
输入：s = "abccba"
输出：false
解释：执行操作无法得到 "abccba" 。
示例 4：
输入：s = "cababc"
输出：false
解释：执行操作无法得到 "cababc" 。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/check-if-word-is-valid-after-substitutions
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
public class IsValid {
public static void main(String[] args) {
String s="abccba";
boolean valid = isValid(s);
System.out.println(valid);
}
public static boolean isValid(String s) {
if(s.length()<3){
return false;
}
while(s.indexOf("abc")!=-1){
int abc = s.indexOf("abc");
if(abc+3<=s.length()){
s=s.substring(0,abc)+s.substring(abc+3);
}else{
s=s.substring(0,abc);
}
}
if(s.length()>0){
return false;
}
return true;
}
}
25 给定两个字符串 s 和 t ，编写一个函数来判断它们是不是一组变位词（字母异位词）。
注意：若 s 和 t 中每个字符出现的次数都相同且字符顺序不完全相同，则称 s 和 t 互为变位词（字母异位词）。
示例 1:
输入: s = "anagram", t = "nagaram"
输出: true
示例 2:
输入: s = "rat", t = "car"
输出: false
示例 3:
输入: s = "a", t = "a"
输出: false
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/dKk3P7
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package com.xxl.job.admin.util;
public class IsAnagram {
public static void main(String[] args) {
String s="rat";
String t="car";
boolean anagram = isAnagram(s, t);
System.out.print(anagram);
}
public static boolean isAnagram(String s, String t) {
if(s.length()!=t.length()){
return false;
}
char[] chars = s.toCharArray();
boolean flag=false;
for(int i=0;i<chars.length;i++){
char aChar = chars[i];
int i1 = t.indexOf(aChar);
if(i1==-1){
flag=false;
break;
}
t=t.substring(0,i1)+t.substring(i1+1);
if(i!=i1){
flag=true;
}
}
if(flag && t.length()==0){
return true;
}
return false;
}
}
26
给你一个非递减的 有序 整数数组，已知这个数组中恰好有一个整数，它的出现次数超过数组元素总数的 25%。
请你找到并返回这个整数
示例：
输入：arr = [1,2,2,6,6,6,6,7,10]
输出：6
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/element-appearing-more-than-25-in-sorted-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package xxl.job.admin.util;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.stream.Collectors;
public class FindSpecialInteger {
public static void main(String[] args) {
int [] arr={1,2,3,3};
int specialInteger = findSpecialInteger(arr);
System.out.println(specialInteger);
}
public static int findSpecialInteger(int[] arr) {
Map<Integer,Integer> map=new HashMap();
for(int i=0;i<arr.length;i++){
int number = arr[i];
Integer integer = map.get(number);
if(integer==null){
map.put(number,1);
}else{
integer+=1;
map.put(number,integer);
}
}
List<Integer> collect = map.entrySet()
.stream()
.map(item -> {
Integer value = item.getValue();
double num=value / new Double(arr.length);
if ( num > 0.25) {
return item.getKey();
}
return null;
})
.filter(Objects::nonNull)
.collect(Collectors.toList());
if(collect.size()<=0){
return 0;
}
return collect.get(0);
}
}
27
给你一个字符串 word ，该字符串由数字和小写英文字母组成。
请你用空格替换每个不是数字的字符。例如，"a123bc34d8ef34" 将会变成 " 123 34 8 34" 。注意，剩下的这些整数为（相邻彼此至少有一个空格隔开）："123"、"34"、"8" 和 "34" 。
返回对 word 完成替换后形成的 不同 整数的数目。
只有当两个整数的 不含前导零 的十进制表示不同， 才认为这两个整数也不同。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-different-integers-in-a-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package xxl.job.admin.util;
import java.util.HashSet;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class NumDifferentIntegers {
public static void main(String[] args) {
String word = "a1b01c001";
int i = numDifferentIntegers(word);
System.out.println(i);
}
public static int numDifferentIntegers(String word) {
String reg="[0-9]+";
// 创建 Pattern 对象
Pattern r = Pattern.compile(reg);
Set<String> set=new HashSet<String>();
// 现在创建 matcher 对象
Matcher m = r.matcher(word);
while(m.find()){
String group = m.group();
String s = removeZero(group);
set.add(s);
}
return set.size();
}
public static String removeZero(String str) {
int len = str.length(), i = 0;
while (i < len && str.charAt(i) == '0') {
i++;
}
return str.substring(i);
}
}
28 给你一个整数 n ，对于 0 <= i <= n 中的每个 i ，计算其二进制表示中 1 的个数 ，返回一个长度为 n + 1 的数组 ans 作为答案。
示例 1：
输入：n = 2
输出：[0,1,1]
解释：
0 --> 0
1 --> 1
2 --> 10
示例 2：
输入：n = 5
输出：[0,1,1,2,1,2]
解释：
0 --> 0
1 --> 1
2 --> 10
3 --> 11
4 --> 100
5 --> 101
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/counting-bits
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
public class CountBits {
public static void main(String[] args) {
int[] ints = countBits(5);
for(int i=0;i<ints.length;i++){
System.out.println(ints[i]);
}
}
public static int[] countBits(int n) {
int[] result=new int[n+1];
for(int i=0;i<=n;i++){
String string = Integer.toBinaryString(i);
char[] chars = string.toCharArray();
int sum=0;
for(int j=0;j<chars.length;j++){
sum+=Integer.parseInt(chars[j]+"");
}
result[i]=sum;
}
return result;
}
}
29 给你一个整数数组 arr 和一个整数 difference，请你找出并返回 arr 中最长等差子序列的长度，该子序列中相邻元素之间的差等于 difference 。
子序列 是指在不改变其余元素顺序的情况下，通过删除一些元素或不删除任何元素而从 arr 派生出来的序列。
示例 1：
输入：arr = [1,2,3,4], difference = 1
输出：4
解释：最长的等差子序列是 [1,2,3,4]。
示例 2：
输入：arr = [1,3,5,7], difference = 1
输出：1
解释：最长的等差子序列是任意单个元素。
示例 3：
输入：arr = [1,5,7,8,5,3,4,2,1], difference = -2
输出：4
解释：最长的等差子序列是 [7,5,3,1]。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package xxl.job.admin.util;
import java.util.*;
public class LongestSubsequence {
public static void main(String[] args) {
int[] num={10,-11,8,-1,-14,-5,7,15,7,-2,14,5,-3,-9,12,-9};
int i = longestSubsequence(num, -2);
System.out.println(i);
}
public static int longestSubsequence(int[] arr, int difference) {
Map<Integer,Integer> mapSet=new HashMap<>();
int ans=0;
for(int i=0;i<arr.length;i++){
int arri = arr[i];
Integer kes=(arri-difference);
Integer val = mapSet.get(kes);
if(val==null){
val=0;
}
mapSet.put(arri,val+1);
ans=Math.max(ans,mapSet.get(arri));
}
return ans;
}
}
30 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：
左括号必须用相同类型的右括号闭合。
左括号必须以正确的顺序闭合。
示例 1：
输入：s = "()"
输出：true
示例 2：
输入：s = "()[]{}"
输出：true
示例 3：
输入：s = "(]"
输出：false
示例 4：
输入：s = "([)]"
输出：false
示例 5：
输入：s = "{[]}"
输出：true
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/valid-parentheses
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package xxl.job.admin.util;
import java.util.Deque;
import java.util.concurrent.ConcurrentLinkedDeque;
/**
* 给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
*
* 有效字符串需满足：
*
* 左括号必须用相同类型的右括号闭合。
* 左括号必须以正确的顺序闭合。
*
*
* 示例 1：
*
* 输入：s = "()"
* 输出：true
* 示例 2：
*
* 输入：s = "()[]{}"
* 输出：true
* 示例 3：
*
* 输入：s = "(]"
* 输出：false
* 示例 4：
*
* 输入：s = "([)]"
* 输出：false
* 示例 5：
*
* 输入：s = "{[]}"
* 输出：true
*
* 来源：力扣（LeetCode）
* 链接：https://leetcode-cn.com/problems/valid-parentheses
* 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
*/
public class StrIsValid {
public static void main(String[] args) {
String st="{[]}";
boolean valid = isValid(st);
System.out.println(valid);
}
public static boolean isValid(String s) {
char[] chars1 = s.toCharArray();
if (chars1.length % 2 != 0) {
return false;
}
if(s.startsWith(")")||s.startsWith("]")||s.startsWith("}")){
return false;
}
Deque<Character> stackLeft=new ConcurrentLinkedDeque();
char[] chars = s.toCharArray();
for (int i = 0; i < chars.length; i++) {
char aChar = chars[i];
if (aChar == '(' || aChar == '{' || aChar == '[') {
stackLeft.push(aChar);
continue;
}
if (aChar == ')') {
Character peek = stackLeft.peek();
if (peek != null && peek == '(') {
stackLeft.pop();
}else{
stackLeft.push(aChar);
}
}
if (aChar == ']') {
Character peek = stackLeft.peek();
if (peek != null && peek == '[') {
stackLeft.pop();
}else{
stackLeft.push(aChar);
}
}
if (aChar == '}') {
Character peek = stackLeft.peek();
if (peek != null && peek == '{') {
stackLeft.pop();
}else{
stackLeft.push(aChar);
}
}
}
if(stackLeft.isEmpty()){
return true;
}
return false;
}
}
31 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。
给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
示例 1：
输入：[1,2,3,1]
输出：4
解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。
偷窃到的最高金额 = 1 + 3 = 4 。
示例 2：
输入：[2,7,9,3,1]
输出：12
解释：偷窃 1 号房屋 (金额 = 2), 偷窃 3 号房屋 (金额 = 9)，接着偷窃 5 号房屋 (金额 = 1)。
偷窃到的最高金额 = 2 + 9 + 1 = 12 。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/house-robber
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
public class Rob {
public static void main(String[] args) {
//[4,1,2,7,5,3,1]
int[] number = {4,1,2,7,5,3,1};
System.out.println(rob(number));
}
public static int rob(int[] nums) {
int[] sum = new int[nums.length];
for (int i = 0; i < nums.length; i++) {
if (i == 0) {
sum[i] = nums[0];
continue;
}
if (i == 1) {
sum[i] = Math.max(nums[0], nums[1]);
continue;
}
if (i > 1) {
sum[i]=Math.max(sum[i-1],sum[i-2]+nums[i]);
continue;
}
}
return sum[nums.length-1];
}
}
32 给定两个以 升序排列 的整数数组 nums1 和 nums2 , 以及一个整数 k 。
定义一对值 (u,v)，其中第一个元素来自 nums1，第二个元素来自 nums2 。
请找到和最小的 k 个数对 (u1,v1), (u2,v2) ... (uk,vk) 。
示例 1:
输入: nums1 = [1,7,11], nums2 = [2,4,6], k = 3
输出: [1,2],[1,4],[1,6]
解释: 返回序列中的前 3 对数：
[1,2],[1,4],[1,6],[7,2],[7,4],[11,2],[7,6],[11,4],[11,6]
示例 2:
输入: nums1 = [1,1,2], nums2 = [1,2,3], k = 2
输出: [1,1],[1,1]
解释: 返回序列中的前 2 对数：
[1,1],[1,1],[1,2],[2,1],[1,2],[2,2],[1,3],[1,3],[2,3]
示例 3:
输入: nums1 = [1,2], nums2 = [3], k = 3
输出: [1,3],[2,3]
解释: 也可能序列中所有的数对都被返回:[1,3],[2,3]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-k-pairs-with-smallest-sums (超时)
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
public class KSmallestPairs {
public static void main(String[] args) {
int[] nums1={1,2,4,5,6};
int[] nums2={3,5,7,9};
int k=3;
List<List<Integer>> lists = kSmallestPairs(nums1, nums2, k);
System.out.println(JSONObject.toJSONString(lists));
}
public static List<List<Integer>> kSmallestPairs(int[] nums1, int[] nums2, int k) {
List<List<Integer>> result = new ArrayList<>();
Queue<NumberPair> queue = new PriorityQueue<>((o1, o2) -> {
int number = o1.x + o1.y;
int numbers = o2.x + o2.y;
return numbers-number;
});
for (int i = 0; i < nums1.length; i++) {
for (int j = 0; j < nums2.length; j++) {
NumberPair peek = queue.peek();
NumberPair newNum = new NumberPair(nums1[i], nums2[j]);
int size = queue.size();
if(size < k) {
queue.offer(newNum);
continue;
}
if (peek != null && peek.sum() > newNum.sum() ) {
queue.poll();
queue.offer(newNum);
}
}
}
for (Iterator<NumberPair> it = queue.iterator(); it.hasNext(); ) {
List<Integer> list = new ArrayList<>();
NumberPair next = it.next();
list.add(next.x);
list.add(next.y);
result.add(list);
}
return result;
}
static class NumberPair {
private Integer x;
private Integer y;
public NumberPair(Integer x,Integer y){
this.x=x;
this.y=y;
}
public int sum(){
return x+y;
}
}
}
33 给你一个 严格升序排列 的正整数数组 arr 和一个整数 k 。
请你找到这个数组里第 k 个缺失的正整数。
示例 1：
输入：arr = [2,3,4,7,11], k = 5
输出：9
解释：缺失的正整数包括 [1,5,6,8,9,10,12,13,...] 。第 5 个缺失的正整数为 9 。
示例 2：
输入：arr = [1,2,3,4], k = 2
输出：6
解释：缺失的正整数包括 [5,6,7,...] 。第 2 个缺失的正整数为 6 。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/kth-missing-positive-number
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.ArrayList;
import java.util.List;
public class FindKthPositive {
public static void main(String[] args) {
//arr = [], k = 5
int[] arr={1,2,3,4};
int k=2;
final int kthPositive = findKthPositive(arr, k);
System.out.println(kthPositive);
}
public static int findKthPositive(int[] arr, int k) {
int count = 0;
List<Integer> kths = getList(arr);
for (int i = 1; i < Integer.MAX_VALUE; i++) {
if(!kths.contains(i)){
count++;
}
if (count == k) {
return i;
}
}
return 0;
}
public static List<Integer> getList(int[] arr) {
List<Integer> list=new ArrayList<>();
for(int i=0;i<arr.length;i++){
list.add(arr[i]);
}
return list;
}
}
34 给你一个由大小写英文字母组成的字符串 s 。
一个整理好的字符串中，两个相邻字符 s[i] 和 s[i+1]，其中 0<= i <= s.length-2 ，要满足如下条件:
若 s[i] 是小写字符，则 s[i+1] 不可以是相同的大写字符。
若 s[i] 是大写字符，则 s[i+1] 不可以是相同的小写字符。
请你将字符串整理好，每次你都可以从字符串中选出满足上述条件的 两个相邻 字符并删除，直到字符串整理好为止。
请返回整理好的 字符串 。题目保证在给出的约束条件下，测试样例对应的答案是唯一的。
注意：空字符串也属于整理好的字符串，尽管其中没有任何字符。
示例 1：
输入：s = "leEeetcode"
输出："leetcode"
解释：无论你第一次选的是 i = 1 还是 i = 2，都会使 "leEeetcode" 缩减为 "leetcode" 。
示例 2：
输入：s = "abBAcC"
输出：""
解释：存在多种不同情况，但所有的情况都会导致相同的结果。例如：
"abBAcC" --> "aAcC" --> "cC" --> ""
"abBAcC" --> "abBA" --> "aA" --> ""
示例 3：
输入：s = "s"
输出："s"
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/make-the-string-great
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import org.apache.commons.lang3.StringUtils;
import java.util.Locale;
public class MakeGood {
public static void main(String[] args) {
String s = "s";
System.out.println(makeGood(s));
}
public static String makeGood(String s) {
if(checkRemove(s)){
String newStr=remove(s);
return makeGood(newStr);
}
return s;
}
private static String remove(String s) {
StringBuilder stringBuilder=new StringBuilder();
for(int i=0;i<s.length();i++){
char number = s.charAt(i);
char anonumber = 0;
if(i+1<s.length()){
anonumber = s.charAt(i + 1);
}
if(anonumber<=0){
continue;
}
if (number - anonumber != 0
&& String.valueOf(number).toUpperCase(Locale.ROOT)
.equals(String.valueOf(anonumber).toUpperCase(Locale.ROOT))) {
String substr1 = s.substring(0, i );
String substr2 = s.substring(i + 2);
stringBuilder.append(substr1);
stringBuilder.append(substr2);
break;
}
}
return stringBuilder.toString();
}
private static boolean checkRemove(String s) {
for(int i=0;i<s.length();i++){
char number = s.charAt(i);
char anonumber = 0;
if(i+1<s.length()){
anonumber = s.charAt(i + 1);
}
if(anonumber<=0){
continue;
}
if(number - anonumber != 0
&& String.valueOf(number).toUpperCase(Locale.ROOT)
.equals(String.valueOf(anonumber).toUpperCase(Locale.ROOT))){
return true;
}
}
return false;
}
}
35 给你一个 n x n 矩阵 matrix ，其中每行和每列元素均按升序排序，找到矩阵中第 k 小的元素。
请注意，它是 排序后 的第 k 小元素，而不是第 k 个 不同 的元素。
你必须找到一个内存复杂度优于 O(n2) 的解决方案。
示例 1：
输入：matrix = [[1,5,9],[10,11,13],[12,13,15]], k = 8
输出：13
解释：矩阵中的元素为 [1,5,9,10,11,12,13,13,15]，第 8 小元素是 13
示例 2：
输入：matrix = [[-5]], k = 1
输出：-5
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/kth-smallest-element-in-a-sorted-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.Comparator;
import java.util.PriorityQueue;
import java.util.Queue;
public class KthSmallest {
public static void main(String[] args) {
int[][] matrix = {{1, 2}, {1,3}};
int k = 2;
System.out.println(kthSmallest(matrix, k));
}
public static int kthSmallest(int[][] matrix, int k) {
Queue<Integer> queue = new PriorityQueue<>(new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2-o1;
}
});
for (int i = 0; i < matrix.length; i++) {
for (int j = 0; j < matrix[i].length; j++) {
int number = matrix[i][j];
Integer peek = queue.peek();
if (queue.size() < k) {
queue.offer(number);
continue;
}
if (peek >= number & queue.size() >= k) {
queue.poll();
queue.offer(number);
continue;
}
}
}
return queue.poll();
}
}
36 猜数字游戏的规则如下：
每轮游戏，我都会从 1 到 n 随机选择一个数字。 请你猜选出的是哪个数字。
如果你猜错了，我会告诉你，你猜测的数字比我选出的数字是大了还是小了。
你可以通过调用一个预先定义好的接口 int guess(int num) 来获取猜测结果，返回值一共有 3 种可能的情况（-1，1 或 0）：
-1：我选出的数字比你猜的数字小 pick < num
1：我选出的数字比你猜的数字大 pick > num
0：我选出的数字和你猜的数字一样。恭喜！你猜对了！pick == num
返回我选出的数字。
示例 1：
输入：n = 10, pick = 6
输出：6
示例 2：
输入：n = 1, pick = 1
输出：1
示例 3：
输入：n = 2, pick = 1
输出：1
示例 4：
输入：n = 2, pick = 2
输出：2
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/guess-number-higher-or-lower (未完成)
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
public class GuessNumber {
public static void main(String[] args) {
System.out.println(guessNumber(2126753390));
}
public static int guessNumber(int n) {
int left = 1, right = n;
while (left < right) { // 循环直至区间左右端点相同
int mid = left + (right - left) / 2; // 防止计算时溢出
if (guess(mid) <= 0) {
right = mid; // 答案在区间 [left, mid] 中
} else {
left = mid + 1; // 答案在区间 [mid+1, right] 中
}
}
// 此时有 left == right，区间缩为一个点，即为答案
return left;
}
public static int guess(int number) {
if (number == 1702766719) {
return 0;
}
if (number > 1702766719) {
return 1;
}
return -1;
}
}
37 给你一个字符串数组 words ，找出并返回数组中的 第一个回文字符串 。如果不存在满足要求的字符串，返回一个 空字符串 "" 。
回文字符串 的定义为：如果一个字符串正着读和反着读一样，那么该字符串就是一个 回文字符串 。
示例 1：
输入：words = ["abc","car","ada","racecar","cool"]
输出："ada"
解释：第一个回文字符串是 "ada" 。
注意，"racecar" 也是回文字符串，但它不是第一个。
示例 2：
输入：words = ["notapalindrome","racecar"]
输出："racecar"
解释：第一个也是唯一一个回文字符串是 "racecar" 。
示例 3：
输入：words = ["def","ghi"]
输出：""
解释：不存在回文字符串，所以返回一个空字符串。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-first-palindromic-string-in-the-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
public class FirstPalindrome {
public static void main(String[] args) {
String[] words = {"cqllrtyhw","swwisru","gpzmbders","wqibjuqvs","pp","usewxryy","ybqfuh","hqwwqftgyu","jggmatpk"};
System.out.println(firstPalindrome(words));
}
public static String firstPalindrome(String[] words) {
for (int i = 0; i < words.length; i++) {
String word = words[i];
if (isPalindrome(word)) {
return word;
}
}
return "";
}
private static boolean isPalindrome(String word) {
boolean flag = true;
for (int i = 0, j = word.length()-1; i<=j; i++, j--) {
if (word.charAt(i) != word.charAt(j)) {
flag = false;
break;
}
}
return flag;
}
}
38 给你一个字符串 s ，如果 s 是一个 好 字符串，请你返回 true ，否则请返回 false 。
如果 s 中出现过的 所有 字符的出现次数 相同 ，那么我们称字符串 s 是 好 字符串。
示例 1：
输入：s = "abacbc"
输出：true
解释：s 中出现过的字符为 'a'，'b' 和 'c' 。s 中所有字符均出现 2 次。
示例 2：
输入：s = "aaabb"
输出：false
解释：s 中出现过的字符为 'a' 和 'b' 。
'a' 出现了 3 次，'b' 出现了 2 次，两者出现次数不同。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/check-if-all-characters-have-equal-number-of-occurrences
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.*;
public class AreOccurrencesEqual {
public static void main(String[] args) {
String str = "aaabb";
System.out.println(areOccurrencesEqual(str));
}
public static boolean areOccurrencesEqual(String s) {
Map<Character, Integer> countMap = new HashMap<Character, Integer>();
for (int i = 0; i < s.length(); i++) {
char c = s.charAt(i);
Integer count = countMap.get(c);
if (count == null) {
countMap.put(c, 1);
} else {
count++;
countMap.put(c, count);
}
}
Collection<Integer> values = countMap.values();
Set<Integer> countSet = new HashSet<>();
countSet.addAll(values);
if (countSet.size() >= 2) {
return false;
}
return true;
}
}
39 设计一个支持 push ，pop ，top 操作，并能在常数时间内检索到最小元素的栈。
实现 MinStack 类:
MinStack() 初始化堆栈对象。
void push(int val) 将元素val推入堆栈。
void pop() 删除堆栈顶部的元素。
int top() 获取堆栈顶部的元素。
int getMin() 获取堆栈中的最小元素。
示例 1:
输入：
["MinStack","push","push","push","getMin","pop","top","getMin"]
[[],[-2],[0],[-3],[],[],[],[]]
输出：
[null,null,null,null,-3,null,0,-2]
解释：
MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.getMin(); --> 返回 -3.
minStack.pop();
minStack.top(); --> 返回 0.
minStack.getMin(); --> 返回 -2.
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/min-stack
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.*;
public class MinStack {
Deque<Integer> deque=new LinkedList<>();
int min=Integer.MAX_VALUE;
public MinStack() {
}
public void push(int val) {
deque.push(val);
if (min > val) {
min = val;
}
}
public void pop() {
final Integer poll = deque.pop();
if (min >= poll) {
min=Integer.MAX_VALUE;
for (Iterator<Integer> it = deque.iterator(); it.hasNext(); ) {
Integer next = it.next();
if (min > next) {
min = next;
}
}
}
}
public int top() {
return deque.peek();
}
public int getMin() {
return min;
}
}
40 值元素是指其值严格大于左右相邻值的元素。
给你一个整数数组 nums，找到峰值元素并返回其索引。数组可能包含多个峰值，在这种情况下，返回 任何一个峰值 所在位置即可。
你可以假设 nums[-1] = nums[n] = -∞ 。
你必须实现时间复杂度为 O(log n) 的算法来解决此问题。
示例 1：
输入：nums = [1,2,3,1]
输出：2
解释：3 是峰值元素，你的函数应该返回其索引 2。
示例 2：
输入：nums = [1,2,1,3,5,6,4]
输出：1 或 5
解释：你的函数可以返回索引 1，其峰值元素为 2；
或者返回索引 5， 其峰值元素为 6。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-peak-element
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.*;
public class FindPeakElement {
public static void main(String[] args) {
int[] nums = {1, 2, 3, 1};
System.out.println(findPeakElement(nums));
}
public static int findPeakElement(int[] nums) {
List<Integer> lis = new ArrayList<>();
Queue<Integer> deque = new PriorityQueue<>((o1, o2) -> o2 - o1);
for (int i = 0; i < nums.length; i++) {
deque.offer(nums[i]);
lis.add(nums[i]);
}
Integer peek = deque.peek();
return lis.indexOf(peek);
}
}
41 给你一个整数数组 nums ，请你将数组按照每个值的频率 升序 排序。如果有多个值的频率相同，请你按照数值本身将它们 降序 排序。
请你返回排序后的数组。
示例 1：
输入：nums = [1,1,2,2,2,3]
输出：[3,1,1,2,2,2]
解释：'3' 频率为 1，'1' 频率为 2，'2' 频率为 3 。
示例 2：
输入：nums = [2,3,1,3,2]
输出：[1,3,3,2,2]
解释：'2' 和 '3' 频率都为 2 ，所以它们之间按照数值本身降序排序。
示例 3：
输入：nums = [-1,1,-6,4,5,-6,1,4,1]
输出：[5,-1,4,4,-6,-6,1,1,1]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/sort-array-by-increasing-frequency
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
import java.util.*;
import java.util.stream.Collectors;
public class FrequencySort {
public static void main(String[] args) {
int[] nums = {2,3,1,3,2};
int[] ints = frequencySort(nums);
for(int i=0;i<ints.length;i++){
System.out.println(ints[i]);
}
}
public static int[] frequencySort(int[] nums) {
Map<Integer, Integer> numberMap = new HashMap<Integer, Integer>();
for (int i = 0; i < nums.length; i++) {
int num = nums[i];
Integer count = numberMap.get(num);
if (count == null) {
numberMap.put(num, 1);
} else {
count++;
numberMap.put(num, count);
}
}
List<Map.Entry<Integer, Integer>> entries = numberMap
.entrySet()
.stream()
.sorted((o1, o2) -> {
int number = o1.getValue() - o2.getValue();
if (number != 0) {
return number;
}
return o2.getKey() - o1.getKey();
})
.collect(Collectors.toList());
int[] resu = new int[nums.length];
int count = 0;
for (Iterator<Map.Entry<Integer, Integer>> it = entries.iterator();
it.hasNext(); ) {
Map.Entry<Integer, Integer> next = it.next();
Integer value = next.getValue();
for (int i = 0; i < value; i++) {
resu[count] = next.getKey();
count++;
}
}
return resu;
}
}
42 有 n 个城市，其中一些彼此相连，另一些没有相连。如果城市 a 与城市 b 直接相连，且城市 b 与城市 c 直接相连，那么城市 a 与城市 c 间接相连。
省份 是一组直接或间接相连的城市，组内不含其他没有相连的城市。
给你一个 n x n 的矩阵 isConnected ，其中 isConnected[i][j] = 1 表示第 i 个城市和第 j 个城市直接相连，而 isConnected[i][j] = 0 表示二者不直接相连。
返回矩阵中 省份 的数量。
示例 1：
输入：isConnected = [[1,1,0],[1,1,0],[0,0,1]]
输出：2
示例 2：
输入：isConnected = [[1,0,0],[0,1,0],[0,0,1]]
输出：3
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/number-of-provinces (题目有点问题)
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.*;
public class FindCircleNum {
public static void main(String[] args) {
int[][] isConnected = new int[][]{{1,0,0}, {0,1,0}, {0,0,1}};
System.out.println(findCircleNum(isConnected));
}
public static int findCircleNum(int[][] isConnected) {
Set<Point> points = new TreeSet<>(Comparator
.comparingInt((Point o) -> o.x)
.thenComparingInt(o -> o.y));
List<Deque<Point>> result = new ArrayList<>();
// 1 遍历每一个点
for (int i = 0; i < isConnected.length; i++) {
for (int j = 0; j < isConnected[i].length; j++) {
int number = isConnected[i][j];
Point point = new Point(i, j, 1);
if (number == 1 && !points.contains(point)) {
Deque<Point> stack = new ArrayDeque();
stack.push(point);
while (!stack.isEmpty()) {
Point pop = stack.pop();
points.add(pop);
int x = pop.x;
int y = pop.y;
if (y + 1 < isConnected[0].length) {
int upVal = isConnected[x][y + 1];
Point upPoint = new Point(x, y + 1, 1);
if (upVal == 1 && !points.contains(upPoint)) {
stack.push(upPoint);
}
}
if (y - 1 >= 0) {
int downVal = isConnected[x][y - 1];
Point downPoint = new Point(x, y - 1, 1);
if (downVal == 1 && !points.contains(downPoint)) {
stack.push(downPoint);
}
}
if (x - 1 >= 0) {
int left = isConnected[x - 1][y];
Point leftPoint = new Point(x - 1, y, 1);
if (left == 1 && !points.contains(leftPoint)) {
stack.push(leftPoint);
}
}
if (x + 1 < isConnected.length) {
int right = isConnected[x + 1][y];
Point rightPoint = new Point(x + 1, y, 1);
if (right == 1 && !points.contains(rightPoint)) {
stack.push(rightPoint);
}
}
}
result.add(stack);
}
}
}
return result.size();
}
static class Point {
private int x;
private int y;
private int val;
public Point() {
}
public Point(int x, int y, int val) {
this.x = x;
this.y = y;
this.val = val;
}
}
}
43 给你一个长度为 n 的 整数 数组 pref 。找出并返回满足下述条件且长度为 n 的数组 arr ：
pref[i] = arr[0] ^ arr[1] ^ ... ^ arr[i].
注意 ^ 表示 按位异或（bitwise-xor）运算。
可以证明答案是 唯一 的。
示例 1：
输入：pref = [5,2,0,3,1]
输出：[5,7,2,3,2]
解释：从数组 [5,7,2,3,2] 可以得到如下结果：
- pref[0] = 5
- pref[1] = 5 ^ 7 = 2
- pref[2] = 5 ^ 7 ^ 2 = 0
- pref[3] = 5 ^ 7 ^ 2 ^ 3 = 3
- pref[4] = 5 ^ 7 ^ 2 ^ 3 ^ 2 = 1
示例 2：
输入：pref = [13]
输出：[13]
解释：pref[0] = arr[0] = 13
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-the-original-array-of-prefix-xor
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
public class FindArray {
public static void main(String[] args) {
int[] pre={13};
int[] array = findArray(pre);
for(int i=0;i<array.length;i++){
System.out.print(array[i]);
}
}
public static int[] findArray(int[] pref) {
int[] numbers=new int[pref.length];
numbers[0]=pref[0];
for(int i=1;i<numbers.length;i++){
numbers[i]=pref[i]^pref[i-1];
}
return numbers;
}
}
44 给你一个字符串 s 和一个机器人，机器人当前有一个空字符串 t 。执行以下操作之一，直到 s 和 t 都变成空字符串：
删除字符串 s 的 第一个 字符，并将该字符给机器人。机器人把这个字符添加到 t 的尾部。
删除字符串 t 的 最后一个 字符，并将该字符给机器人。机器人将该字符写到纸上。
请你返回纸上能写出的字典序最小的字符串。
示例 1：
输入：s = "zza"
输出："azz"
解释：用 p 表示写出来的字符串。
一开始，p="" ，s="zza" ，t="" 。
执行第一个操作三次，得到 p="" ，s="" ，t="zza" 。
执行第二个操作三次，得到 p="azz" ，s="" ，t="" 。
示例 2：
输入：s = "bac"
输出："abc"
解释：用 p 表示写出来的字符串。
执行第一个操作两次，得到 p="" ，s="c" ，t="ba" 。
执行第二个操作两次，得到 p="ab" ，s="c" ，t="" 。
执行第一个操作，得到 p="ab" ，s="" ，t="c" 。
执行第二个操作，得到 p="abc" ，s="" ，t="" 。
示例 3：
输入：s = "bdda"
输出："addb"
解释：用 p 表示写出来的字符串。
一开始，p="" ，s="bdda" ，t="" 。
执行第一个操作四次，得到 p="" ，s="" ，t="bdda" 。
执行第二个操作四次，得到 p="addb" ，s="" ，t="" 。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/using-a-robot-to-print-the-lexicographically-smallest-string(未完成)
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import org.apache.commons.lang3.StringUtils;
import java.util.Arrays;
import java.util.Deque;
import java.util.LinkedList;
public class RobotWithString {
public static void main(String[] args) {
String str = "bydizfve";
System.out.print(robotWithString(str));
}
public static String robotWithString(String str) {
Deque<Character> tDeque = new LinkedList<>();
Deque<Character> sDeque = new LinkedList<>();
StringBuilder result = new StringBuilder();
do {
int minCharIndex = getMinChar(str);
for (int i = 0; i < str.length(); i++) {
if (i <= minCharIndex) {
tDeque.push(str.charAt(i));
} else {
sDeque.addFirst(str.charAt(i));
}
}
int i = 0;
int j = 0;
int tlen = tDeque.size();
int slen = sDeque.size();
while (i < tlen && j < slen) {
Character peek = tDeque.peek();
Character first = sDeque.peekFirst();
if (!tDeque.isEmpty() && first == null) {
Character pop = tDeque.pop();
result.append(pop);
i++;
continue;
}
if (!tDeque.isEmpty() && peek < first) {
Character pop = tDeque.pop();
result.append(pop);
i++;
continue;
}
if (!tDeque.isEmpty()) {
Character character = tDeque.removeFirst();
result.append(character);
j++;
}
}
while (i < tlen) {
Character pop = tDeque.pop();
result.append(pop);
i++;
}
if(tDeque.isEmpty() && !sDeque.isEmpty()){
Character[] characters=new Character[sDeque.size()];
sDeque.toArray(characters);
str = getStr(characters);
tDeque.clear();
sDeque.clear();
}
} while (!StringUtils.isBlank(str));
return result.toString();
}
private static String getStr(Character[] characters) {
StringBuilder str=new StringBuilder();
for(int i=0;i< characters.length;i++){
str.append(characters[i]);
}
return str.toString();
}
/**
* 返回索引值
*
* @param str
* @return
*/
public static int getMinChar(String str) {
int min = Integer.MAX_VALUE;
int index = 0;
for (int i = 0; i < str.length(); i++) {
int ins = str.charAt(i);
if (ins < min) {
min = ins;
index = i;
}
}
return index;
}
}
45 给你两个正整数 n 和 k，二进制字符串 Sn 的形成规则如下：
S1 = "0"
当 i > 1 时，Si = Si-1 + "1" + reverse(invert(Si-1))
其中 + 表示串联操作，reverse(x) 返回反转 x 后得到的字符串，而 invert(x) 则会翻转 x 中的每一位（0 变为 1，而 1 变为 0）。
例如，符合上述描述的序列的前 4 个字符串依次是：
S1 = "0"
S2 = "011"
S3 = "0111001"
S4 = "011100110110001"
请你返回 Sn 的 第 k 位字符 ，题目数据保证 k 一定在 Sn 长度范围以内。
示例 1：
输入：n = 3, k = 1
输出："0"
解释：S3 为 "0111001"，其第 1 位为 "0" 。
示例 2：
输入：n = 4, k = 11
输出："1"
解释：S4 为 "011100110110001"，其第 11 位为 "1" 。
示例 3：
输入：n = 1, k = 1
输出："0"
示例 4：
输入：n = 2, k = 3
输出："1"
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-kth-bit-in-nth-binary-string
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
public class FindKthBit {
public static void main(String[] args) {
int n=3;
int k=1;
System.out.println(findKthBit(n,k));
}
public static char findKthBit(int n, int k) {
String[] sn=new String[n];
sn[0]="0";
for(int i=1;i<n;i++){
sn[i]=sn[i-1]+"1"+reverse(invert(sn[i-1]));
}
return sn[n-1].charAt(k-1);
}
/**
* 二进制0变1 1变0
* @param str
* @return
*/
public static String invert(String str){
StringBuilder stringBuilder=new StringBuilder();
for(int i=0;i<str.length();i++){
char c = str.charAt(i);
if(c=='0'){
stringBuilder.append("1");
continue;
}
stringBuilder.append("0");
}
return stringBuilder.toString();
}
/**
* 二进制字符串反转函数
* @param str
* @return
*/
public static String reverse(String str){
StringBuilder stringBuilder=new StringBuilder();
stringBuilder.append(str);
return stringBuilder.reverse().toString();
}
}
46 给定一个整数数组 temperatures ，表示每天的温度，返回一个数组 answer ，其中 answer[i] 是指对于第 i 天，下一个更高温度出现在几天后。如果气温在这之后都不会升高，请在该位置用 0 来代替。
示例 1:
输入: temperatures = [73,74,75,71,69,72,76,73]
输出: [1,1,4,2,1,1,0,0]
示例 2:
输入: temperatures = [30,40,50,60]
输出: [1,1,1,0]
示例 3:
输入: temperatures = [30,60,90]
输出: [1,1,0]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/daily-temperatures
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.ArrayDeque;
import java.util.Deque;
public class DailyTemperatures {
public static void main(String[] args) {
int[] temperatures = {73, 74, 75, 71, 69, 72, 76, 73};
int[] dailyTemperatures = dailyTemperatures(temperatures);
for (int i = 0; i < dailyTemperatures.length; i++) {
System.out.print(dailyTemperatures[i]);
}
}
public static int[] dailyTemperatures(int[] temperatures) {
int[] daily = new int[temperatures.length];
Deque<Point> stack = new ArrayDeque<>();
for (int i = 0; i < temperatures.length; i++) {
int tem = temperatures[i];
if (i == 0) {
stack.push(new Point(i, tem));
continue;
}
Point peek = stack.peekFirst();
if (peek==null || peek.val > tem) {
stack.push(new Point(i, tem));
continue;
}
while (peek!=null && peek.val < tem) {
Point pop = stack.pop();
int index = pop.index;
daily[index]=i-index;
peek=stack.peek();
}
stack.push(new Point(i,tem));
}
return daily;
}
static class Point {
private int index;
private int val;
public Point() {
}
public Point(int index, int val) {
this.index = index;
this.val = val;
}
}
}
47 给你一个字符串数组 words ，找出并返回 length(words[i]) * length(words[j]) 的最大值，并且这两个单词不含有公共字母。如果不存在这样的两个单词，返回 0 。
示例 1：
输入：words = ["abcw","baz","foo","bar","xtfn","abcdef"]
输出：16
解释：这两个单词为 "abcw", "xtfn"。
示例 2：
输入：words = ["a","ab","abc","d","cd","bcd","abcd"]
输出：4
解释：这两个单词为 "ab", "cd"。
示例 3：
输入：words = ["a","aa","aaa","aaaa"]
输出：0
解释：不存在这样的两个单词。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/maximum-product-of-word-lengths (超时)
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import java.util.HashSet;
public class MaxProduct {
public static void main(String[] args) {
String[] words = {"abcw", "baz", "foo", "bar", "xtfn", "abcdef"};
System.out.print(maxProduct(words));
}
public static int maxProduct(String[] words) {
int result = 0;
for (int i = 0; i < words.length; i++) {
for (int j = i; j < words.length; j++) {
String wordi = words[i];
String wordj = words[j];
HashSet<Character> h1 = new HashSet<Character>();
HashSet<Character> h2 = new HashSet<Character>();
for (int k = 0; k < wordi.length(); k++) {
h1.add(wordi.charAt(k));
}
for (int m = 0; m < wordj.length(); m++) {
h2.add(wordj.charAt(m));
}
h1.retainAll(h2);
if (h1.size() > 0) {
continue;
}
int number = wordi.length() * wordj.length();
if (number > result) {
result = number;
}
}
}
return result;
}
}
48 给你两个二维整数数组 items1 和 items2 ，表示两个物品集合。每个数组 items 有以下特质：
items[i] = [valuei, weighti] 其中 valuei 表示第 i 件物品的 价值 ，weighti 表示第 i 件物品的 重量 。
items 中每件物品的价值都是 唯一的 。
请你返回一个二维数组 ret，其中 ret[i] = [valuei, weighti]， weighti 是所有价值为 valuei 物品的 重量之和 。
注意：ret 应该按价值 升序 排序后返回。
示例 1：
输入：items1 = [[1,1],[4,5],[3,8]], items2 = [[3,1],[1,5]]
输出：[[1,6],[3,9],[4,5]]
解释：
value = 1 的物品在 items1 中 weight = 1 ，在 items2 中 weight = 5 ，总重量为 1 + 5 = 6 。
value = 3 的物品再 items1 中 weight = 8 ，在 items2 中 weight = 1 ，总重量为 8 + 1 = 9 。
value = 4 的物品在 items1 中 weight = 5 ，总重量为 5 。
所以，我们返回 [[1,6],[3,9],[4,5]] 。
示例 2：
输入：items1 = [[1,1],[3,2],[2,3]], items2 = [[2,1],[3,2],[1,3]]
输出：[[1,4],[2,4],[3,4]]
解释：
value = 1 的物品在 items1 中 weight = 1 ，在 items2 中 weight = 3 ，总重量为 1 + 3 = 4 。
value = 2 的物品在 items1 中 weight = 3 ，在 items2 中 weight = 1 ，总重量为 3 + 1 = 4 。
value = 3 的物品在 items1 中 weight = 2 ，在 items2 中 weight = 2 ，总重量为 2 + 2 = 4 。
所以，我们返回 [[1,4],[2,4],[3,4]] 。
示例 3：
输入：items1 = [[1,3],[2,2]], items2 = [[7,1],[2,2],[1,4]]
输出：[[1,7],[2,4],[7,1]]
解释：
value = 1 的物品在 items1 中 weight = 3 ，在 items2 中 weight = 4 ，总重量为 3 + 4 = 7 。
value = 2 的物品在 items1 中 weight = 2 ，在 items2 中 weight = 2 ，总重量为 2 + 2 = 4 。
value = 7 的物品在 items2 中 weight = 1 ，总重量为 1 。
所以，我们返回 [[1,7],[2,4],[7,1]] 。
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/merge-similar-items
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao;
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
public class MergeSimilarItems {
public static void main(String[] args) {
int[][] item1={{1,1},{4,5},{3,8}};
int[][] item2={{3,1},{1,5}};
List<List<Integer>> lists = mergeSimilarItems(item1, item2);
System.out.print(JSONObject.toJSONString(lists));
}
public static List<List<Integer>> mergeSimilarItems(int[][] items1, int[][] items2) {
List<Entry> entries=new ArrayList<>();
for(int i=0;i<items1.length;i++){
entries.add(new Entry(items1[i][0],items1[i][1]));
}
for(int i=0;i<items2.length;i++){
entries.add(new Entry(items2[i][0],items2[i][1]));
}
List<List<Integer>> mergeSimilarItems = entries.stream()
.collect(Collectors.groupingBy(Entry::getKey))
.entrySet()
.stream()
.map(item -> {
List<Integer> list = new ArrayList<>();
Integer key = item.getKey();
List<Entry> value = item.getValue();
int sum = value
.stream()
.mapToInt(Entry::getVal)
.sum();
list.add(key);
list.add(sum);
return list;
})
.collect(Collectors.toList());
mergeSimilarItems.sort(Comparator.comparingInt(o -> o.get(0)));
return mergeSimilarItems;
}
static class Entry{
private int key;
private int val;
public int getKey() {
return key;
}
public void setKey(int key) {
this.key = key;
}
public int getVal() {
return val;
}
public void setVal(int val) {
this.val = val;
}
public Entry(){
}
public Entry(int key,int val){
this.key=key;
this.val=val;
}
}
}
49 给你链表的头节点 head 和一个整数 k 。
交换 链表正数第 k 个节点和倒数第 k 个节点的值后，返回链表的头节点（链表 从 1 开始索引）。
示例 1：
输入：head = [1,2,3,4,5], k = 2
输出：[1,4,3,2,5]
示例 2：
输入：head = [7,9,6,6,7,8,3,0,9,5], k = 5
输出：[7,9,6,6,8,7,3,0,9,5]
示例 3：
输入：head = [1], k = 1
输出：[1]
示例 4：
输入：head = [1,2], k = 1
输出：[2,1]
示例 5：
输入：head = [1,2,3], k = 2
输出：[1,2,3]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/swapping-nodes-in-a-linked-list
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import com.alibaba.fastjson.JSONObject;
import java.util.ArrayList;
import java.util.List;
public class SwapNodes {
public static void main(String[] args) {
List<Integer> list=new ArrayList<>();
list.add(1);//1,2,3,4,5
list.add(2);
list.add(3);
list.add(4);
list.add(5);
ListNode listNode = listFromArray(list);
ListNode result = swapNodes(listNode, 2);
System.out.println(JSONObject.toJSONString(result));
}
public static ListNode swapNodes(ListNode head, int k) {
List<Integer> newList=new ArrayList<Integer>();
while(head!=null){
int val = head.val;
newList.add(val);
head=head.next;
}
int kFirstIndex=k-1;
int kLastIndex=newList.size()-k;
int numHead=newList.get(kFirstIndex);
int numTail=newList.get(kLastIndex);
newList.set(kLastIndex,numHead);
newList.set(kFirstIndex,numTail);
return listFromArray(newList);
}
public static ListNode listFromArray(List<Integer> newList) {
Integer hv = newList.get(0);
ListNode head=new ListNode();
head.val=hv;
ListNode tail=head;
for(int i=1;i<newList.size();i++){
ListNode newNode=new ListNode();
newNode.val=newList.get(i);
tail.next=newNode;
tail=tail.next;
}
return head;
};
public static class ListNode {
int val;
ListNode next;
ListNode() {
}
ListNode(int val) {
this.val = val;
}
ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
}
50 给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。
示例1：
输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]
示例2：
输入: root = [1,2,3]
输出: [1,3]
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/find-largest-value-in-each-tree-row
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
package worn.xiao.leedcode;
import worn.xiao.leedcode.record2.base.TreeNode;
import worn.xiao.leedcode.record2.base.TreeUtils;
import java.util.*;
public class LargestValues {
public static void main(String[] args) {
//[3,1,5,0,2,4,6,null,null,null,3]
Integer[] arges = {3,1,5,0,2,4,6,null,null,null,3};
TreeUtils treeUtils = TreeUtils.getInstance();
TreeNode treeNode = treeUtils.initTree(arges);
System.out.println(largestValues(treeNode));
}
public static List<Integer> largestValues(TreeNode root) {
if(root==null){
return new ArrayList<>();
}
List<Integer> alist = new ArrayList<>();
Queue<TreeNode> treeNodeQueue = new ArrayDeque<>();
Queue<TreeNode> sortNodeQueue = new ArrayDeque<>();
sortNodeQueue.add(root);
while (!sortNodeQueue.isEmpty()) {
if (treeNodeQueue.isEmpty()) {
int min=Integer.MIN_VALUE;
for(Iterator<TreeNode> it = sortNodeQueue.iterator();it.hasNext();){
TreeNode next = it.next();
int val = next.getVal();
if(val>min){
min=val;
}
}
alist.add(min);
while (!sortNodeQueue.isEmpty()) {
treeNodeQueue.add(sortNodeQueue.poll());
}
}
while(!treeNodeQueue.isEmpty()){
TreeNode poll = treeNodeQueue.poll();
TreeNode right = poll.getRight();
if (right != null) {
sortNodeQueue.add(right);
}
TreeNode left = poll.getLeft();
if (left != null) {
sortNodeQueue.add(left);
}
}
}
return alist;
}
}
1674
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
