// 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->clau = element;  temp->esquerra = temp->dreta = NULL;  temperatura de retorn; } // Una funció d'utilitat per inserir // un nou node amb una clau donada a BST struct node* insert(struct node* node, int key) { // Si l'arbre està buit, retorna un nou node si (node ​​== NULL ) retorna nouNode(clau);  // En cas contrari, torneu a baixar per l'arbre si (clau< node->clau) node->esquerra = inserir (node->esquerra, clau);  else if (clau> node->clau) node->dreta = inserir (node->dreta, clau);  // Retorna el node de retorn del punter del node (no canviat); } // Funció d'utilitat per cercar una clau en un node d'estructura BST* cerca (node ​​d'estructura* arrel, clau int) arrel->clau == clau) arrel de retorn;  // La clau és més gran que la clau de root si (root->key< key)  return search(root->dreta, clau);  // La clau és més petita que la clau de l'arrel retorna la cerca (arrel->esquerra, clau);>>>Cclau) node->esquerra = inserir (node->esquerra, clau);  else if (clau> node->clau) node->dreta = inserir (node->dreta, clau);  // Retorna el node de retorn del punter del node (no canviat); } // Funció d'utilitat per cercar una clau en un node d'estructura BST* cerca (node ​​d'estructura* arrel, clau int)>

// 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 = inserir (node.right, clau);  // Retorna el node de retorn del punter del node (no canviat);  } // Funció d'utilitat per cercar una clau en una cerca de nodes BST (arrel de nodes, clau int) // Casos bàsics: l'arrel és nul o la clau està present a l'arrel si (arrel == nul>

# 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) # Retorna el node de retorn del punter del node (no canviat) # Funció d'utilitat per cercar una clau en una cerca definida BST (arrel, clau): # Casos bàsics: root és null o la clau està present a l'arrel si l'arrel és Cap o root.key == clau: retornar l'arrel # La clau és més gran que la clau d'arrel si root.key< key: return search(root.right, key) # Key is smaller than root's key return search(root.left, key)>

// 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 = inserir (node.right, clau); } // Retorna el node de retorn del punter del node (no canviat); } // Funció d'utilitat per cercar una clau en una funció BST cerca (arrel, clau) { // Casos bàsics: l'arrel és nul·la o la clau està present a l'arrel si (arrel === nul || root.key === clau ) { retornar arrel; } // La clau és més gran que la clau de root si (root.key< key) {  return search(root.right, key); } // Key is smaller than root's key return search(root.left, key); }>

// 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->clau = element;  temp->esquerra = temp->dreta = NULL;  temperatura de retorn; } // Funció per inserir un nou node amb // la clau donada al node de l'estructura BST* insert(struct node* node, int key) { // Si l'arbre està buit, retorna un nou node si (node ​​== NULL) retorn nouNode(clau);  // En cas contrari, torneu a baixar per l'arbre si (clau< node->clau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; }>>>Cclau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; }>>>Javanode.key: node.right = inserir (node.right, clau) # Retorna el punter de node retorn node>

// 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 = inserir (node.right, clau);  } // Retorna el node de retorn del punter del node; }>>> 
    Complexitat temporal:    O(N), on N és el nombre de nodes de la BST  
    Espai auxiliar:    O(1)
 
    3.          Suprimeix un node de BST     :
S'utilitza per eliminar un node amb una clau específica del BST i retornar el nou BST.
 
Diferents escenaris per eliminar el node:
 
    El node que s'ha de suprimir és el node fulla       :    
És senzill que només ho pots anul·lar.
  
    El node que s'ha de suprimir té un fill       :     
Només podeu substituir el node pel node fill.
  
    El node que s'ha de suprimir té dos fills       :     
Aquí ho hem de fer    eliminar el node és de tal manera que l'arbre resultant segueix les propietats d'un BST.    El truc és trobar el successor en ordre del node. Copieu el contingut del successor de l'ordre al node i suprimiu el successor de l'ordre.
  
Tingueu cura de les coses següents mentre suprimiu un node d'un BST:
 
Cal esbrinar quin serà el reemplaçament del node que s'eliminarà.
Voleu una interrupció mínima a l'estructura de l'arbre existent
Pot prendre el node de substitució del subarbre esquerre o dret dels nodes suprimits.
Si prenem if del subarbre esquerre, hem de prendre el valor més gran del subarbre esquerre.
Si prenem if del subarbre dret, hem de prendre el valor més petit del subarbre dret.
    Codi:    
 
A continuació es mostra la implementació de la supressió a BST:
C++clau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; } // Funció que retorna el node amb // el valor de clau mínim que es troba en aquest node d'estructura d'arbre* minValueNode(struct node* node) { struct node* current = node;  // Fes un bucle cap avall per trobar la fulla més a l'esquerra while (actual && actual->esquerra != NULL) corrent = actual->esquerra;  corrent de retorn; } // Funció que elimina la clau i // retorna el nou node d'estructura arrel* deleteNode(node ​​de estructura* arrel, clau int) { // majúscules i minúscules si (arrel == NULL) retorna arrel;  // Si la clau a suprimir és // més petita que la clau de l'arrel, // es troba al subarbre esquerre si (clau< root->clau) { arrel->esquerra = deleteNode (arrel->esquerra, clau);  } // Si la clau que s'ha d'esborrar és // més gran que la clau de l'arrel, // es troba al subarbre dret, sinó si (clau> arrel->clau) { arrel->right = deleteNode (arrel-> dreta, clau);  } // Si la clau és la mateixa que la clau de l'arrel, // llavors aquest és el node // que s'ha d'eliminar sinó { // Node amb només un fill // o cap fill si (arrel->esquerra == NULL) { struct node* temp = arrel->dreta;  lliure (arrel);  temperatura de retorn;  } else if (arrel->dreta == NULL) { struct node* temp = arrel->esquerra;  lliure (arrel);  temperatura de retorn;  } // Node amb dos fills: // Obteniu el successor de l'ordre (més petit // al subarbre dret) struct node* temp = minValueNode (arrel->dreta);  // Copieu el // contingut del successor de l'ordre a aquest node root->key = temp->key;  // Esborra el successor de l'ordre arrel->right = deleteNode (arrel->dreta, temp->clau);  } retornar l'arrel; }>>>Cclau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; } // Funció que retorna el node amb // el valor de clau mínim que es troba en aquest node d'estructura d'arbre* minValueNode(struct node* node) { struct node* current = node;  // Fes un bucle cap avall per trobar la fulla més a l'esquerra while (actual && actual->esquerra != NULL) corrent = actual->esquerra;  corrent de retorn; } // Funció que elimina la clau i // retorna el nou node d'estructura arrel* deleteNode(node ​​de estructura* arrel, clau int) { // majúscules i minúscules si (arrel == NULL) retorna arrel;  // Si la clau a suprimir és // més petita que la clau de l'arrel, // es troba al subarbre esquerre si (clau< root->clau) { arrel->esquerra = deleteNode (arrel->esquerra, clau);  } // Si la clau que s'ha d'esborrar és // més gran que la clau de l'arrel, // es troba al subarbre dret, sinó si (clau> arrel->clau) { arrel->right = deleteNode (arrel-> dreta, clau);  } // Si la clau és la mateixa que la clau de l'arrel, // llavors aquest és el node // que s'ha d'eliminar sinó { // Node amb només un fill // o cap fill si (arrel->esquerra == NULL) { struct node* temp = arrel->dreta;  lliure (arrel);  temperatura de retorn;  } else if (arrel->dreta == NULL) { struct node* temp = arrel->esquerra;  lliure (arrel);  temperatura de retorn;  } // Node amb dos fills: // Obteniu el successor de l'ordre (més petit // al subarbre dret) struct node* temp = minValueNode (arrel->dreta);  // Copieu el // contingut del successor de l'ordre a aquest node root->key = temp->key;  // Esborra el successor de l'ordre arrel->right = deleteNode (arrel->dreta, temp->clau);  } retornar l'arrel; }>>>Javaroot.key) { root.right = deleteNode (root.right, clau);  { node temp = root.right;  temperatura de retorn;  } else if (root.right == null) { node temp = root.left;  temperatura de retorn;  } // Node amb dos fills: // Obteniu el successor de l'ordre (més petit // al subarbre dret) node temp = minValueNode(root.right);  // Copieu el // contingut del successor de l'ordre en aquest node root.key = temp.key;  // Esborra el successor de l'ordre root.right = deleteNode(root.right, temp.key);  } retornar l'arrel;  }>>>Pythonroot.key: root.right = deleteNode(root.right, key) # Si la clau és la mateixa que la clau de root, # llavors aquest és el node # que s'ha d'esborrar sinó: # Node amb només un fill # o cap fill si root.left és Cap: temp = root.right arrel = Cap retorn temp elif root.right és Cap: temp = root.left arrel = Cap retorn temp # Node amb dos fills: # Obteniu el successor de l'ordre (# més petit del subarbre dret) temp = minValueNode(root.right) # Copieu el # contingut del successor de l'ordre en aquest node root.key = temp.key # Suprimeix el successor de l'ordre root.right = deleteNode (root.right, temp.key) retornar arrel>>> 
    4.         Travessia (travessament en ordre de BST)         :    
En el cas dels arbres de cerca binaris (BST), el recorregut Inorder dóna nodes en ordre no decreixent. Visitem primer el nen esquerre, després l'arrel i després el nen dret.
 
A continuació es mostra la implementació de com fer un recorregut en ordre d'un arbre de cerca binari:
C++clau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; } // Funció per fer el recorregut en ordre de BST void inorder(struct node* root) { if (root != NULL) { inorder(root->left);  cout<< ' ' << root->clau;  inordre(arrel->dreta);  } } // Codi del controlador int main() { /* Creem el següent BST 50 /  30 70 /  /  20 40 60 80 */ struct node* root = NULL;  // Creant l'arrel BST = insert(arrel, 50);  inserir (arrel, 30);  inserir (arrel, 20);  inserir (arrel, 40);  inserir (arrel, 70);  inserir (arrel, 60);  inserir (arrel, 80);  // Crida a la funció inorder(arrel);  retorn 0; } // Aquest codi és aportat per shivanisinghss2110>>>Cclau) { node->esquerra = inserir (node->esquerra, clau);  } else if (clau> node->clau) { node->dreta = inserir (node->dreta, clau);  } // Retorna el node de retorn del punter del node; } // Funció per fer el recorregut en ordre de BST void inorder(struct node* root) { if (root != NULL) { inorder(root->left);  printf('%d', arrel->clau);  inordre(arrel->dreta);  } } // Codi del controlador int main() { /* Creem el següent BST 50 /  30 70 /  /  20 40 60 80 */ struct node* root = NULL;  // Creant l'arrel BST = insert(arrel, 50);  inserir (arrel, 30);  inserir (arrel, 20);  inserir (arrel, 40);  inserir (arrel, 70);  inserir (arrel, 60);  inserir (arrel, 80);  // Crida a la funció inorder(arrel);  retorn 0; }>>>Java>Python 3>>  
  Sortida      Complexitat temporal:    O(N), on N és el nombre de nodes de la BST  
    Espai auxiliar:    O(1)
 
    Aplicacions de BST:    
    Algorismes gràfics:    Els BST es poden utilitzar per implementar algorismes de gràfics, com ara algorismes d'arbre d'abast mínim.
    Cues de prioritat:    Els BST es poden utilitzar per implementar cues de prioritat, on l'element amb la prioritat més alta es troba a l'arrel de l'arbre i els elements amb prioritat més baixa s'emmagatzemen als subarbres.
    Arbre de cerca binari d'autoequilibri:    Els BST es poden utilitzar com a estructures de dades d'autoequilibri, com ara l'arbre AVL i l'arbre vermell-negre.
    Emmagatzematge i recuperació de dades:    Els BST es poden utilitzar per emmagatzemar i recuperar dades ràpidament, com ara les bases de dades, on la cerca d'un registre específic es pot fer en temps logarítmic.
    Avantatges:    
    Cerca ràpida:    La cerca d'un valor específic en un BST té una complexitat temporal mitjana de O(log n), on n és el nombre de nodes de l'arbre. Això és molt més ràpid que cercar un element en una matriu o llista enllaçada, que en el pitjor dels casos tenen una complexitat temporal de O(n).
    Travessa en ordre:    Els BST es poden recórrer en ordre, que visita el subarbre esquerre, l'arrel i el subarbre dret. Això es pot utilitzar per ordenar un conjunt de dades.
    Espai eficient:    Els BST són eficients en l'espai, ja que no emmagatzemen cap informació redundant, a diferència de les matrius i les llistes enllaçades.
    Desavantatges:    
    Arbres esbiaixats:    Si un arbre es desvia, la complexitat temporal de les operacions de cerca, inserció i supressió serà O(n) en lloc d'O(log n), cosa que pot fer que l'arbre sigui ineficient.
    Temps addicional necessari:    Els arbres d'autoequilibri requereixen temps addicional per mantenir l'equilibri durant les operacions d'inserció i supressió.
    Eficiència:    Els BST no són eficients per a conjunts de dades amb molts duplicats, ja que perdran espai.
Preguntes freqüents(Preguntes freqüents)a l'arbre de cerca binari:
    1. Què és un arbre de cerca binari?    
 
Un arbre de cerca binari (BST) és    un arbre binari on cada node del subarbre esquerre és menor que l'arrel i cada node del subarbre dret té un valor més gran que l'arrel.    . Les propietats d'un arbre de cerca binari són recursives: si considerem qualsevol node com a arrel, aquestes propietats continuaran sent certes.
 
2. Què és l'operació de l'arbre de cerca binària?
 
Hi ha tres operacions principals a l'arbre de cerca binari:    1. Inserció, 2. Supressió, 3. Cerca.    A causa de les seves propietats, és eficient cercar qualsevol element a l'arbre de cerca binari.
 
3. Què és l'arbre de cerca binari i l'arbre AVL?
 
    Arbre de cerca binari       :    Un arbre de cerca binari (BST) és un arbre binari on cada node del subarbre esquerre és menor que l'arrel i cada node del subarbre dret té un valor més gran que l'arrel.
disseny de quadrícula
 
    Arbre AVL       :    Els arbres de cerca binaris (BST) que s'autoequilibren i giren automàticament es coneixen com a arbres AVL.
 
4. Quins són els usos de l'arbre de cerca binari?
 
Els arbres de cerca binaris es poden utilitzar per implementar tipus de dades abstractes com ara    conjunts dinàmics, taules de cerca i cues de prioritats,    i utilitzat en    algorismes d'ordenació    com ara la classificació d'arbres.
 
5. Quina diferència hi ha entre l'arbre de cerca binari i l'arbre binari?
 
Un arbre de cerca binari és un arbre que segueix algun ordre per organitzar els elements, mentre que l'arbre binari no segueix cap ordre.
 
    Articles relacionats:    
 
     Aplicació del BST     
     Aplicacions, avantatges i desavantatges de l'arbre de cerca binari     
     Inserció a l'arbre de cerca binari (BST)     
     Cercar a l'arbre de cerca binari (BST)     
     Supressió a l'arbre de cerca binari (BST)