Types d'arbres binaires - Geeksforgeeks (2024)

Nous avons discutéIntroduction à l'arbre binaire dans l'ensemble 1et lePropriétés de l'arbre binaire dans l'ensemble 2.Dans cet article, des types communs d'arbres binaires sont discutés.

Types d'arbres binaires basés sur le nombre d'enfants:

Voici les types d'arbres binaires basés sur le nombre d'enfants:

  1. Arbre binaire complet
  2. Arbre binaire dégénéré
  3. Arbres binaires asymétriques

1. arbre binaire complet

Un arbre binaire est un arbre binaire complet si chaque nœud a 0 ou 2 enfants.Voici des exemples d'un arbre binaire complet.Nous pouvons également dire qu'un arbre binaire complet est un arbre binaire dans lequel tous les nœuds sauf les nœuds de feuilles ont deux enfants.

Un arbre binaire complet est un type spécial d'arbre binaire dans lequel chaque nœud parent / nœud interne a deux ou pas d'enfants.Il est également connu comme un arbre binaire approprié.

Types of Binary Tree - GeeksforGeeks (1)

Arbre binaire complet

Programme pour mettre en œuvre un arbre binaire complet

C ++

#include

classe Node {

publique:

int valeur;

Node * gauche;

Nœud * à droite;

Nœud(int val): valeur (val), gauche (null), droit (null) {}

};

classe FullbinaryTree {

publique:

Node * root;

FullbinaryTree (): root (null) {}

vide insérer(int valeur) {

Node * new_node =nouveau Nœud (valeur);

si (!racine) {

root = new_node;

}autre {

Node * current_node = root;

alors que (vrai) {

si (! current_node-> gauche) {

current_node-> Left = new_node;

casser;

}autre si (! current_node-> à droite) {

current_node-> right = new_node;

casser;

}autre {

current_node = current_node-> gauche;

}

}

}

}

};

int principal() {

Arbre completbinarytree;

arbre.insert (1);

arbre.insert (2);

arbre.insert (3);

arbre.insert (4);

retour 0;

}

Java
// Programme Java pour l'approche ci-dessus
classe Node {
publique int valeur;
publique Nœud à gauche;
publique Node à droite;
publique Nœud(int val) {
valeur = val;
gauche =nul;
à droite =nul;
}
}
classe FullbinaryTree {
publique Racine de nœud;
publique FullbinaryTree () {
racine =nul;
}
publique vide insérer(int valeur) {
Node new_node =nouveau Nœud (valeur);
si (root ==nul) {
root = new_node;
}autre {
Nœud current_node = root;
alors que (vrai) {
si (current_node.left ==nul) {
current_node.left = new_node;
casser;
}autre si (current_node.right ==nul) {
current_node.right = new_node;
casser;
}autre {
current_node = current_node.left;
}
}
}
}
}
classe Principal {
publique statique vide main (String [] args) {
Arbre FullbinaryTree =nouveau FullbinaryTree ();
Tree.insert (1));
Tree.insert (2));
Tree.insert (3));
Tree.insert (4));
}
}
// Ce code est apporté par CodeBraxnzt
Python3
# Classe de nœuds représentant un nœud dans un arbre binaire
classe Nœud:
def __init __ (soi, Val):
soi.valeur= val
soi.gauche= Aucun
soi.droite= Aucun
# Classe FullbinaryTree représentant un arbre binaire complet
classe FullbinaryTree:
def __init __ (soi):
soi.racine= Aucun
# Méthode pour insérer un nouveau nœud avec la valeur donnée dans l'arbre
def insérer(soi, valeur):
newnode= Node (valeur)
si pas soi.racine:
soi.racine= newnode
autre:
NODE COURT= soi.racine
alors que Vrai:
si pas currentNode.left:
currentnode.left= newnode
casser
Elif pas currentNode.Right:
currentNode.Right= newnode
casser
autre:
See Also
5 types d'arbres binaires expliqués [avec illustrations] | blog upGrad
NODE COURT= currentnode.left
# Fonction principale
arbre= FullbinaryTree ()
Tree.insert (1)
Tree.insert (2)
Tree.insert (3)
Tree.insert (4)
C #
en utilisant Système;
// classe de nœuds représentant un nœud dans un arbre binaire
publique classe Node {
publique int valeur;
publique Nœud à gauche;
publique Node à droite;
publique Nœud(int val)
{
valeur = val;
gauche =nul;
à droite =nul;
}
}
// classe FullbinaryTree représentant un arbre binaire complet
publique classe FullbinaryTree {
publique Racine de nœud;
// Méthode pour insérer un nouveau nœud avec la valeur donnée dans
// l'arbre
publique vide Insérer(int valeur)
{
Node newNode =nouveau Nœud (valeur);
si (root ==nul) {
root = newNode;
}
autre {
Nœud currentNode = root;
alors que (vrai) {
si (currentNode.left ==nul) {
currentNode.Left = newNode;
casser;
}
autre si (currentNode.Right ==nul) {
currentNode.Right = newNode;
casser;
}
autre {
currentNode = currentNode.Left;
}
}
}
}
}
// Fonction principale
classe Programme {
statique vide Principal(chaîne[] args)
{
Arbre FullbinaryTree =nouveau FullbinaryTree ();
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
}
}
Javascrip
// classe de nœuds représentant un nœud dans un arbre binaire
classe node {
constructeur (val) {
ce.Value = Val;
ce.left =nul;
ce.Right =nul;
}
}
// classe FullbinaryTree représentant un arbre binaire complet
classe fullbinarytree {
constructeur () {
ce.Root =nul;
}
// Méthode pour insérer un nouveau nœud avec la valeur donnée dans l'arbre
insérer (valeur) {
const newNode =nouveau Nœud (valeur);
si (!ce.racine) {
ce.root = newNode;
}autre {
Laissez currentNode =ce.racine;
alors que (vrai) {
si (! currentNode.left) {
currentNode.Left = newNode;
casser;
}autre si (! currentNode.Right) {
currentNode.Right = newNode;
casser;
}autre {
currentNode = currentNode.Left;
}
}
}
}
}
// Fonction principale
const arbre =nouveau FullbinaryTree ();
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
2. Arbre dégénéré (ou pathologique)
Un arbre où chaque nœud interne a un enfant.Ces arbres sont en termes de liste de performance que la liste liée.Un arbre dégénéré ou pathologique est un arbre ayant un seul enfant à gauche ou à droite.
Types of Binary Tree - GeeksforGeeks (2)
Arbre dégénéré (ou pathologique)
Programme pour mettre en œuvre un arbre dégénéré
C ++
#include 
#include 
classe Node {
publique:
int valeur;
Nœud * suivant;
Nœud(int val): valeur (val), suivant (null) {}
};
classe DegenerateTree {
publique:
NODES STD :: VECTOR ;
DegenerateTree () {}
vide insérer(int valeur) {
Node * new_node =nouveau Nœud (valeur);
si (nœuds.empty ()) {
nœuds.push_back (new_node);
}autre {
Node * last_node = nœuds.back ();
last_node-> next = new_node;
nœuds.push_back (new_node);
}
}
};
int principal() {
DegeneraTetree Tree;
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
retour 0;
}
Java
importer java.util.arraylist;
importer java.util.list;
// classe de nœud pour représenter un nœud dans l'arbre
classe Node {
int valeur;// valeur du nœud
Nœud suivant;// Référence au nœud suivant
// Constructeur pour initialiser le nœud
publique Nœud(int val)
{
valeur = val;
suivant =nul;
}
}
// Classe DegenerateTree pour représenter un arbre dégénéré
classe DegenerateTree {
Nœuds list ;// Liste des nœuds dans l'arbre
// Constructeur pour initialiser l'arbre
publique DegenerateTree () {nœuds =nouveau ArrayList <> ();}
// Méthode pour insérer un nouveau nœud dans l'arbre
publique vide insérer(int valeur)
{
Node NewNode
=nouveau Nœud (valeur);// Créez un nouveau nœud avec le
// Valeur donnée
si (nœuds.isempty ()) {// Si la liste est vide, ajouter
// le nouveau nœud comme le premier
// nœud
nœuds.add (newNode);
}
autre {// sinon, ajoutez le nouveau nœud comme le suivant
// nœud du dernier nœud de la liste
Node LastNode = NODES.GET (NODES.SIZE () -1));
LastNode.Next = newNode;
nœuds.add (newNode);
}
}
}
// Classe principale pour tester la classe DegenerateTree
publique classe Principal {
publique statique vide main (String [] args)
{
Dégénératoire
=nouveau Degeneratree ();// créer un nouveau
// arbre dégénéré
// insérer certaines valeurs dans l'arbre
Tree.insert (1));
Tree.insert (2));
Tree.insert (3));
Tree.insert (4));
}
}
Python3
classe Nœud:
def __init __ (soi, Val):
soi.valeur= val
soi.suivant = Aucun
classe DegenerateTree:
def __init __ (soi):
soi.= []
def insérer(soi, valeur):
new_node= Node (valeur)
si pas soi.Nodes:
soi.nodes.append (new_node)
autre:
dernier_node= soi.Nodes [-1]]
last_node.suivant = new_node
soi.nodes.append (new_node)
# Code de pilote
si __nom__== '__principal__':
arbre= DegenerateTree ()
Tree.insert (1)
Tree.insert (2)
Tree.insert (3)
Tree.insert (4)
Javascrip
// Code javascript pour l'approche ci-dessus
classe node {
constructeur (val) {
ce.Value = Val;
ce.Next =nul;
}
}
classe DegenerateTree {
constructeur () {
ce.Nodes = [];
}
insérer (valeur) {
// Créer un nouveau nœud
const new_node =nouveau Nœud (valeur);
si (ce.nodes.length === 0) {
// Si l'arbre est vide, ajoutez le nouveau nœud comme premier nœud
ce.nodes.push (new_node);
}autre {
// Trouvez le dernier nœud de l'arbre
const last_node =ce.Nodes [ce.Nodes.length - 1];
// liez le dernier nœud au nouveau nœud
last_node.next = new_node;
// Ajouter le nouveau nœud à l'arbre
ce.nodes.push (new_node);
}
}
}
// Fonction principale
const arbre =nouveau Degeneratree ();
// insérer des valeurs dans l'arbre
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
// Ce code est apporté par Kanchan Agarwal
3. Arbre binaire asymétrique
Un arbre binaire asymétrique est un arbre pathologique / dégénéré dans lequel l'arbre est dominé par les nœuds gauche ou les nœuds droits.Ainsi, il existe deux types d'arbre binaire asymétrique: l'arbre binaire asymétrique gauche et l'arbre binaire asymétrique.
Types of Binary Tree - GeeksforGeeks (3)
Arbre binaire asymétrique
Reportez-vous à cet article pour en savoir plus sur l'arbre binaire asymétrique
C ++
#include 
classe Node {
publique:
int valeur;
Nœud * à droite;
Nœud(int val): valeur (val), droit (null) {}
};
classe Asymétrique {
publique:
Node * root;
SkewedTree (): root (null) {}
vide insérer(int valeur) {
Node * new_node =nouveau Nœud (valeur);
si (!racine) {
root = new_node;
}autre {
Node * current_node = root;
alors que (current_node-> droit) {
current_node = current_node-> droit;
}
current_node-> right = new_node;
}
}
};
int principal() {
Arbre bizarre;
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
retour 0;
}
Javascrip
classe node {
constructeur (valeur) {
ce.Value = valeur;
ce.Right =nul;
}
}
classe SkewedTree {
constructeur () {
ce.Root =nul;
}
insérer (valeur) {
const newNode =nouveau Nœud (valeur);
si (!ce.racine) {
ce.root = newNode;
}autre {
Laissez currentNode =ce.racine;
alors que (currentNode.Right) {
currentNode = currentNode.Right;
}
currentNode.Right = newNode;
}
}
}
const arbre =nouveau Sèchetree ();
arbre.insert (1);
arbre.insert (2);
arbre.insert (3);
arbre.insert (4);
Types d'arbres binairesSur la base de l'achèvement des niveaux:
  1. Arbre binaire complet
  2. Arbre binaire parfait
  3. Arbre binaire équilibré
1. Arbre binaire complet
Un arbre binaire est un arbre binaire complet si tous les niveaux sont complètement remplis, sauf peut-être le dernier niveau et que le dernier niveau a toutes les clés aussi restantes que possible.
Un arbre binaire complet est comme un arbre binaire complet, mais avec deux différences majeures:
  • Chaque niveau doit être complètement rempli
  • Tous les éléments foliaires doivent se pencher vers la gauche.
  • Le dernier élément de feuille peut ne pas avoir un frère droit, c'est-à-dire qu'un arbre binaire complet n'a pas besoin d'être un arbre binaire complet.
Types of Binary Tree - GeeksforGeeks (4)
Arbre binaire complet
Reportez-vous à cet article pour en savoir plus sur Treat Tree
2. Arbre binaire parfait
Un arbre binaire est un arbre binaire parfait dans lequel tous les nœuds internes ont deux enfants et tous les nœuds de feuilles sont au même niveau.
Voici des exemples d'arbres binaires parfaits.
Un arbre binaire parfait est un type d'arbre binaire dans lequel chaque nœud interne a exactement deux nœuds enfants et tous les nœuds de feuilles sont au même niveau.
Types of Binary Tree - GeeksforGeeks (5)
Arbre binaire parfait
Dans un arbre binaire parfait, le nombre de nœuds de feuilles est le nombre de nœuds internes plus 1
L = i + 1where l = nombre de nœuds de feuilles, i = nombre de nœuds internes.
Un arbre binaire parfait de hauteur h (où la hauteur de l'arbre binaire est le nombre de bords dans le chemin le plus long du nœud racine à n'importe quel nœud de feuille dans l'arbre, la hauteur du nœud racine est 0) a 2h + 1- 1 nœud.
Un exemple d'un arbre binaire parfait est les ancêtres de la famille.Gardez une personne à la racine, les parents en tant qu'enfants, les parents de parents comme enfants.
Reportez-vous à cet article pour en savoir plus sur Perfect Tree
3. Arbre binaire équilibré
Un arbre binaire est équilibré si la hauteur de l'arbre est O (log n) où n est le nombre de nœuds.Par exemple, l'arbre AVL maintient la hauteur de O (log n) en s'assurant que la différence entre les hauteurs des sous-arbres gauche et droite est au plus 1.Des nœuds noirs sur chaque trajectoire de racine à feuilles sont les mêmes et qu'il n'y a pas de nœuds rouges adjacents.Les arbres de recherche binaires équilibrés sont bons en termes de performances car ils fournissent un temps (journal n) pour la recherche, l'insertion et la suppression.
Types of Binary Tree - GeeksforGeeks (6)
Exemple d'arbre binaire équilibré et déséquilibré
C'est un type d'arbre binaire dans lequel la différence entre la hauteur de la gauche et le sous-arbre droit pour chaque nœud est soit 0 ou 1. Dans la figure ci-dessus, le nœud racine ayant une valeur 0 est déséquilibré avec une profondeur de 2 unités.
Quelques types d'arbres spéciaux:
Sur la base des valeurs de nœud, l'arbre binaire peut être classé dans les types spéciaux suivants:
  1. Arbre de recherche binaire
  2. Arbre avl
  3. Arbre noir rouge
  4. B arbre
  5. Arbre b +
  6. Arbre de segment
L'image ci-dessous montre des cas spéciaux importants d'arbres binaires:
Types of Binary Tree - GeeksforGeeks (7)
Cas spéciaux d'arbre binaire
1. Arbre de recherche binaire
Arbre de recherche binaireest une structure de données d'arbre binaire basée sur des nœuds qui possède les propriétés suivantes:
  • Le sous-arbre gauche d'un nœud ne contient que des nœuds avec des touches moins que la clé du nœud.
  • Le sous-arbre droit d'un nœud ne contient que des nœuds avec des touches supérieures à la clé du nœud.
  • Le sous-arbre gauche et droit chacun doit également être un arbre de recherche binaire.
Types of Binary Tree - GeeksforGeeks (8)
Arbre de recherche binaire
2. Arbre AVL
AVL Tree est un arbre de recherche binaire auto-équilibré (BST) où la différence entre les hauteurs des sous-arbres gauche et droite ne peut pas être plus queunpour tous les nœuds.
Exemple d'arbre AVL illustré ci-dessous:
L'arbre ci-dessous est AVL car les différences entre les hauteurs des sous-arbres gauche et droite pour chaque nœud sont inférieures ou égales à 1
Types of Binary Tree - GeeksforGeeks (9)
Arbre avl
3. arbre noir rouge
Un arbre rouge-noir est une sorte d'arbre de recherche binaire auto-équilibré où chaque nœud a un morceau supplémentaire, et ce bit est souvent interprété comme la couleur (rouge ou noir).Ces couleurs sont utilisées pour garantir que l'arbre reste équilibré pendant les insertions et les suppressions.Bien que l'équilibre de l'arbre ne soit pas parfait, il est suffisamment bon pour réduire le temps de recherche et le maintenir autour du temps O (log n), où n est le nombre total d'éléments dans l'arbre.Cet arbre a été inventé en 1972 par Rudolf Bayer.
Types of Binary Tree - GeeksforGeeks (10)
Arbre noir rouge
4. b - arbre
Un B-Tree est un type de structure de données d'arborescence auto-équilibrée qui permet un accès, une insertion et une suppression efficaces des éléments de données.Les arbres B sont couramment utilisés dans les bases de données et les systèmes de fichiers, où ils peuvent stocker et récupérer efficacement de grandes quantités de données.Un arbre B est caractérisé par un degré maximum (ou ordre) fixe, qui détermine le nombre maximum de nœuds enfants qu'un nœud parent peut avoir.Chaque nœud dans un arbre B peut avoir plusieurs nœuds enfants et plusieurs clés, et les clés sont utilisées pour indexer et localiser les éléments de données.
Reportez-vous à cet article pour en savoir plus sur B-Tree
5. B + arbre
Une arborescence B + est une variation de l'arbre B qui est optimisé pour une utilisation dans les systèmes de fichiers et les bases de données.Comme un arbre B, une arborescence B + a également un degré maximal fixe et permet un accès, une insertion et une suppression efficaces des éléments de données.Cependant, dans une arborescence B +, tous les éléments de données sont stockés dans les nœuds de feuilles, tandis que les nœuds internes ne contiennent que des clés pour l'indexation et la localisation des éléments de données.Cette conception permet des recherches plus rapides et un accès séquentiel des éléments de données, car tous les nœuds de feuilles sont liés ensemble dans une liste liée.
Reportez-vous à cet article pour en savoir plus sur B + Tree
6. Arbre de segment
En informatique, unArbre de segment, également connu sous le nom d'un arbre statistique, est une structure de données d'arbre utilisée pour stocker des informations sur les intervalles ou les segments.Il permet d'interroger lequel des segments stockés contiennent un point donné.Il s'agit, en principe, d'une structure statique;Autrement dit, c'est une structure qui ne peut pas être modifiée une fois qu'elle est construite.Une structure de données similaire est l'arborescence d'intervalle.
UNarbre de segmentPour un ensemble, les intervalles de N utilisent le stockage O (n log n) et peuvent être construits en temps o (n log n).Les arbres du segment prennent en charge la recherche de tous les intervalles qui contiennent un point de requête dans le temps O (log n + k), k étant le nombre d'intervalles ou de segments récupérés.
Types of Binary Tree - GeeksforGeeks (11)
Arbre de segment
Reportez-vous à cet article pour en savoir plus sur le segment Tree
Résoudre les problèmes de DSA recommandés sur la pratique GFG.


                                                        Types d'arbres binaires - Geeksforgeeks (2024)
                        

                            
                        

                    

                                                                                                            
Top Articles

                            

                                                                    



    
    

        Problems with Merging: &#39;by&#39; must specify a uniquely valid column
    


                                                                    



    
    

        Les biologiques et les biosimilaires américains ont besoin de noms de distinction
    


                                                                                                    



    
    

        Dora The Explorer Grandma's House Dailymotion
    


                



    
    

        Seth Juszkiewicz Obituary
    


                                                                

                                                                
Latest Posts

                        

                                                            



    
    

        Graphique à barres, graphique à secteurs
    


                                                            



    
    

        Comment formater la table de données dans Excel Chart (4 méthodes faciles)
    


                                                    

                    
                    

        

    
    
    



                    

    
Article information

    
Author:  Golda Nolan II 

    
Last Updated:   

    
Views: 6432

    
Rating: 4.8 / 5 (58 voted)

    
Reviews: 81% of readers found this page helpful





    
Author information

    
Name: Golda Nolan II

    
Birthday: 1998-05-14

    
Address: Suite 369 9754 Roberts Pines, West Benitaburgh, NM 69180-7958

    
Phone: +522993866487

    
Job: Sales Executive

    
Hobby: Worldbuilding, Shopping, Quilting, Cooking, Homebrewing, Leather crafting, Pet

    
Introduction: My name is Golda Nolan II, I am a thoughtful, clever, cute, jolly, brave, powerful, splendid person who loves writing and wants to share my knowledge and understanding with you.