logo

TechCodeview

Úvod do binárního vyhledávacího stromu – výukové programy pro datovou strukturu a algoritmus

Binární vyhledávací strom je datová struktura používaná v informatice pro organizování a ukládání dat tříděným způsobem. Binární vyhledávací strom sleduje všechny vlastnosti binárního stromu a jeho vlevo, odjet potomek obsahuje hodnoty menší než nadřazený uzel a že jo potomek obsahuje hodnoty větší než nadřazený uzel. Tato hierarchická struktura umožňuje efektivní Hledání , Vložení , a Vymazání operace s daty uloženými ve stromu.

Binární vyhledávací strom




Obsah

imessage hry na android

Co je binární vyhledávací strom?

Binární vyhledávací strom (BST) je zvláštní druh binární strom ve kterém má levý potomek uzlu hodnotu menší než hodnota uzlu a pravý potomek má hodnotu větší, než je hodnota uzlu. Tato vlastnost se nazývá vlastnost BST a umožňuje efektivně vyhledávat, vkládat a mazat prvky ve stromu.



Vlastnosti binárního vyhledávacího stromu:

  • Levý podstrom uzlu obsahuje pouze uzly s klíči menšími, než je klíč uzlu.
  • Pravý podstrom uzlu obsahuje pouze uzly s klíči většími, než je klíč uzlu.
  • To znamená, že vše nalevo od kořenového adresáře je menší než hodnota kořenového adresáře a vše napravo od kořenového adresáře je větší než hodnota kořenového adresáře. Díky tomuto výkonu je binární vyhledávání velmi snadné.
  • Levý a pravý podstrom musí být také binárním vyhledávacím stromem.
  • Nesmí existovat žádné duplicitní uzly (BST může mít duplicitní hodnoty s různými přístupy k manipulaci)

Zpracování duplicitních hodnot ve stromu binárního vyhledávání:

  • Musíme dodržovat konzistentní proces, tj. buď uložit duplicitní hodnotu nalevo, nebo uložit duplicitní hodnotu napravo od kořenového adresáře, ale být konzistentní s vaším přístupem.

Základní operace s binárním vyhledávacím stromem:

1. Hledání uzlu v BST:

Hledání v BST znamená najít konkrétní uzel v datové struktuře. V binárním vyhledávacím stromu je vyhledávání uzlu snadné, protože má specifické pořadí. Kroky prohledání uzlu ve stromu binárního vyhledávání jsou uvedeny následovně –

  1. Nejprve porovnejte hledaný prvek s kořenovým prvkem stromu.
    • Pokud se root shoduje s cílovým prvkem, vraťte umístění uzlu.
    • Pokud se neshoduje, zkontrolujte, zda je položka menší než kořenový prvek, pokud je menší než kořenový prvek, přejděte do levého podstromu.
    • Pokud je větší než kořenový prvek, přejděte do pravého podstromu.
  2. Opakujte výše uvedený postup rekurzivně, dokud nebude nalezena shoda.
  3. Pokud prvek není nalezen nebo není přítomen ve stromu, vraťte hodnotu NULL.

Nyní pochopme vyhledávání v binárním stromu na příkladu:

Níže je uveden BST a musíme hledat prvek 6.




Kód:

Níže je implementace vyhledávání v BST:

C++ 
// C++ function to search a given key in a given BST #include  using namespace std; struct node {  int key;  struct node *left, *right; }; // A utility function to create a new BST node struct node* newNode(int item) {  struct node* temp  = new struct node;  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Obslužná funkce pro vložení // nového uzlu s daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL ) return newNode(key);  // V opačném případě se ve stromu opakujte, pokud (key< node->key) node->left = insert(uzel->left, key);  else if (klíč> uzel->klíč) uzel->vpravo = vložit(uzel->vpravo, klíč);  // Vrátí (nezměněný) ukazatel uzlu return node; } // Funkce nástroje pro hledání klíče v uzlu BST struct* search(struct node* root, int key) root->key == key) return root;  // Klíč je větší než kořenový klíč if (root->key< key)  return search(root->vpravo, klíč);  // Klíč je menší než klíč roota return search(root->left, key);>
C 
// C function to search a given key in a given BST #include  #include  struct node {  int key;  struct node *left, *right; }; // A utility function to create a new BST node struct node* newNode(int item) {  struct node* temp  = (struct node*)malloc(sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Obslužná funkce pro vložení // nového uzlu s daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL ) return newNode(key);  // V opačném případě se ve stromu opakujte, pokud (key< node->key) node->left = insert(uzel->left, key);  else if (klíč> uzel->klíč) uzel->vpravo = vložit(uzel->vpravo, klíč);  // Vrátí (nezměněný) ukazatel uzlu return node; } // Funkce nástroje pro vyhledání klíče v uzlu struktury BST* search (struct node* root, klíč int)>
Jáva 
// Java program to search a given key in a given BST class Node {  int key;  Node left, right;  public Node(int item) {  key = item;  left = right = null;  } } class BinarySearchTree {  Node root;  // Constructor  BinarySearchTree() {  root = null;  }  // A utility function to insert  // a new node with given key in BST  Node insert(Node node, int key) {  // If the tree is empty, return a new node  if (node == null) {  node = new Node(key);  return node;  }  // Otherwise, recur down the tree  if (key < node.key)  node.left = insert(node.left, key);  else if (key>node.key) node.right = insert(uzel.right, key);  // Vrátí (nezměněný) ukazatel uzlu return node;  } // Funkce nástroje pro hledání klíče při hledání uzlu BST (kořen uzlu, klíč int) // Základní případy: root je null nebo klíč je přítomen v rootu if (root == null>
Krajta 
# Python3 function to search a given key in a given BST class Node: # Constructor to create a new node def __init__(self, key): self.key = key self.left = None self.right = None # A utility function to insert # a new node with the given key in BST def insert(node, key): # If the tree is empty, return a new node if node is None: return Node(key) # Otherwise, recur down the tree if key < node.key: node.left = insert(node.left, key) elif key>node.key: node.right = insert(node.right, key) # Vrátit (nezměněný) ukazatel uzlu návratový uzel # Funkce nástroje pro hledání klíče v BST def search(root, key): # Základní případy: root is null nebo klíč je přítomen v rootu, pokud root je Žádný nebo root.key == klíč: return root # Klíč je větší než root, pokud root.key< key: return search(root.right, key) # Key is smaller than root's key return search(root.left, key)>
JavaScript 
// Javascript function to search a given key in a given BST class Node { constructor(key) {  this.key = key;  this.left = null;  this.right = null; } } // A utility function to insert // a new node with given key in BST function insert(node, key) { // If the tree is empty, return a new node if (node === null) {  return new Node(key); } // Otherwise, recur down the tree if (key < node.key) {  node.left = insert(node.left, key); } else if (key>node.key) { node.right = insert(uzel.right, key); } // Vrátí (nezměněný) ukazatel uzlu return node; } // Funkce nástroje pro hledání klíče ve funkci BST search(root, key) { // Základní případy: root je null nebo klíč je přítomen v root if (root === null || root.key === klíč ) { return root; } // Klíč je větší než klíč root's if (root.key< key) {  return search(root.right, key); } // Key is smaller than root's key return search(root.left, key); }>


2. Vložte uzel do BST :

Na křídle se vždy vloží nový klíč. Začněte hledat klíč od kořenového po listový uzel. Jakmile je nalezen listový uzel, nový uzel je přidán jako potomek listového uzlu.


Kód:

Níže je uvedena implementace vložení jednoho uzlu do stromu binárního vyhledávání:

C++ 
// Given Node Structure struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return newNode(key);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = vložit(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; }>
C 
// Given Node Structure struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp  = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return newNode(key);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = vložit(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; }>
Jáva 
class GFG {  // Given Node Structure  static class node {  int key;  node left, right;  };  // Function to create a new BST node  static node newNode(int item)  {  node temp = new node();  temp.key = item;  temp.left = temp.right = null;  return temp;  }  // Function to insert a new node with  // given key in BST  static node insert(node node, int key)  {  // If the tree is empty, return a new node  if (node == null)  return newNode(key);  // Otherwise, recur down the tree  if (key < node.key) {  node.left = insert(node.left, key);  }  else if (key>node.key) { node.right = insert(uzel.right, key);  } // Vrátí návratový uzel uzlu;  } }>
Python3 
# Given Node Structure class Node: def __init__(self, key): self.key = key self.left = None self.right = None # Function to insert a new node with # given key in BST def insert(node, key): # If the tree is empty, return a new node if node is None: return Node(key) # Otherwise, recur down the tree if key < node.key: node.left = insert(node.left, key) elif key>node.key: node.right = insert(node.right, key) # Vrátit ukazatel uzlu return node>
Javascript 
// Given Node Structure class Node {  constructor(key){  this.key = key;  this.left = null;  this.right = null;  } } // Function to insert a new node with // given key in BST function insert(node, key) {    // If the tree is empty, return a new node  if (node == null)  return new Node(key);  // Otherwise, recur down the tree  if (key < node.key)  {  node.left = insert(node.left, key);  }  else if (key>node.key) { node.right = insert(uzel.right, key);  } // Vrátí ukazatel na uzel return node; }>

Časová náročnost: O(N), kde N je počet uzlů BST
Pomocný prostor: O(1)

3. Odstraňte uzel BST :

Používá se k odstranění uzlu se specifickým klíčem z BST a vrácení nového BST.

Různé scénáře pro odstranění uzlu:

Uzel, který má být odstraněn, je listový uzel :

Je to jednoduché, můžete to prostě vynulovat.

d1

Uzel ke smazání má jednoho potomka :

Můžete pouze nahradit uzel podřízeným uzlem.

soubor

Uzel ke smazání má dva potomky :

Tady musíme delete the node je tak, že výsledný strom sleduje vlastnosti BST. Trik je najít neřadového nástupce uzlu. Zkopírujte obsah následníka pořadí do uzlu a odstraňte následníka pořadí.

d3

Při odstraňování uzlu BST dbejte na následující věci:

  1. Je třeba zjistit, jaká bude náhrada uzlu, který má být odstraněn.
  2. Chcete minimální narušení stávající stromové struktury
  3. Může vzít náhradní uzel z levého nebo pravého podstromu odstraněných uzlů.
  4. Pokud bereme if z levého podstromu, musíme vzít největší hodnotu v levém podstromu.
  5. Pokud bereme if z pravého podstromu, musíme vzít nejmenší hodnotu v pravém podstromu.

Kód:

Níže je uvedena implementace odstranění v BST:

C++ 
// C++ program to delete // a node of BST // Given Node node struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp  = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return novýUzel(klíč);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = vložit(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; } // Funkce, která vrací uzel s minimální // hodnotou klíče nalezenou v tomto stromu struct node* minValueNode(struct node* node) { struct node* current = node;  // Smyčkou dolů najděte list úplně vlevo while (aktuální && aktuální->levý != NULL) current = current->left;  zpětný proud; } // Funkce, která vymaže klíč a // vrátí novou kořenovou strukturu node* deleteNode(struct node* root, klíč int) { // base Case if (root == NULL) return root;  // Pokud je klíč k odstranění // menší než kořenový klíč, // pak leží v levém podstromu if (klíč< root->klíč) { root->left = deleteNode(root->left, key);  } // Pokud je klíč k odstranění // větší než kořenový klíč, // pak leží v pravém podstromu else if (klíč> root->klíč) { root->right = deleteNode(root-> vpravo, klíč);  } // Pokud je klíč stejný jako root's key, // pak toto je uzel //, který má být odstraněn jinak { // Uzel s pouze jedním potomkem // nebo žádným potomkem if (root->left == NULL) { struct node* temp = root->right;  volný(kořen);  návratová teplota;  } else if (root->right == NULL) { struct node* temp = root->left;  volný(kořen);  návratová teplota;  } // Uzel se dvěma potomky: // Získání následníka pořadí (nejmenší // v pravém podstromu) struct node* temp = minValueNode(root->right);  // Zkopírujte // obsah následníka // tohoto uzlu root->key = temp->key;  // Smazání následníka pořadí root->right = deleteNode(root->right, temp->key);  } return root; }>
C 
// C program to delete // a node of BST // Given Node node struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp  = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return novýUzel(klíč);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = vložit(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; } // Funkce, která vrací uzel s minimální // hodnotou klíče nalezenou v tomto stromu struct node* minValueNode(struct node* node) { struct node* current = node;  // Smyčkou dolů najděte list úplně vlevo while (aktuální && aktuální->levý != NULL) current = current->left;  zpětný proud; } // Funkce, která vymaže klíč a // vrátí novou kořenovou strukturu node* deleteNode(struct node* root, klíč int) { // base Case if (root == NULL) return root;  // Pokud je klíč k odstranění // menší než kořenový klíč, // pak leží v levém podstromu if (klíč< root->klíč) { root->left = deleteNode(root->left, key);  } // Pokud je klíč k odstranění // větší než kořenový klíč, // pak leží v pravém podstromu else if (klíč> root->klíč) { root->right = deleteNode(root-> vpravo, klíč);  } // Pokud je klíč stejný jako root's key, // pak toto je uzel //, který má být odstraněn jinak { // Uzel s pouze jedním potomkem // nebo žádným potomkem if (root->left == NULL) { struct node* temp = root->right;  volný(kořen);  návratová teplota;  } else if (root->right == NULL) { struct node* temp = root->left;  volný(kořen);  návratová teplota;  } // Uzel se dvěma potomky: // Získání následníka pořadí (nejmenší // v pravém podstromu) struct node* temp = minValueNode(root->right);  // Zkopírujte // obsah následníka // tohoto uzlu root->key = temp->key;  // Smazání následníka pořadí root->right = deleteNode(root->right, temp->key);  } return root; }>
Jáva 
// Java program for Delete a Node of BST class GFG {  // Given Node node  static class node {  int key;  node left, right;  };  // Function to create a new BST node  static node newNode(int item)  {  node temp = new node();  temp.key = item;  temp.left = temp.right = null;  return temp;  }  // Function to insert a new node with  // given key in BST  static node insert(node node, int key)  {  // If the tree is empty, return a new node  if (node == null)  return newNode(key);  // Otherwise, recur down the tree  if (key < node.key) {  node.left = insert(node.left, key);  }  else if (key>node.key) { node.right = insert(uzel.right, key);  } // Vrátí návratový uzel uzlu;  } // Funkce, která vrací uzel s minimální // hodnotou klíče nalezenou v tomto stromu statický uzel minValueNode(node ​​node) { node current = node;  // Smyčkou dolů vyhledejte list úplně vlevo while (current != null && current.left != null) current = current.left;  zpětný proud;  } // Funkce, která odstraní klíč a // vrátí nový kořenový statický uzel deleteNode(kořen uzlu, klíč int) { // base Case if (root == null) return root;  // Pokud je klíč k odstranění // menší než kořenový klíč, // pak leží v levém podstromu if (klíč< root.key) {  root.left = deleteNode(root.left, key);  }  // If the key to be deleted is  // greater than the root's key,  // then it lies in right subtree  else if (key>root.key) { root.right = deleteNode(root.right, key);  { teplota uzlu = root.right;  návratová teplota;  } else if (root.right == null) { node temp = root.left;  návratová teplota;  } // Uzel se dvěma potomky: // Získání následníka pořadí (nejmenší // v pravém podstromu) node temp = minValueNode(root.right);  // Zkopírujte // obsah následníka pořadí do tohoto uzlu root.key = temp.key;  // Smazání následníka pořadí root.right = deleteNode(root.right, temp.key);  } return root;  }>
Krajta 
# Python program to delete a node of BST # Given Node node class Node: def __init__(self, key): self.key = key self.left = None self.right = None # Function to insert a new node with # given key in BST def insert(root, key): # If the tree is empty, return a new node if root is None: return Node(key) # Otherwise, recur down the tree if key < root.key: root.left = insert(root.left, key) elif key>root.key: root.right = insert(root.right, key) # Vraťte ukazatel uzlu return root # Funkce pro provedení procházení BST def inorder(root): if root: inorder(root.left) print(root. key, end=' ') inorder(root.right) # Funkce, která vrací uzel s minimální # hodnotou klíče nalezenou v tomto stromu def minValueNode(node): current = node # Smyčkou dolů najděte list úplně vlevo, zatímco je aktuální a current.left is not None: current = current.left return current # Funkce, která vymaže klíč a # vrátí nový kořen def deleteNode(root, key): # base Case if root is None: return root # If the key to be delete je # menší než kořenový klíč, # ​​pak leží v levém podstromu if klíč< root.key: root.left = deleteNode(root.left, key) # If the key to be deleted is # greater than the root's key, # then it lies in right subtree elif key>root.key: root.right = deleteNode(root.right, key) # Pokud je klíč stejný jako klíč root, # pak je toto uzel #, který má být odstraněn jinak: # Uzel s pouze jedním potomkem # nebo žádným potomkem pokud root.left je None: temp = root.right root = None return temp elif root.right is None: temp = root.left root = Žádný return temp # Uzel se dvěma potomky: # Získejte následníka pořadí (nejmenší # v pravý podstrom) temp = minValueNode(root.right) # Zkopírujte # obsah následníka pořadí do tohoto uzlu root.key = temp.key # Smažte následníka pořadí root.right = deleteNode(root.right, temp.key) vrátit kořen>

4. Traversal (Inorder traversal of BST) :

V případě binárních vyhledávacích stromů (BST) dává Inorder traversal uzly v neklesajícím pořadí. Nejprve navštěvujeme levé dítě, potom kořen a poté pravé dítě.

Níže je implementace toho, jak provést procházení binárního vyhledávacího stromu podle pořadí:

matice v jazyce c
C++ 
// C++ program to implement // inorder traversal of BST #include  using namespace std; // Given Node node struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return newNode(key);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = vložit(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; } // Funkce pro procházení BST podle pořadí void inorder(struct node* root) { if (root != NULL) { inorder(root->left);  cout<< ' ' << root->klíč;  inorder(kořen->vpravo);  } } // Kód ovladače int main() { /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ struct node* root = NULL;  // Vytvoření kořene BST = insert(root, 50);  insert(kořen, 30);  insert(kořen, 20);  insert(kořen, 40);  insert(kořen, 70);  insert(kořen, 60);  insert(kořen, 80);  // Volání funkce inorder(root);  návrat 0; } // Tento kód přispěl shivanisinghss2110>
C 
// C program to implement // inorder traversal of BST #include  #include  // Given Node node struct node {  int key;  struct node *left, *right; }; // Function to create a new BST node struct node* newNode(int item) {  struct node* temp  = (struct node*)malloc(  sizeof(struct node));  temp->klíč = předmět;  temp->left = temp->right = NULL;  návratová teplota; } // Funkce pro vložení nového uzlu s // daným klíčem v BST struct node* insert(struct node* uzel, klíč int) { // Pokud je strom prázdný, vrátí nový uzel if (node ​​== NULL) return novýUzel(klíč);  // V opačném případě se ve stromu opakujte, pokud (key< node->klíč) { uzel->levý = insert(uzel->levý, klíč);  } else if (klíč> uzel->klíč) { uzel->vpravo = insert(uzel->vpravo, klíč);  } // Vrátí ukazatel na uzel return node; } // Funkce pro procházení BST podle pořadí void inorder(struct node* root) { if (root != NULL) { inorder(root->left);  printf('%d ', root->key);  inorder(kořen->vpravo);  } } // Kód ovladače int main() { /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ struct node* root = NULL;  // Vytvoření kořene BST = insert(root, 50);  insert(kořen, 30);  insert(kořen, 20);  insert(kořen, 40);  insert(kořen, 70);  insert(kořen, 60);  insert(kořen, 80);  // Volání funkce inorder(root);  návrat 0; }>
Jáva 
import java.io.*; // Java program for Inorder Traversal class GFG {  // Given Node node  static class node {  int key;  node left, right;  };  // Function to create a new BST node  static node newNode(int item)  {  node temp = new node();  temp.key = item;  temp.left = temp.right = null;  return temp;  }  // Function to insert a new node with  // given key in BST  static node insert(node node, int key)  {  // If the tree is empty, return a new node  if (node == null)  return newNode(key);  // Otherwise, recur down the tree  if (key < node.key) {  node.left = insert(node.left, key);  }  else if (key>node.key) { node.right = insert(uzel.right, key);  } // Vrátí návratový uzel uzlu;  } // Funkce pro procházení BST static void inorder(node ​​root) { if (root != null) { inorder(root.left);  System.out.print(' ' + root.key);  inorder(root.right);  } } // Kód ovladače public static void main(String[] args) { /* Vytvořme následující BST 50 /  30 70 /  /  20 40 60 80 */ kořen uzlu = null;  // vložení hodnoty 50 root = insert(root, 50);  // vložení hodnoty 30 insert(root, 30);  // vložení hodnoty 20 insert(root, 20);  // vložení hodnoty 40 insert(root, 40);  // vložení hodnoty 70 insert(root, 70);  // vložení hodnoty 60 insert(root, 60);  // vložení hodnoty 80 insert(root, 80);  // vytiskne BST inorder(root);  } } // Tento kód přispěl abhijitjadhav1998>
Python3 
# Python program to implement # inorder traversal of BST # Given Node node class Node: def __init__(self, key): self.key = key self.left = None self.right = None # Function to create a new BST node def newNode(item): temp = Node(item) temp.key = item temp.left = temp.right = None return temp # Function to insert a new node with # given key in BST def insert(node, key): # If the tree is empty, return a new node if node is None: return newNode(key) # Otherwise, recur down the tree if key < node.key: node.left = insert(node.left, key) elif key>node.key: node.right = insert(node.right, key) # Vraťte ukazatel na uzel return node # Funkce pro provedení procházení BST def inorder(root): if root: inorder(root.left) print(root. key, end=' ') inorder(root.right) # Driver Code if __name__ == '__main__': # Vytvořme následující BST # 50 # /  # 30 70 # /  /  # 20 40 60 80 root = Žádný # Vytvoření kořene BST = insert(root, 50) insert(root, 30) insert(root, 20) insert(root, 40) insert(root, 70) insert(root, 60) insert(root , 80) # Volání funkce inorder(root) #Tento kód přispěl japmeet01>
Výstup 
 20 30 40 50 60 70 80>

Časová náročnost: O(N), kde N je počet uzlů BST
Pomocný prostor: O(1)

Aplikace BST:

  • Algoritmy grafů: BST lze použít k implementaci grafových algoritmů, jako jsou algoritmy minimálního spanning tree.
  • Prioritní fronty: BST lze použít k implementaci prioritních front, kde prvek s nejvyšší prioritou je v kořenu stromu a prvky s nižší prioritou jsou uloženy v podstromech.
  • Samovyrovnávací binární vyhledávací strom: BST lze použít jako samovyvažující datové struktury, jako je AVL strom a Červeno-černý strom.
  • Ukládání a získávání dat: BST lze použít k rychlému ukládání a získávání dat, například v databázích, kde lze vyhledávat konkrétní záznam v logaritmickém čase.

výhody:

  • Rychlé vyhledávání: Hledání konkrétní hodnoty v BST má průměrnou časovou složitost O(log n), kde n je počet uzlů ve stromu. To je mnohem rychlejší než hledání prvku v poli nebo propojeném seznamu, které mají v nejhorším případě časovou složitost O(n).
  • Průjezd v pořadí: BST lze procházet v pořadí, které navštíví levý podstrom, kořen a pravý podstrom. To lze použít k třídění datové sady.
  • Prostorově úsporné: BST jsou prostorově úsporné, protože na rozdíl od polí a propojených seznamů neukládají žádné nadbytečné informace.

Nevýhody:

  • Zkosené stromy: Pokud se strom zkosí, časová složitost operací vyhledávání, vkládání a mazání bude O(n) místo O(log n), což může způsobit, že strom bude neefektivní.
  • Další požadovaný čas: Samovyrovnávací stromy vyžadují další čas na udržení rovnováhy během operací vkládání a mazání.
  • Účinnost: BST nejsou efektivní pro datové sady s mnoha duplikáty, protože budou plýtvat místem.

Nejčastější dotazy(Často kladené otázky)ve stromu binárního vyhledávání:

1. Co je binární vyhledávací strom?

Binární vyhledávací strom (BST) je binární strom, kde každý uzel v levém podstromu je menší než kořen a každý uzel v pravém podstromu má hodnotu větší než kořen . Vlastnosti binárního vyhledávacího stromu jsou rekurzivní: pokud považujeme jakýkoli uzel za kořen, tyto vlastnosti zůstanou pravdivé.

2. Co je operace binárního vyhledávacího stromu?

Ve stromu binárního vyhledávání existují tři hlavní operace: 1. Vkládání, 2. Mazání, 3. Vyhledávání. Díky svým vlastnostem je efektivní prohledávat jakýkoli prvek v binárním vyhledávacím stromu.

3. Co je binární vyhledávací strom a strom AVL?

Binární vyhledávací strom : Binární vyhledávací strom (BST) je binární strom, kde každý uzel v levém podstromu je menší než kořen a každý uzel v pravém podstromu má hodnotu větší než kořen.

Strom AVL : Binární vyhledávací stromy (BST), které se samy vyvažují a automaticky rotují, jsou známé jako AVL stromy.

4. Jaká jsou použití binárního vyhledávacího stromu?

Binární vyhledávací stromy lze použít k implementaci abstraktních datových typů jako např dynamické sady, vyhledávací tabulky a prioritní fronty, a používá se v třídicí algoritmy jako je stromový druh.

5. Jaký je rozdíl mezi binárním vyhledávacím stromem a binárním stromem?

Binární vyhledávací strom je strom, který se řídí určitým pořadím pro uspořádání prvků, zatímco binární strom nesleduje žádné pořadí.

Související články:

  • Aplikace BST
  • Aplikace, výhody a nevýhody binárního vyhledávacího stromu
  • Vložení do stromu binárního vyhledávání (BST)
  • Vyhledávání v binárním vyhledávacím stromu (BST)
  • Smazání ve stromu binárního vyhledávání (BST)