Preguntas de prueba de leetcode | Resumen de tipos de preguntas sobre árboles binarios 3
Directorio de artículos
Conexión de preguntas
897. Árbol de búsqueda de orden creciente - LeetCode
Sword Points se ofrecerá II 053. Sucesor en orden en el árbol de búsqueda binaria - LeetCode
538. Convertir árbol de búsqueda binario en árbol acumulativo - LeetCode
173. Iterador de árbol de búsqueda binaria - LeetCode
Árbol de búsqueda de orden creciente
El árbol binario en sí está ordenado y se puede recorrer en orden izquierdo, medio y derecho, utilizando un nodo anterior para guardar el nodo anterior.
class Solution {
TreeNode prev = new TreeNode(-1);
TreeNode node = prev;
public TreeNode increasingBST(TreeNode root) {
dfs(root);
return node.right;
}
public void dfs(TreeNode root){
if(root == null) return ;
dfs(root.left);
prev.right = root;
root.left = null;
prev = root;
dfs(root.right);
}
}
Sucesor en orden en el árbol de búsqueda binaria
dfs+ recorrido en orden
class Solution {
TreeNode res = null;
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
dfs(root,p);
return res;
}
public TreeNode dfs(TreeNode root,TreeNode p){
if(root == null) return null;
if(root.val > p.val){
res = root;
return inorderSuccessor(root.left,p);
}else return inorderSuccessor(root.right,p);
}
}
Utilice la búsqueda binaria para encontrar el nodo donde se encuentra cur = p y utilice prev para registrar el nodo raíz de cur.
Luego determine si el nodo cur tiene un subárbol derecho y, si existe, devuelva el nodo más a la izquierda del subárbol derecho.
Si no hay un subárbol derecho, regrese directamente a anterior, porque pre > cur = p
class Solution {
public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
TreeNode cur = root;
TreeNode prev = null;
while(cur != p){
if(cur.val > p.val){
prev = cur;
cur = cur.left;
}else{
cur = cur.right;
}
}
if(cur.right != null){
cur = cur.right;
while(cur.left != null){
cur = cur.left;
}
return cur;
}
return prev;
}
}
Convertir un árbol de búsqueda binario en un árbol acumulativo
class Solution {
int sum = 0;
public TreeNode convertBST(TreeNode root) {
if(root == null) return null;
convertBST(root.right);
root.val += sum; //将当前节点值和大于当前节点值的和相加
sum = root.val;
convertBST(root.left);
return root;
}
}
Utilice el recorrido de orden medio en orden inverso derecha-centro-izquierda y utilice la pila para almacenar el nodo anterior
Cuando cur = null, se atraviesa el nodo hoja, dep.poll() obtiene el nodo padre del nodo y establece cur = el nodo padre.
Actualice el valor val del nodo padre actual. La pregunta requiere que el valor sea igual a la suma de los valores mayores o iguales en el árbol original node.val. Utilice suma para guardar la suma.
Debido a que se utiliza el orden transversal derecha-centro-izquierda, la suma siempre es acumulativa.
class Solution {
public TreeNode convertBST(TreeNode root) {
int sum = 0;
Deque<TreeNode> deq = new ArrayDeque();
TreeNode cur = root;
while(!deq.isEmpty() || cur != null){
if(cur != null){
deq.push(cur);
cur = cur.right;
}else{
cur = deq.poll();
sum += cur.val;
cur.val = sum;
cur = cur.left;
}
}
return root;
}
}
Iterador de árbol de búsqueda binaria
Primero obtenga los resultados del recorrido en orden y luego recorra
class BSTIterator {
List<TreeNode> list = null;
int index;
int siez;
public BSTIterator(TreeNode root) {
list = new ArrayList<>();
index = -1;
dfs(root);
this.siez = list.size();
}
public int next() {
return list.get(++index).val;
}
public boolean hasNext() {
if (index >= siez-1) return false;
return true;
}
public void dfs(TreeNode root){
if (root == null) return ;
dfs(root.left);
list.add(root);
dfs(root.right);
}
}
Utilice la pila para almacenar todos los nodos secundarios y nodos raíz izquierdos
class BSTIterator {
Deque<TreeNode> deq = new ArrayDeque<>();
public BSTIterator(TreeNode root) {
TreeNode node = root;
while (node != null){
deq.push(node);
node = node.left;
}
}
public int next() {
TreeNode cur = deq.poll();
if(cur.right != null){
TreeNode node = cur.right;
while(node != null){
deq.push(node);
node = node.left;//把所有的左节点都放入deq
}
}
return cur.val;
}
public boolean hasNext() {
return !deq.isEmpty();
}
}