// Use any below method to implement Nodes of tree // Method 1: Using 'struct' to make // user-define data type struct node {  int data;  struct node* left;  struct node* right; }; // Method 2: Using 'class' to make // user-define data type class Node { public:  int data;  Node* left;  Node* right; };>

// Structure of each node of the tree struct node {  int data;  struct node* left;  struct node* right; };>

// Class containing left and right child // of current node and key value class Node {  int key;  Node left, right;  public Node(int item)  {  key = item;  left = right = null;  } }>

# A Python class that represents # an individual node in a Binary Tree class Node: def __init__(self, key): self.left = None self.right = None self.val = key>

// Class containing left and right child // of current node and key value class Node {  int key;  Node left, right;  public Node(int item)  {  key = item;  left = right = null;  } }>

>>> 
Tipuri de arbore binar
Arborele binar poate fi clasificat în mai multe tipuri pe baza mai multor factori:
 
    Pe baza numărului de copii    
 Arborele binar complet 
 Arborele binar degenerat 
 Arbori binari deformați 
    Pe baza Finalizării Nivelurilor    
  Arborele binar complet  
 Arborele binar perfect 
  Arborele binar echilibrat  
    Pe baza valorilor nodurilor:    
 Arborele de căutare binar 
  Arborele AVL  
  Arborele Roșu Negru  
  B Arborele  
  B+ Arborele  
 Arborele de segmente 
    Operații pe arbore binar    
1. Inserarea în Arbore Binar
Putem insera un nod oriunde într-un arbore binar inserând nodul ca copil stânga sau dreapta al oricărui nod sau făcând nodul ca rădăcină a arborelui.
powershell mai mare sau egal
 
    Algoritm pentru inserarea unui nod într-un arbore binar:    
 
Verificați dacă există un nod în arborele binar, care are copilul stânga lipsă. Dacă un astfel de nod există, atunci introduceți noul nod ca fiul său stâng.
Verificați dacă există un nod în arborele binar, care are copilul drept lipsă. Dacă un astfel de nod există, atunci introduceți noul nod ca fiul său drept.
Dacă nu găsim niciun nod cu copilul stânga sau dreapta lipsă, atunci găsim nodul care are ambii copii lipsă și introduceți nodul ca copil stâng sau drept.
2. Traversarea arborelui binar
Traversarea arborelui binar implică vizitarea tuturor nodurilor arborelui binar. Algoritmii Tree Traversal pot fi clasificați pe scară largă în două categorii:
 
Algoritmi de căutare în profunzime (DFS).
Algoritmi de căutare pe lățime (BFS).
Algoritmi de căutare în profunzime (DFS):
      Precomandă Traversal (actual-stânga-dreapta):       Vizitați nodul curent înainte de a vizita orice nod din subarborele din stânga sau din dreapta. Aici, traversarea este rădăcină – copil stâng – copil drept. Înseamnă că nodul rădăcină este parcurs mai întâi apoi fiul său stâng și în sfârșit copilul drept.
      Traversare în ordine (stânga-curent-dreapta):              Vizitați nodul curent după ce ați vizitat toate nodurile din subarborele din stânga, dar înainte de a vizita orice nod din subarborele din dreapta. Aici, traversarea este copil stâng – rădăcină – copil drept. Înseamnă că copilul din stânga este parcurs mai întâi apoi nodul său rădăcină și în final copilul din dreapta.
      Traversare postcomandă (stânga-dreapta-curent):      Vizitați nodul curent după ce ați vizitat toate nodurile subarborilor din stânga și din dreapta.         Aici, traversarea este copil stâng – copil drept – rădăcină. Înseamnă că copilul din stânga a parcurs mai întâi copilul din dreapta și în final nodul său rădăcină.
Algoritmi Breadth-First Search (BFS):
      Traversarea comenzii la nivel:              Vizitați nodurile nivel cu nivel și de la stânga la dreapta la același nivel. Aici, traversarea este la nivel. Înseamnă că primul copil din stânga a parcurs și apoi ceilalți copii de același nivel de la stânga la dreapta au traversat.
3. Ștergerea în arbore binar
Putem șterge orice nod din arborele binar și rearanja nodurile după ștergere pentru a forma din nou un arbore binar valid.
 
    Algoritm pentru ștergerea unui nod dintr-un arbore binar:    
 
Începând de la rădăcină, găsiți cel mai adânc și cel mai din dreapta nod din arborele binar și nodul pe care vrem să-l ștergem.
Înlocuiți datele nodului cel mai adânc din dreapta cu nodul care trebuie șters.
Apoi ștergeți nodul cel mai adânc din dreapta.
4. Căutarea în arbore binar
Putem căuta un element în nod utilizând oricare dintre tehnicile de traversare.
 
    Algoritm pentru căutarea unui nod într-un arbore binar:    
 
Începeți de la nodul rădăcină.
Verificați dacă valoarea nodului curent este egală cu valoarea țintă.
Dacă valoarea nodului curent este egală cu valoarea țintă, atunci acest nod este nodul necesar.
În caz contrar, dacă valoarea nodului nu este egală cu valoarea țintă, începeți căutarea în copilul din stânga și din dreapta.
Dacă nu găsim niciun nod a cărui valoare să fie egală cu țintă, atunci valoarea nu este prezentă în arbore.
    Operații auxiliare pe arbore binar    
  Aflarea înălțimii copacului  
 Găsiți nivelul unui nod într-un arbore binar 
 Găsirea dimensiunii întregului copac 
Implementarea arborelui binar
Mai jos este codul pentru inserarea, ștergerea și parcurgerea arborelui binar:
Cdata);  inorderTraversal(rădăcină->dreapta); } // Precomandă traversarea arborelui (Rădăcină - Stânga - Dreapta) void preorderTraversal(Nod* root) { if (!root) return;  printf('%d', root->data);  precomandăTraversal(rădăcină->stânga);  precomandăTraversal(rădăcină->dreapta); } // Parcurgerea arborelui postorder (Stânga - Dreapta - Rădăcină) void postorderTraversal(Nod* root) { if (root == NULL) return;  postorderTraversal(rădăcină->stânga);  postorderTraversal(rădăcină->dreapta);  printf('%d', root->data); } // Funcție pentru traversarea arborelui de ordine de nivel void levelorderTraversal(Nod* root) { if (root == NULL) return;  // Coadă pentru parcurgerea ordinii de nivel Node* coadă[100];  int fata = 0, spate = 0;  coada[spate++] = root;  while (față != spate) { Node* temp = coadă[față++];  printf('%d', temp->date);  // Împinge copilul stâng în coadă dacă (temp->left) queue[rear++] = temp->left;  // Împinge copilul drept în coadă dacă (temp->right) queue[rear++] = temp->right;  } } /* Funcția driver pentru a verifica algoritmul de mai sus. */ int main() { Node* root = NULL;  // Inserarea nodurilor root = insert(root, 10);  rădăcină = insert (rădăcină, 20);  rădăcină = insert(rădăcină, 30);  rădăcină = insert (rădăcină, 40);  printf('Precomandă traversare: ');  precomandăTraversal(rădăcină);  printf('
Parcurgere în ordine: ');  inorderTraversal(rădăcină);  printf('
Postorder parcurs: ');  postorderTraversal(rădăcină);  printf('
Parcurgere a ordinii de nivel: ');  levelorderTraversal(rădăcină);  // Sterge nodul cu date = 20 root = deletion(root, 20);  printf('
În ordinea traversării după ștergere: ');  inorderTraversal(rădăcină);  întoarce 0; }>>>Javaq = noua Lista Linked();  q.oferă(rădăcină);  while (!q.isEmpty()) { Node temp = q.poll();  System.out.print(temp.date + ' ');  // Împinge copilul stâng în coadă dacă (temp.left != null) q.offer(temp.left);  // Împinge copilul drept în coadă dacă (temp.right != null) q.offer(temp.right);  } } /* Funcția driver pentru a verifica algoritmul de mai sus. */ public static void main(String[] args) { Node root = null;  // Inserarea nodurilor root = insert(root, 10);  rădăcină = insert (rădăcină, 20);  rădăcină = insert(rădăcină, 30);  rădăcină = insert (rădăcină, 40);  System.out.print('Precomandă traversare: ');  precomandăTraversal(rădăcină);  System.out.print('
Parcurgere în ordine: ');  inorderTraversal(rădăcină);  System.out.print('
Postorder parcurs: ');  postorderTraversal(rădăcină);  System.out.print('
Parcurgere a ordinii de nivel: ');  levelorderTraversal(rădăcină);  // Sterge nodul cu date = 20 root = deletion(root, 20);  System.out.print('
Parcurgere în ordine după ștergere: ');  inorderTraversal(rădăcină);  } }>>>Piton

using System; using System.Collections.Generic; // Node class to define the structure of the node public class Node {  public int data;  public Node left, right;  // Parameterized Constructor  public Node(int val)  {  data = val;  left = right = null;  } } public class Program {  // Function to insert nodes  public static Node Insert(Node root, int data)  {  // If tree is empty, new node becomes the root  if (root == null)  {  root = new Node(data);  return root;  }  // Queue to traverse the tree and find the position to insert the node  Queueq = coadă nouă();  q.Enqueue(rădăcină);  while (q.Count != 0) { Node temp = q.Dequeue();  // Inserează nodul ca fiul stâng al nodului părinte if (temp.left == null) { temp.left = new Node(data);  pauză;  } // Dacă copilul din stânga nu este nul, împingeți-l în coadă altfel q.Enqueue(temp.left);  // Inserează nodul ca fiul drept al nodului părinte if (temp.right == null) { temp.right = new Node(data);  pauză;  } // Dacă copilul drept nu este nul, împingeți-l în coadă altfel q.Enqueue(temp.right);  } returnează rădăcină;  } /* funcție pentru a șterge cel mai adânc nod dat (d_node) în arborele binar */ public static void DeleteDeepest(Node root, Node d_node) { Coadăq = coadă nouă();  q.Enqueue(rădăcină);  // Efectuați traversarea ordinii de nivel până la ultimul nod Node temp;  while (q.Count != 0) { temp = q.Dequeue();  if (temp == d_node) { temp = null;  d_node = nul;  întoarcere;  } if (temp.right != null) { if (temp.right == d_node) { temp.right = null;  d_node = nul;  întoarcere;  } else q.Enqueue(temp.right);  } if (temp.left != null) { if (temp.left == d_node) { temp.left = null;  d_node = nul;  întoarcere;  } else q.Enqueue(temp.left);  } } } /* funcție de ștergere a elementului din arborele binar */ public static Node Deletion(Rădăcină nod, cheie int) { if (rădăcină == null) returnează nul;  if (root.left == null && root.right == null) { if (root.data == cheie) return null;  altfel returnează rădăcină;  } Coadăq = coadă nouă();  q.Pune în coadă (rădăcină);  Node temp = new Node(0);  Nod key_node = null;  // Efectuați traversarea ordinii de nivel pentru a găsi cel mai adânc nod (temp) și nodul de șters (key_node) în timp ce (q.Count != 0) { temp = q.Dequeue();  if (temp.data == cheie) key_node = temp;  if (temp.left != null) q.Enqueue(temp.left);  if (temp.right != null) q.Enqueue(temp.right);  } if (key_node != null) { int x = temp.data;  key_node.data = x;  DeleteDeepest (rădăcină, temp);  } returnează rădăcină;  } // În ordinea traversării arborelui (Stânga - Rădăcină - Dreapta) public static void InorderTraversal(Rădăcină nod) { if (rădăcină == null) return;  InorderTraversal(root.left);  Console.Write(root.data + ' ');  InorderTraversal(root.right);  } // Precomandă traversarea arborelui (Rădăcină - Stânga - Dreapta) public static void PreorderTraversal(Rădăcină nod) { if (rădăcină == null) return;  Console.Write(root.data + ' ');  PrecomandaTraversal(root.left);  PrecomandaTraversal(root.right);  } // Parcursul arborelui postorder (Stânga - Dreapta - Rădăcină) public static void PostorderTraversal(Rădăcină nod) { if (rădăcină == null) return;  PostorderTraversal(root.left);  PostorderTraversal(root.right);  Console.Write(root.data + ' ');  } // Funcție pentru traversarea arborelui de ordine de nivel public static void LevellorderTraversal(Rădăcină nod) { if (rădăcină == null) return;  // Coadă pentru parcurgerea ordinii de nivel Coadăq = coadă nouă();  q.Enqueue(rădăcină);  while (q.Count != 0) { Node temp = q.Dequeue();  Console.Write(temp.data + ' ');  // Împinge copilul stâng în coadă dacă (temp.left != null) q.Enqueue(temp.left);  // Împinge copilul drept în coadă dacă (temp.right != null) q.Enqueue(temp.right);  } } /* Funcția driver pentru a verifica algoritmul de mai sus. */ public static void Main(string[] args) { Node root = null;  // Inserarea nodurilor root = Insert(root, 10);  rădăcină = Insert(rădăcină, 20);  rădăcină = Insert(rădăcină, 30);  rădăcină = Insert(rădăcină, 40);  Console.Write('Precomandă traversare: ');  PrecomandăTraversal(rădăcină);  Console.Write('
Parcurgere în ordine: ');  InorderTraversal(rădăcină);  Console.Write('
Postorder traversal: ');  PostorderTraversal(rădăcină);  Console.Write('
Parcurgere a ordinii de nivel: ');  LevelorTraversal(rădăcină);  // Sterge nodul cu date = 20 root = Deletion(root, 20);  Console.Write('
Parcurgere în ordine după ștergere: ');  InorderTraversal(rădăcină);  } }>>>Javascript

#include  using namespace std; // Node class to define the structure of the node class Node { public:  int data;  Node *left, *right;  // Parameterized Constructor  Node(int val)  {  data = val;  left = right = NULL;  } }; // Function to insert nodes Node* insert(Node* root, int data) {  // If tree is empty, new node becomes the root  if (root == NULL) {  root = new Node(data);  return root;  }  // queue to traverse the tree and find the position to  // insert the node  queueq;  q.push(rădăcină);  while (!q.empty()) { Node* temp = q.front();  q.pop();  // Inserează nodul ca fiul stâng al nodului părinte if (temp->left == NULL) { temp->left = new Node(data);  pauză;  } // Dacă copilul din stânga nu este nul, împingeți-l în // coadă else q.push(temp->left);  // Inserează nodul ca fiul drept al nodului părinte if (temp->right == NULL) { temp->right = new Node(data);  pauză;  } // Dacă copilul potrivit nu este nul, împingeți-l în // coadă else q.push(temp->right);  } returnează rădăcină; } /* funcție pentru a șterge cel mai adânc nod dat (d_node) din arborele binar */ void deletDeepest(Node* rădăcină, Node* d_node) { coadaq;  q.push(rădăcină);  // Efectuați traversarea ordinii de nivel până la ultimul nod Node* temp;  while (!q.empty()) { temp = q.front();  q.pop();  if (temp == d_node) { temp = NULL;  șterge (d_node);  întoarcere;  } if (temp->right) { if (temp->right == d_node) { temp->right = NULL;  șterge (d_node);  întoarcere;  } else q.push(temp->right);  } if (temp->left) { if (temp->left == d_node) { temp->left = NULL;  șterge (d_node);  întoarcere;  } else q.push(temp->left);  } } } /* Funcție de ștergere a elementului din arborele binar */ Nod* deletion(Nod* root, int key) { if (!root) return NULL;  if (rădăcină->stânga == NULL && rădăcină->dreapta == NULL) { dacă (rădăcină->date == cheie) returnează NULL;  altfel returnează rădăcină;  } coadăq;  q.push(rădăcină);  Nod* temp;  Nod* key_node = NULL;  // Efectuați traversarea ordinii de nivel pentru a găsi cea mai profundă // nodul(temp) și nodul de șters (key_node) în timp ce (!q.empty()) { temp = q.front();  q.pop();  if (temp->data == cheie) key_node = temp;  if (temp->left) q.push(temp->left);  if (temp->right) q.push(temp->right);  } if (key_node != NULL) { int x = temp->data;  key_node->data = x;  deletDeepest (rădăcină, temp);  } returnează rădăcină; } // În ordinea traversării arborelui (Stânga - Rădăcină - Dreapta) void inorderTraversal(Nod* rădăcină) { if (!rădăcină) return;  inorderTraversal(rădăcină->stânga);  cout<< root->date<< ' ';  inorderTraversal(root->dreapta); } // Precomandă traversarea arborelui (Rădăcină - Stânga - Dreapta) void preorderTraversal(Nod* root) { if (!root) return;  cout<< root->date<< ' ';  preorderTraversal(root->stânga);  precomandăTraversal(rădăcină->dreapta); } // Parcurgerea arborelui postorder (Stânga - Dreapta - Rădăcină) void postorderTraversal(Nod* root) { if (root == NULL) return;  postorderTraversal(rădăcină->stânga);  postorderTraversal(rădăcină->dreapta);  cout<< root->date<< ' '; } // Function for Level order tree traversal void levelorderTraversal(Node* root) {  if (root == NULL)  return;  // Queue for level order traversal  queueq;  q.push(rădăcină);  while (!q.empty()) { Node* temp = q.front();  q.pop();  cout<< temp->date<< ' ';  // Push left child in the queue  if (temp->stânga) q.push(temp->stânga);  // Push child right in coada if (temp->right) q.push(temp->right);  } } /* Funcția driver pentru a verifica algoritmul de mai sus. */ int main() { Node* root = NULL;  // Inserarea nodurilor root = insert(root, 10);  rădăcină = insert (rădăcină, 20);  rădăcină = insert(rădăcină, 30);  rădăcină = insert (rădăcină, 40);  cout<< 'Preorder traversal: ';  preorderTraversal(root);  cout << '
Inorder traversal: ';  inorderTraversal(root);  cout << '
Postorder traversal: ';  postorderTraversal(root);  cout << '
Level order traversal: ';  levelorderTraversal(root);  // Delete the node with data = 20  root = deletion(root, 20);  cout << '
Inorder traversal after deletion: ';  inorderTraversal(root); }>