1. Suche in einem binären Suchbaum
Suchen in einem binären Suchbaum.
Gegeben sei ein Wurzelknoten des binären Suchbaums (BST) und ein ganzzahliger Wert val.
Sie müssen im BST einen Knoten finden, dessen Knotenwert gleich val ist. Gibt den Teilbaum zurück, der an diesem Knoten verwurzelt ist. Gibt null zurück, wenn der Knoten nicht existiert.
1.1 Rekursion
Zuerst dachte ich, es sei schwierig und ich könnte nicht anfangen, aber im Thema wurde festgelegt, dass es sich um einen binären Suchbaum handelt, was bedeutet, dass die Elemente der Reihe nach angeordnet sind, was ein geordnetes Array/eine verknüpfte Liste darstellt. Auf der Suche nach Zielwert, es gibt drei Ergebnisse:
- Gleich val, dann wird der Wurzelknoten direkt ausgegeben
- Kleiner als der Wert, der Zielwert befindet sich links vom aktuellen Knoten
- größer als val, das Ziel liegt rechts von val
public TreeNode searchBST(TreeNode root, int val) {
if(root==null || val == root.val) return root;
return val<root.val ? searchBST(root.left,val) : searchBST(root.right,val);
}
1.2 Iteration
Denken ist dasselbe
public TreeNode searchBST(TreeNode root, int val) {
while(root!=null && val!=root.val){
root= val< root.val?root.left:root.right;
}
return root;
}
2. Überprüfen Sie den binären Suchbaum
98. Überprüfen Sie den binären Suchbaum.
Stellen Sie anhand eines Wurzelknotens eines Binärbaums fest, ob es sich um einen gültigen binären Suchbaum handelt.
Ein gültiger binärer Suchbaum ist wie folgt definiert:
Der linke Teilbaum eines Knotens enthält nur Zahlen, die kleiner sind als der aktuelle Knoten.
Der rechte Teilbaum eines Knotens enthält nur Zahlen, die größer sind als der aktuelle Knoten.
Alle linken und rechten Teilbäume müssen selbst binäre Suchbäume sein.
2.1 Rekursion
Die offizielle Rekursion besteht darin, eine Methode neu zu schreiben, zuerst zwei Werte zu definieren, nämlich die kleinste Ganzzahl und die größte Ganzzahl, dann muss der Wert dieses Knotens innerhalb dieses Bereichs liegen und dann die Werte des Teilbaums rekursiv mit dem Minimum vergleichen und Der größte Wert wird verglichen und dann zurückgegeben, aber die Vorteile sind problematisch.
Hier können wir eine einfache Methode anwenden, zuerst den Mindestwert außerhalb definieren und dann isValidBST rekursiv im linken Teilbaum aufrufen und dann beurteilen, ob der aktuelle Knotenwert größer als der Wert des vorherigen Knotens im Durchlauf in der Reihenfolge ist, wenn nicht, geben Sie false zurückDas heißt, die Bedingung von BST ist nicht erfüllt. Weisen Sie abschließend den Wert des aktuellen Knotens der Variablen pre zu und rufen Sie isValidBST rekursiv im rechten Teilbaum auf.
class Solution {
// 里面会采用integer的最大值，会不通过
long pre = Long.MIN_VALUE;
public boolean isValidBST(TreeNode root) {
if(root == null) return true;
// 左子树元素不满足
if(!isValidBST(root.left)){
return false;
}
// 当前节点小于等于中序遍历的前一个节点
if(root.val<= pre){
return false;
}
pre = root.val;
return isValidBST(root.right);
}
}
2.2 Iteration
Wenn die Bedingung erfüllt werden kann, ist das Durchlaufen des binären Suchbaums in der Reihenfolge in Ordnung, und es muss nur beurteilt werden, ob der aktuelle Wert kleiner als der Wert des vorherigen Knotens ist.
public boolean isValidBST(TreeNode root) {
Deque<TreeNode> stack = new LinkedList<>();
// 存储前一个节点元素值
double inorder = -Double.MAX_VALUE;
while(!stack.isEmpty() || root!=null){
while(root!=null){
stack.push(root);
root=root.left;
}
root = stack.pop();
if(root.val<=inorder){
return false;
}
inorder = root.val;
root=root.right;
}
return true;
}
3. Minimale absolute Differenz des binären Suchbaums
Minimale absolute Differenz des binären Suchbaums
Geben Sie anhand der Wurzelknotenwurzel eines binären Suchbaums die minimale Differenz zwischen zwei beliebigen Knotenwerten im Baum zurück.
Die Differenz ist eine positive Zahl, deren Wert dem Absolutwert der Differenz zwischen den beiden Werten entspricht.
3.1 Rekursion
Es ist immer noch der erste, der den Wert des vorherigen Knotens beibehält und dann einen Durchlauf in der Reihenfolge durchführt, um zu vergleichen, ob die Differenz zwischen dem vorherigen Wert und dem aktuellen Wert kleiner als der Mindestwert ist, und ihn zu ersetzen, wenn er kleiner ist.
class Solution {
// 上一个节点的值
int pre;
// 结果
int ans;
public int getMinimumDifference(TreeNode root) {
ans = Integer.MAX_VALUE;
pre=-1;
dfs(root);
return ans;
}
public void dfs(TreeNode root){
if(root==null){
return;
}
// 左
dfs(root.left);
// 中
if(pre == -1){
pre = root.val;
}else{
ans = Math.min(ans,root.val-pre);
pre=root.val;
}
// 右
dfs(root.right);
}
}
3.2 Iteration, Inorder-Traversal
Am Anfang dachte ich über die iterative Methode nach, aber als ich an der Reihe war, war es etwas verwirrend, es selbst zu tun, insbesondere Variablen in der Klasse zu definieren und sie dann in der Methode zu verwenden. Die Methode ist ähnlich.
class Solution {
// 记录前一个节点
TreeNode pre;
Stack<TreeNode> stack;
public int getMinimumDifference(TreeNode root) {
if(root==null) return 0;
TreeNode cur = root;
stack = new Stack<>();
int res = Integer.MAX_VALUE;
while(cur!=null || !stack.isEmpty()){
// 当前节点不为空
if(cur!=null){
stack.push(cur);
// 左
cur=cur.left;
// 当前节点为空
}else{
cur=stack.pop();
// 中
if(pre!=null){
res=Math.min(res,cur.val-pre.val);
}
pre=cur;
// 右
cur=cur.right;
}
}
return res;
}
}