logo

TechCodeview

Maior número em BST que é menor ou igual a k

Dada a raiz de um Árvore de pesquisa binária e um número inteiro k . A tarefa é encontrar o maior número na árvore de pesquisa binária que é menor que ou igual para k se tal elemento não existir, imprima -1. 

Exemplos:  

Entrada:



Maior número em BST que é menor que ou igual a k-1' title=

Saída : 21
Explicação: 19 e 25 são dois números mais próximos de 21 e 19 é o maior número com valor menor ou igual a 21.

Entrada:

Maior número em BST que é menor que ou igual a k-2' loading='lazy' title=

Saída : 3
Explicação: 3 e 5 são dois números mais próximos de 4 e 3 é o maior número com valor menor ou igual a 4.

Índice

[Abordagem ingênua] Usando recursão - O(h) Tempo e O(h) Espaço

A ideia é começar pelo raiz e compare seu valor com k. Se o valor do nó for maior que k, vá para a subárvore esquerda. Caso contrário, encontre o valor do maior número menor que igual a k no subárvore direita . Se a subárvore direita retornar -1 (significando que tal valor não existe), retorne o valor do nó atual. Caso contrário, retorne o valor retornado pela subárvore direita (pois será maior que o valor do nó atual, mas menor que igual a k).

C++ 
// C++ code to find the largest value  // smaller than or equal to k using recursion #include    using namespace std; class Node { public:  int data;  Node *left *right;    Node(int val){  data = val;  left = nullptr;  right = nullptr;  } }; // function to find max value less than k int findMaxFork(Node* root int k) {    // Base cases  if (root == nullptr)  return -1;  if (root->data == k)  return k;  // If root's value is smaller  // try in right subtree  else if (root->data < k) {    int x = findMaxFork(root->right k);  if (x == -1)  return root->data;  else  return x;  }  // If root's data is greater   // return value from left subtree.  return findMaxFork(root->left k);  } int main() {    int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node* root = new Node(5);  root->left = new Node(2);  root->left->left = new Node(1);  root->left->right = new Node(3);  root->right = new Node(12);  root->right->left = new Node(9);  root->right->right = new Node(21);  root->right->right->left = new Node(19);  root->right->right->right = new Node(25);    cout << findMaxFork(root k);  return 0; }
Java 
// Java code to find the largest value  // smaller than or equal to k using recursion class Node {  int data;  Node left right;    Node(int val) {  data = val;  left = null;  right = null;  } } class GfG {    // function to find max value less than k  static int findMaxFork(Node root int k) {    // Base cases  if (root == null)  return -1;  if (root.data == k)  return k;  // If root's value is smaller  // try in right subtree  else if (root.data < k) {  int x = findMaxFork(root.right k);  if (x == -1)  return root.data;  else  return x;  }  // If root's data is greater  // return value from left subtree.  return findMaxFork(root.left k);  }  public static void main(String[] args) {  int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node root = new Node(5);  root.left = new Node(2);  root.left.left = new Node(1);  root.left.right = new Node(3);  root.right = new Node(12);  root.right.left = new Node(9);  root.right.right = new Node(21);  root.right.right.left = new Node(19);  root.right.right.right = new Node(25);  System.out.println(findMaxFork(root k));  } }
Python 
# Python code to find the largest value  # smaller than or equal to k using recursion class Node: def __init__(self val): self.data = val self.left = None self.right = None # function to find max value less than k def findMaxFork(root k): # Base cases if root is None: return -1 if root.data == k: return k # If root's value is smaller # try in right subtree elif root.data < k: x = findMaxFork(root.right k) if x == -1: return root.data else: return x # If root's data is greater # return value from left subtree. return findMaxFork(root.left k) if __name__ == '__main__': k = 24 # creating following BST # # 5 # /   # 2 12 # /  /   # 1 3 9 21 # /   # 19 25 root = Node(5) root.left = Node(2) root.left.left = Node(1) root.left.right = Node(3) root.right = Node(12) root.right.left = Node(9) root.right.right = Node(21) root.right.right.left = Node(19) root.right.right.right = Node(25) print(findMaxFork(root k))
C# 
// C# code to find the largest value  // smaller than or equal to k using recursion using System; class Node {  public int data;  public Node left right;    public Node(int val) {  data = val;  left = null;  right = null;  } } class GfG {    // function to find max value less than k  static int FindMaxFork(Node root int k) {    // Base cases  if (root == null)  return -1;  if (root.data == k)  return k;  // If root's value is smaller  // try in right subtree  else if (root.data < k) {  int x = FindMaxFork(root.right k);  if (x == -1)  return root.data;  else  return x;  }  // If root's data is greater  // return value from left subtree.  return FindMaxFork(root.left k);  }  static void Main() {  int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node root = new Node(5);  root.left = new Node(2);  root.left.left = new Node(1);  root.left.right = new Node(3);  root.right = new Node(12);  root.right.left = new Node(9);  root.right.right = new Node(21);  root.right.right.left = new Node(19);  root.right.right.right = new Node(25);  Console.WriteLine(FindMaxFork(root k));  } }
JavaScript 
// JavaScript code to find the largest value  // smaller than or equal to k using recursion class Node {  constructor(val) {  this.data = val;  this.left = null;  this.right = null;  } } // function to find max value less than k function findMaxFork(root k) {    // Base cases  if (root === null)  return -1;  if (root.data === k)  return k;  // If root's value is smaller  // try in right subtree  else if (root.data < k) {  let x = findMaxFork(root.right k);  if (x === -1)  return root.data;  else  return x;  }  // If root's data is greater  // return value from left subtree.  return findMaxFork(root.left k); } let k = 24; // creating following BST // // 5 // /   // 2 12 // /  /   // 1 3 9 21 // /   // 19 25 let root = new Node(5); root.left = new Node(2); root.left.left = new Node(1); root.left.right = new Node(3); root.right = new Node(12); root.right.left = new Node(9); root.right.right = new Node(21); root.right.right.left = new Node(19); root.right.right.right = new Node(25); console.log(findMaxFork(root k));

Saída 
21

[Abordagem Esperada] Usando Iteração - O(h) Tempo e O(1) Espaço

A ideia é começar pelo raiz e compare seu valor com k . Se o valor do nó for <= k atualize o valor do resultado para o valor da raiz e vá para o certo subárvore senão move para a esquerda subárvore. Por iterativamente aplicando esta operação em todos os nós, podemos minimizar o espaço necessário para o recursão pilha.

C++ 
// C++ code to find the largest value  // smaller than or equal to k using recursion #include    using namespace std; class Node { public:  int data;  Node *left *right;    Node(int val){  data = val;  left = nullptr;  right = nullptr;  } }; // function to find max value less than k int findMaxFork(Node* root int k) {    int result = -1;    // Start from root and keep looking for larger   while (root != nullptr) {  // If root is smaller go to right side  if (root->data <= k){  result = root->data;  root = root->right;  }  // If root is greater go to left side   else  root = root->left;  }    return result; } int main() {    int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node* root = new Node(5);  root->left = new Node(2);  root->left->left = new Node(1);  root->left->right = new Node(3);  root->right = new Node(12);  root->right->left = new Node(9);  root->right->right = new Node(21);  root->right->right->left = new Node(19);  root->right->right->right = new Node(25);    cout << findMaxFork(root k);  return 0; }
Java 
// Java code to find the largest value  // smaller than or equal to k using recursion class Node {  int data;  Node left right;    Node(int val) {  data = val;  left = null;  right = null;  } } class GfG {    // function to find max value less than k  static int findMaxFork(Node root int k) {  int result = -1;    // Start from root and keep looking for larger   while (root != null) {  // If root is smaller go to right side  if (root.data <= k) {  result = root.data;  root = root.right;  }  // If root is greater go to left side   else {  root = root.left;  }  }    return result;  }  public static void main(String[] args) {  int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node root = new Node(5);  root.left = new Node(2);  root.left.left = new Node(1);  root.left.right = new Node(3);  root.right = new Node(12);  root.right.left = new Node(9);  root.right.right = new Node(21);  root.right.right.left = new Node(19);  root.right.right.right = new Node(25);  System.out.println(findMaxFork(root k));  } }
Python 
# Python code to find the largest value  # smaller than or equal to k using recursion class Node: def __init__(self val): self.data = val self.left = None self.right = None # function to find max value less than k def findMaxFork(root k): result = -1 # Start from root and keep looking for larger  while root is not None: # If root is smaller go to right side if root.data <= k: result = root.data root = root.right # If root is greater go to left side  else: root = root.left return result if __name__ == '__main__': k = 24 # creating following BST # # 5 # /   # 2 12 # /  /   # 1 3 9 21 # /   # 19 25 root = Node(5) root.left = Node(2) root.left.left = Node(1) root.left.right = Node(3) root.right = Node(12) root.right.left = Node(9) root.right.right = Node(21) root.right.right.left = Node(19) root.right.right.right = Node(25) print(findMaxFork(root k))
C# 
// C# code to find the largest value  // smaller than or equal to k using recursion using System; class Node {  public int data;  public Node left right;    public Node(int val) {  data = val;  left = null;  right = null;  } } class GfG {    // function to find max value less than k  static int FindMaxFork(Node root int k) {  int result = -1;    // Start from root and keep looking for larger   while (root != null) {  // If root is smaller go to right side  if (root.data <= k) {  result = root.data;  root = root.right;  }  // If root is greater go to left side   else {  root = root.left;  }  }    return result;  }  static void Main() {  int k = 24;  // creating following BST  //  // 5  // /    // 2 12  // /  /    // 1 3 9 21  // /    // 19 25  Node root = new Node(5);  root.left = new Node(2);  root.left.left = new Node(1);  root.left.right = new Node(3);  root.right = new Node(12);  root.right.left = new Node(9);  root.right.right = new Node(21);  root.right.right.left = new Node(19);  root.right.right.right = new Node(25);  Console.WriteLine(FindMaxFork(root k));  } }
JavaScript 
// JavaScript code to find the largest value  // smaller than or equal to k using recursion class Node {  constructor(val) {  this.data = val;  this.left = null;  this.right = null;  } } // function to find max value less than k function findMaxFork(root k) {  let result = -1;    // Start from root and keep looking for larger   while (root !== null) {  // If root is smaller go to right side  if (root.data <= k) {  result = root.data;  root = root.right;  }  // If root is greater go to left side   else {  root = root.left;  }  }    return result; } let k = 24; // creating following BST // // 5 // /   // 2 12 // /  /   // 1 3 9 21 // /   // 19 25 let root = new Node(5); root.left = new Node(2); root.left.left = new Node(1); root.left.right = new Node(3); root.right = new Node(12); root.right.left = new Node(9); root.right.right = new Node(21); root.right.right.left = new Node(19); root.right.right.right = new Node(25); console.log(findMaxFork(root k));

Saída 
21
Criar questionário