Comment implémenter l'arbre binaire en c?

Un arbre est un format de données commun pour le stockage des informations contenues hiérarchiquement. Un arbre est composé de nœuds liés par des bords, chaque nœud ayant son nœud parent et un ou plusieurs nœuds enfants. Cet article étudie et analyse arbres binaires et voit la mise en œuvre de arbres binaires en programmation C.

Arbre binaire en c

En c, un arbre binaire est une instance d'une structure de données d'arbre avec un nœud parent qui peut posséder un nombre maximum de deux nœuds enfants; 0, 1 ou 2 nœuds de progéniture. Chaque nœud dans un arbre binaire a une valeur propre et deux pointeurs vers ses enfants, un pointeur pour l'enfant gauche et l'autre pour l'enfant droit.

Déclaration d'arbre binaire

UN arbre binaire peut être déclaré en C en utilisant un objet appelé structure qui représente l'un des nœuds de l'arbre.

nœud struct
dataType var_name;
Node de structure * gauche;
nœud struct * à droite;
;

Ci-dessus est une déclaration d'un arbre binaire Nom du nœud comme nœud. Il contient trois valeurs; L'un est la variable de stockage de données et les deux autres sont les pointeurs de l'enfant. (enfant gauche et droit du nœud parent).

Faits de l'arbre binaire

Même pour de grands ensembles de données, en utilisant un arbre binaire rend la recherche plus facile et plus rapide. Le nombre de branches d'arbres n'est pas limitée. Contrairement à un tableau, les arbres de toute nature peuvent être fabriqués et augmentés en fonction de ce qui est exigé d'un individu.

Mise en œuvre des arbres binaires en c

Ce qui suit est un guide étape par étape pour implémenter un Arbre binaire en c.

Étape 1: Déclarez un arbre de recherche binaire

Créer un nœud struct qui a trois types de données, tels que les données, * Left_child et * droite_child, où les données peuvent être de type entier, et à la fois * les nœuds * Left_child et * droite_child peuvent être déclarés NULL ou non.

nœud de structure

données int;
struct nœud * right_child;
nœud struct * Left_child;
;

Étape 2: Créez de nouveaux nœuds dans l'arbre de recherche binaire

Créez un nouveau nœud en créant une fonction qui accepte un entier comme argument et fournit le pointeur vers le nouveau nœud créé avec cette valeur. Utilisez la fonction malloc () en C pour l'allocation de mémoire dynamique pour le nœud créé. Initialisez l'enfant gauche et droit à Null et renvoyez le Nodename.

nœud struct * Create (données de données de données)

struct nœud * nodeName = malloc (sizeof (nœud struct));
Nodename-> data = valeur;
NodeName-> Left_Child = nodeName-> droite_child = null;
return nodename;

Étape 3: Insérez les enfants à droite et à gauche dans l'arbre binaire

Créer des fonctions insert_left et insert_right qui accepteront deux entrées, qui sont la valeur à insérer et le pointeur vers le nœud auquel les deux enfants seront connectés. Appelez la fonction Créer pour créer un nouveau nœud et attribuer le pointeur retourné au pointeur gauche de l'enfant gauche ou le pointeur droit de l'enfant droit du parent racine.

struct nœud * insert_left (struct nœud * root, dataType data)
root-> Left = create (data);
return root-> gauche;

struct nœud * insert_right (struct nœud * root, dataType data)
root-> droite = create (data);
return root-> droite;

Étape 4: Afficher les nœuds de l'arbre binaire en utilisant des méthodes de traversée

Nous pouvons afficher les arbres en utilisant trois méthodes de traversée en C. Ces méthodes de traversée sont:

1: Traversion de précommande

Dans cette méthode de traversée, nous passerons par les nœuds dans une direction de parent_node-> Left_child-> droite_child.

void pre_order (nœud * root)
if (root)
printf ("% d \ n", root-> data);
display_pre_order (root-> gauche);
display_pre_order (root-> à droite);

2: Traversion post-ordre

Dans cette méthode de traversée, nous passerons par les nœuds dans une direction du Left_Child-> droite_child-> parent_node->.

void display_post_order (node ​​* root)
if (binary_tree)
display_post_order (root-> gauche);
display_post_order (root-> à droite);
printf ("% d \ n", root-> data);

3: traversée dans l'ordre

Dans cette méthode de traversée, nous passerons par les nœuds dans une direction de Left_node-> root_child-> droite_child.

void display_in_order (nœud * root)
if (binary_tree)
display_in_order (root-> gauche);
printf ("% d \ n", root-> data);
display_in_order (root-> à droite);

Étape 5: Effectuez la suppression dans l'arbre binaire

Nous pouvons supprimer le créé Arbre binaire En supprimant les deux enfants avec la fonction du nœud parent en C comme suit.

void delete_t (nœud * root)
if (root)
delete_t (root-> gauche);
delete_t (root-> à droite);
libre (racine);

C Programme d'arbre de recherche binaire

Ce qui suit est la mise en œuvre complète de l'arbre de recherche binaire dans la programmation C:

#inclure
#inclure
nœud struct
INT VALEUR;
nœud struct * gauche, * à droite;
;
struct node * node1 (int data)
nœud struct * tmp = (nœud struct *) malloc (sizeof (nœud struct));
tmp -> value = data;
tmp -> gauche = tmp -> droit = ​​null;
retour tmp;

vide print (struct nœud * root_node) // affichant les nœuds!

if (root_node != Null)
print (root_node -> gauche);
printf ("% d \ n", root_node -> valeur);
print (root_node -> à droite);


nœud struct * insert_node (nœud struct * nœud, données int) // insérer des nœuds!

if (node ​​== null) return node1 (data);
si (données < node -> valeur)
Node -> Left = insert_node (Node -> Left, Data);
else if (data> nœud -> value)
Node -> droite = insert_node (node ​​-> droite, données);

Node de retour;

int main()
printf ("C implémentation de l'arbre de recherche binaire!\ n \ n ");
nœud struct * parent = null;
parent = insert_node (parent, 10);
insert_node (parent, 4);
insert_node (parent, 66);
insert_node (parent, 45);
insert_node (parent, 9);
insert_node (parent, 7);
imprimer (parent);
retour 0;

Dans le code ci-dessus, nous déclarons d'abord un nœud en utilisant structure. Ensuite, nous initialisons un nouveau nœud comme «node1»Et allouer la mémoire en utilisant dynamiquement malloc () en C avec des données et deux pointeurs tapent les enfants utilisant le nœud déclaré. Après cela, nous affichons le nœud par printf () fonction et appelez-le dans le principal() fonction. Puis le insertion_node () La fonction est créée, où si les données de nœud sont nuls alors node1 est à la retraite, sinon les données sont placées dans le nœud(parent) de l'enfant gauche et droit. Le programme commence l'exécution à partir du principal() Fonction, qui génère un nœud en utilisant quelques nœuds d'échantillonnage comme enfants, puis utilise des méthodes de traversée dans l'ordre pour imprimer le contenu du nœud.

Sortir

Conclusion

Les arbres sont fréquemment utilisés pour conserver les données sous une forme non linéaire. Arbres binaires sont des types d'arbres où chaque nœud (parent) a deux descendants l'enfant gauche et l'enfant droit. UN arbre binaire est une méthode polyvalente pour transférer et stocker des données. Il est plus efficace par rapport à la liste liée en C. Dans l'article ci-dessus, nous avons vu le concept de Arbre binaire avec l'implémentation étape par étape d'un Arbre de recherche binaire en c.