Java: secuencia transversal posterior al pedido del árbol de búsqueda binaria

enlace de tema

Niuke online oj question - secuencia transversal posterior al pedido del árbol de búsqueda binaria

Tema Descripción

Ingrese una matriz de enteros y juzgue si la matriz es el resultado del recorrido posterior al orden de un árbol de búsqueda binaria. Devuelve verdadero si es así, falso en caso contrario. Suponga que dos números cualesquiera en la matriz de entrada son diferentes entre sí.

Rango de datos: el número de nodos es 0≤n≤1000,
el valor del nodo satisface 1≤val≤10^5 y se garantiza que el valor del nodo es diferente
Requisitos: complejidad espacial O(n), tiempo tiempo complejidad O(n^ 2 )

pista:

1. Un árbol de búsqueda binaria es un árbol en el que el nodo principal es más grande que todos los nodos del subárbol izquierdo pero más pequeño que todos los nodos del subárbol derecho.
2. En esta pregunta, estamos de acuerdo en que un árbol vacío no es un árbol de búsqueda binaria
3. El recorrido posterior al orden se refiere al recorrido en el orden de "subárbol izquierdo-subárbol derecho-nodo raíz"
4. Consulte el siguiente árbol de búsqueda binaria, ejemplo 1
   

Ejemplo de tema

Ejemplo 1

Entrada:
[1,3,2]

valor de retorno:
verdadero

Descripción:
es el recorrido posterior al pedido de la imagen de arriba y devuelve verdadero

Ejemplo 2

Entrada:
[3,1,2]

valor devuelto:
falso

Explicación:
no pertenece al recorrido posterior al orden de la figura anterior, y la secuencia no se puede recorrer desde otro árbol de búsqueda binario, porque los 2 últimos deben ser el nodo raíz y el frente debe ser el nodo secundario, que puede ser el hijo izquierdo o el hijo derecho. El nodo raíz también puede ser el hijo izquierdo completo, el nodo raíz, o puede ser el hijo derecho completo, el nodo raíz, pero la combinación de [3,1,2] no puede satisfacer estas condiciones, por lo que devuelve false

Ejemplo 3

Entrada:
[5,7,6,9,11,10,8]

valor de retorno:
verdadero

ideas para resolver problemas

La característica del árbol de búsqueda binaria es que el nodo padre es mayor que el valor de todos los nodos en el subárbol izquierdo y menor que el valor de todos los nodos en el subárbol derecho

El recorrido posterior al pedido es recorrer primero el subárbol izquierdo, luego atravesar el subárbol derecho y luego generar el valor del nodo principal

El subíndice del primer elemento de la matriz de definición es start y el subíndice del último elemento es end.
Primero obtenga el valor correspondiente al subíndice final del último nodo en la matriz. Este valor es el valor del nodo principal y luego recorra la matriz de izquierda a derecha. Cuando se encuentre un elemento con un valor mayor que el nodo principal , el subíndice del nodo Para i,
se puede determinar que [start, i - 1] es la secuencia del subárbol izquierdo de la secuencia transversal actual, y [i, end - 1] es la secuencia del subárbol derecho de la secuencia transversal actual

Continúe recorriendo la secuencia [i, end - 1], si algún elemento es más pequeño que el valor del nodo principal, significa que esta secuencia no satisface la naturaleza del árbol de búsqueda binaria, devuelve falso

Cabe señalar que actualmente solo se determina si la secuencia actual satisface la naturaleza del árbol de búsqueda binaria, y necesitamos juzgar si todos los subárboles satisfacen la naturaleza del árbol de búsqueda binaria, es decir, tenemos que realizar la el proceso anterior respectivamente [start, i - 1] secuencia y [i, end - 1] secuencia se verifican nuevamente

Por lo tanto, se puede verificar por recursividad, y la condición final de terminación es: when start <= end, return true

código completo

public class Solution {
    
    
    public boolean VerifySquenceOfBST(int [] sequence) {
    
    
        if(sequence == null || sequence.length == 0){
    
    
            return false;
        }

        int start = 0;
        int end = sequence.length - 1;
        return VerifySquenceOfBSTHelper(sequence, start, end);
    }

    private boolean VerifySquenceOfBSTHelper(int[] sequence, int start, int end) {
    
    
        if(start >= end){
    
    
            return true;
        }
        
        int root = sequence[end];
        int i = start;
        while(i < end && sequence[i] < root){
    
    
            i++;
        }
        for(int j = i; j < end; j++){
    
    
            if(sequence[j] < root){
    
    
                return false;
            }
        }
        return VerifySquenceOfBSTHelper(sequence, start, i - 1) && VerifySquenceOfBSTHelper(sequence, i, end - 1);
    }
}