[LeetCode-150 perguntas clássicas da entrevista-dia 25]

Índice

530. Diferença absoluta mínima da árvore de pesquisa binária

 230.O K-ésimo menor elemento na árvore de pesquisa binária

 98. Verifique a árvore de pesquisa binária

---

 

530. Diferença absoluta mínima da árvore de pesquisa binária

Significado da pergunta:

Dado o nó raiz de uma árvore de pesquisa binária  root , retorne  a diferença mínima entre os valores de quaisquer dois nós diferentes na árvore  .

Diferença é um número positivo cujo valor é igual ao valor absoluto da diferença entre dois valores.

• O intervalo do número de nós na árvore é [2, 100]
• 0 <= Node.val <= 105

[Exemplo de entrada] raiz = [4,2,6,1,3]

【Amostra de saída】1

Ideias para resolução de problemas:

As características de uma árvore de pesquisa binária são que todos os valores na subárvore esquerda são menores que o nó raiz e todos os valores na subárvore direita são maiores que o nó raiz;

Para encontrar a diferença mínima, a escolha deve ser a diferença mínima entre dois elementos adjacentes.

Calcule a diferença percorrendo a árvore, salve os resultados e compare durante a travessia.

O método de travessia usa travessia em ordem porque os resultados da travessia em ordem são ordenados.

class Solution {
    int ans,pre;//Pre保存前驱节点的值
    public int getMinimumDifference(TreeNode root) {
        ans = Integer.MAX_VALUE;
        pre = -1;//提示中说明节点值的范围是[0,105],所以初始化为-1
        midOrder(root);
        return ans;      
    }

    void midOrder(TreeNode root){
        if(root == null){
            return;
        }
        midOrder(root.left);
        if(pre == -1){
            pre = root.val;
        }else{
            ans = Math.min(ans, root.val - pre);
            pre = root.val;
        }
        midOrder(root.right);
    }
}

Tempo: bater 100,00%

Memória: derrotada por 29,78%

 230.O K-ésimo menor elemento na árvore de pesquisa binária

Significado da pergunta:

Dado o nó raiz de uma árvore de pesquisa binária  root e um número inteiro  k , projete um algoritmo para encontrar o  k menor elemento (contando a partir de 1).

dica:

• O número de nós na árvore é  n .
• 1 <= k <= n <= 104
• 0 <= Node.val <= 104

[Exemplo de entrada] root = [3,1,4,null,2], k = 1

【Amostra de saída】1

Ideias para resolução de problemas:

Basta encontrar o k-ésimo número por meio de travessia em ordem.

Para evitar percorrer todos os nós, a pesquisa recursiva não é usada, mas a pesquisa iterativa, com a ajuda de pilha

class Solution {
    public int kthSmallest(TreeNode root, int k) {
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);//先把根存进去，然后先找左子树
                root = root.left;//左 根 右，持续进栈根节点，直到找到最左的节点
            }
            //循环结束条件是root为空，证明上一个root没有左节点，出栈
            root = stack.pop();
            --k;//遍历到一个数减一次
            if(k == 0){
                break;
            }
            root = root.right;//往节点右子树找了
        }
        return root.val;
    }
}

Tempo: Derrotado 24,31%

Memória: derrotada por 75,46%

 98. Verifique a árvore de pesquisa binária

Significado da pergunta:

Dado o nó raiz de uma árvore binária  root , determine se é uma árvore de pesquisa binária válida.

Uma  árvore de pesquisa binária válida é definida da seguinte forma:

• A subárvore esquerda de um nó contém apenas números  menores que  o nó atual.
• A subárvore direita de um nó contém apenas  números maiores que  o nó atual.
• Todas as subárvores esquerda e direita devem ser árvores de pesquisa binária.

dica:

• O número de nós na árvore [1, 104] está dentro
• -231 <= Node.val <= 231 - 1

[Exemplo de entrada] raiz = [2,1,3]

[Amostra de saída] verdadeiro

Ideias para resolução de problemas:

Como na pergunta anterior, use a pilha para realizar a travessia em ordem e use pre para salvar o valor do nó anterior.Se root.val <= pre, significa que não é uma árvore de pesquisa binária.

class Solution {
    public boolean isValidBST(TreeNode root) {
        double pre = -Double.MAX_VALUE;;
        Deque<TreeNode> stack = new ArrayDeque<TreeNode>();
        while(root != null || !stack.isEmpty()){
            while(root != null){
                stack.push(root);
                root = root.left;
            }
            root = stack.pop();
            if(root.val <= pre){//=也不符合二叉搜索树的要求
                return false;//不满足
            }
            pre = root.val;
            root = root.right;
        }
        return true;
    }
}

Tempo: Derrotado 18,62%

Memória: derrotada por 49,12%