Autor: Rukawa Maple Knock Code
Blog-Homepage: Rukawa Kaedes Blog
Kolumne: Lerne Java mit mir
Zitat: Bleib hungrig, bleib dumm
Wenn Sie Gutes tun wollen, müssen Sie zuerst Ihre Werkzeuge schärfen Lassen Sie mich Ihnen ein superstarkes Werkzeug vorstellen, um Angebote von großen Herstellern zu gewinnen - Niuke.com
Klicken Sie hier, um sich kostenlos zu registrieren und die Fragen mit mir zu beantworten
Artikelverzeichnis
Inorder Traversal des Binärbaums
Zwei Zahlen, die nur einmal in einem Array vorkommen
Versionsnummern vergleichen
beschreiben
Wenn das Niuke-Projekt die Projektversion veröffentlicht, wird es eine Versionsnummer geben, z. B. 1.02.11, 2.14.4 usw.
Geben Sie nun 2 Versionsnummern Version1 und Version2 an, vergleichen Sie bitte ihre Größen
Die Versionsnummer setzt sich aus Revisionsnummern zusammen, die durch ein „.“ zwischen Revisionsnummer und Revisionsnummer verbunden sind. Eine Revisionsnummer kann aus mehreren Ziffern bestehen, und Revisionsnummern können führende Nullen enthalten und sind zulässig. Beispielsweise sind 1.02.11, 0.1, 0.2 alle gültige Versionsnummern
Jede Versionsnummer enthält mindestens 1 Revisionsnummer.
Revisionsnummern werden von links nach rechts nummeriert, Indizes beginnen bei 0, die Revisionsnummer ganz links wird mit 0 tiefgestellt, die nächste Revisionsnummer wird mit 1 tiefgestellt und so weiter.
Vergleichsregeln:
1. Wenn Sie Versionsnummern vergleichen, vergleichen Sie ihre Revisionsnummern in der Reihenfolge von links nach rechts. Vergleichen Sie beim Vergleich von Revisionsnummern einfach die ganzzahligen Werte und ignorieren Sie führende Nullen. Beispielsweise sind die Versionsnummern von „0.1“ und „0.01“ identisch
2. Wenn die Versionsnummer bei einem Index keine Revisionsnummer angibt, wird die Revisionsnummer als 0 betrachtet. Beispielsweise hat „1.1“ eine Versionsnummer kleiner als „1.1.1“. Da die Versionsnummer „1.1“ „1.1.0“ entspricht, ist der Index der 3. Revisionsnummer 0, also kleiner als 1
3. version1 > version2 gibt 1 zurück, wenn version1 < version2 -1 zurückgibt, sonst 0.
Datenreichweite:
1 <= Version1.Länge, Version2.Länge <= 10001<=Version1.Länge,Version2.Länge<=1000
Die Revisionsnummern von Version1 und Version2 werden den Ausdrucksbereich von int nicht überschreiten, d. h. den Bereich von 32-Bit-Ganzzahlen
Erweitert: Zeitkomplexität O(n)O(n)
Wissenspunkte: Strings, Doppelzeiger
Antworten:
import java.util.*;
public class Solution {
public int compare (String version1, String version2) {
// write code here
String[] numsOfV1 = version1.split("\\."); // 记得这里分割的时候需要加两个斜杠
String[] numsOfV2 = version2.split("\\.");
int index = 0;
while (index < numsOfV1.length && index < numsOfV2.length) {
int num1 = Integer.parseInt(numsOfV1[index]);
int num2 = Integer.parseInt(numsOfV2[index]);
if (num1 > num2) {
return 1;
} else if (num1 < num2) {
return -1;
}
index ++;
}
while (index < numsOfV1.length) {
int num1 = Integer.parseInt(numsOfV1[index]);
if (num1 > 0) {
return 1;
}
index ++;
}
while (index < numsOfV2.length) {
int num2 = Integer.parseInt(numsOfV2[index]);
if (num2 > 0) {
return -1;
}
index ++;
}
return 0;
}
}Inorder Traversal des Binärbaums
beschreiben
Wenn der Wurzelknoten root eines Binärbaums gegeben ist, wird das Ergebnis der Inorder-Durchquerung zurückgegeben.
Datenbereich: Die Anzahl der Knoten im Baum erfüllt 0 \le n \le 10000≤n≤1000, und der Wert jedes Knotens im Baum erfüllt 0 \le val \le 10000≤val≤1000
Erweitert: Raumkomplexität O( n)O (n), Zeitkomplexität O(n)O(n)
Wissenspunkte: Bäume, Rekursion, Breitensuche (BFS)
Antworten:
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整型一维数组
*/
public int[] inorderTraversal (TreeNode root) {
// write code here
if(root == null)return new int[0];
ArrayList<Integer> ans = new ArrayList<>();
inOrder(root, ans);
int[] res = new int[ans.size()];
int i=0;
for(int n: ans){
res[i++] = n;
}
return res;
}
public void inOrder(TreeNode node, ArrayList<Integer> ans){
if(node == null)return;
inOrder(node.left, ans);
ans.add(node.val);
inOrder(node.right, ans);
}
}Zwei Zahlen, die nur einmal in einem Array vorkommen
beschreiben
In einem Integer-Array erscheinen außer zwei Zahlen, die nur einmal vorkommen, alle anderen Zahlen zweimal. Bitte schreiben Sie ein Programm, um diese beiden Zahlen zu finden, die nur einmal vorkommen.
Datenbereich: Arraylänge 2\le n \le 10002≤n≤1000, Größe jeder Zahl im Array 0 < val \le 10000000<val≤1000000
Anforderungen: Raumkomplexität O(1)O(1), zeitlicher Komplexitätsgrad O(n)O(n)Hinweis: Die Ausgabe erfolgt in nicht absteigender Reihenfolge.
Wissenspunkte: Bitoperationen, Hashing
Antworten:
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param array int整型一维数组
* @return int整型一维数组
*/
public int[] FindNumsAppearOnce (int[] array) {
// write code here
int tmp = 0, n = array.length;
for(int i=0; i<n; i++){
tmp ^= array[i];
}
int div = 1;
while(tmp != 0){
if((tmp & 1) == 1) div <<= 1;
tmp >>= 1;
}
int a = 0, b = 0;
for(int i=0; i<n; i++){
if((array[i] & div) != 0) a ^= array[i];
else b ^= array[i];
}
return new int[]{b, a};
}
}Zusammenführungsintervall
beschreiben
Führen Sie bei einem gegebenen Satz von Intervallen alle überlappenden Intervalle zusammen.
Bitte achten Sie darauf, dass die zusammengeführten Intervalle in aufsteigender Reihenfolge vom Startpunkt des Intervalls angeordnet sind.
Datenbereich: Intervallgruppennummer 0 \le n \le 2 \times 10^50≤n≤2×105, die Werte im Intervall erfüllen 0 \le val \le 2 \times 10^50≤val≤2× 105
Anforderungen: Raumkomplexität O(n)O(n), Zeitkomplexität O(nlogn)O(nlogn)
Fortgeschritten: Raumkomplexität O(val)O(val), Zeitkomplexität O(val)O(val)
Wissenspunkte: Sortieren, Arrays
Antworten:
import java.util.*;
/**
* Definition for an interval.
* public class Interval {
* int start;
* int end;
* Interval() { start = 0; end = 0; }
* Interval(int s, int e) { start = s; end = e; }
* }
*/
public class Solution {
public ArrayList<Interval> merge(ArrayList<Interval> intervals) {
if (intervals.size() == 0) {
return new ArrayList<>();
}
Collections.sort(intervals, new Comparator<Interval>() {
public int compare(Interval o1, Interval o2) {
if (o1.start != o2.start) {
return o1.start - o2.start;
} else {
return o1.end - o2.end;
}
}
});
ArrayList<Interval> result = new ArrayList<>();
result.add(intervals.get(0));
int count = 0;
for (int i = 1; i < intervals.size(); i++) {
Interval o1 = intervals.get(i);
Interval origin = result.get(count);
if (o1.start > origin.end) {
result.add(o1);
count++;
} else {
result.remove(count);
Interval s = new Interval(origin.start, o1.end);
if (o1.end < origin.end) {
s.end = origin.end;
}
result.add(s);
}
}
return result;
}
}„Das Teilen dieser Ausgabe ist hier, denken Sie daran, dem Blogger einen Drei-Link zu geben, Ihre Unterstützung ist die größte treibende Kraft für meine Kreation!