Atsižvelgiant į a šaknį Dvejetainis paieškos medis ir sveikasis skaičius k . Užduotis yra surasti didžiausias skaičius dvejetainiame paieškos medyje mažiau nei arba lygus į k, jei tokio elemento nėra, spausdinkite -1.
Pavyzdžiai:
Įvestis:
paprasta python programa
Išvestis: 21
Paaiškinimas: 19 ir 25 yra du artimiausi skaičiai 21, o 19 yra didžiausias skaičius, kurio reikšmė mažesnė arba lygi 21.
Įvestis:
Išvestis: 3
Paaiškinimas: 3 ir 5 yra du artimiausi skaičiai 4, o 3 yra didžiausias skaičius, kurio reikšmė mažesnė arba lygi 4.
Turinio lentelė
[Naivus požiūris] Naudojant rekursiją – O(h) laikas ir O(h) erdvė
C++Idėja yra pradėti nuo šaknis ir palyginkite jo vertę su k. Jei mazgo reikšmė didesnė nei k, pereikite prie kairiojo pomedžio. Kitu atveju suraskite didžiausio skaičiaus reikšmę, mažesnę nei lygi k dešinysis pomedis . Jei dešinysis pomedis grąžina -1 (tai reiškia, kad tokios reikšmės nėra), tada grąžinama dabartinio mazgo reikšmė. Kitu atveju grąžinama dešiniojo pomedžio grąžinta reikšmė (nes ji bus didesnė nei dabartinio mazgo reikšmė, bet mažesnė nei lygi k).
// C++ code to find the largest value // smaller than or equal to k using recursion #include
// 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 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# 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 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));
Išvestis
21
[Numatomas metodas] Iteracijos naudojimas – O(h) laikas ir O(1) erdvė
C++Idėja yra pradėti nuo šaknis ir palyginkite jo vertę su k . Jei mazgo vertė yra <= k atnaujinkite rezultato reikšmę į šaknies reikšmę ir pereikite prie teisingai kitas pomedis perkelti į paliko pomedis. Autorius iteratyviai Taikydami šią operaciją visuose mazguose galime sumažinti vietos, reikalingos rekursija krūva.
valstijos JAV
// C++ code to find the largest value // smaller than or equal to k using recursion #include
// 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 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# 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 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));
Išvestis
21Sukurti viktoriną