Cómo implementar un árbol binario en c?

Un árbol es un formato de datos común para la información de almacenamiento contenida jerárquicamente. Un árbol está formado por nodos vinculados por bordes, con cada nodo que tiene su nodo principal y uno o varios nodos infantiles. Este artículo estudia y analiza árboles binarios y ve la implementación de árboles binarios en la programación C.

Árbol binario en C

En C, A árbol binario es una instancia de una estructura de datos de árbol con un nodo principal que puede poseer un número máximo de dos nodos infantiles; 0, 1 o 2 nodos de descendencia. Cada nodo en un árbol binario tiene un valor propio y dos consejos para sus hijos, un puntero para el niño izquierdo y el otro para el niño correcto.

Declaración de árbol binario

A árbol binario se puede declarar en c usando un objeto llamado estructura que representa uno de los nodos en el árbol.

nodo de estructura
DataType var_name;
nodo de estructura* izquierda;
nodo de estructura* derecho;
;

Arriba hay una declaración de uno árbol binario Nombre del nodo como nodo. Contiene tres valores; Una es la variable de almacenamiento de datos y los otros dos son los consejos para el niño. (Niño izquierdo y derecho del nodo principal).

Hechos del árbol binario

Incluso para grandes conjuntos de datos, utilizando un árbol binario Hace que la búsqueda sea más fácil y rápida. El número de ramas de los árboles no se limita. A diferencia de una matriz, se pueden hacer y aumentar los árboles de cualquier tipo en función de lo que se requiere de un individuo.

Implementación de árbol binario en C

La siguiente es una guía paso a paso para implementar un Árbol binario Cª.

Paso 1: declara un árbol de búsqueda binario

Cree un nodo de estructura que tenga tres tipos de datos, como datos, *Left_child y *Right_child, donde los datos pueden ser de tipo entero, y los nodos *Left_child y *Right_child pueden declararse como nulos o no.

nodo

datos int;
struct nodo *right_child;
struct nodo *Left_child;
;

Paso 2: Crear nuevos nodos en el árbol de búsqueda binario

Cree un nuevo nodo creando una función que acepte un entero como argumento y proporciona el puntero al nuevo nodo creado con ese valor. Use la función malloc () en C para la asignación de memoria dinámica para el nodo creado. Inicialice al niño izquierdo y derecho para nulo y devuelva el nombre de noganza.

struct node* create (datos de tipo de datos)

struct node* nodename = malloc (sizeOf (nodo struct));
NodeName-> data = value;
NodeName-> Left_child = NodeName-> right_child = null;
return NodeName;

Paso 3: inserte niños derecha e izquierda en árbol binario

Crear funciones insert_left e insert_right que aceptarán dos entradas, que son el valor que se insertará y el puntero al nodo al que se conectarán ambos niños. Llame a la función Crear para crear un nuevo nodo y asigne el puntero devuelto al puntero izquierdo del niño izquierdo o el puntero derecho del niño derecho del padre raíz.

struct node* insert_left (struct node* root, datos de tipo de datos)
root-> izquierda = create (datos);
return root-> izquierda;

struct node* insert_right (struct nodo* root, datos de datos de datos)
root-> right = create (data);
return root-> derecho;

Paso 4: Mostrar nodos de árbol binario utilizando métodos de transversal

Podemos mostrar árboles utilizando tres métodos de recorrido en C. Estos métodos transversales son:

1: Recorrido por adelantado

En este método transversal, pasaremos por los nodos en una dirección desde Parent_node-> Left_child-> Right_child.

void pre_order (nodo * root)
if (root)
printf ("%d \ n", root-> data);
display_pre_order (root-> izquierda);
display_pre_order (root-> derecho);

2: transversal posterior al orden

En este método de recorrido, pasaremos por los nodos en una dirección desde el Left_child-> derecho_child-> parent_node->.

void display_post_order (nodo * root)
if (binary_tree)
display_post_order (root-> izquierda);
display_post_order (root-> derecha);
printf ("%d \ n", root-> data);

3: Traversal en orden

En este método transversal, pasaremos por los nodos en una dirección desde Left_node-> root_child-> right_child.

void display_in_order (nodo * root)
if (binary_tree)
display_in_order (root-> izquierda);
printf ("%d \ n", root-> data);
display_in_order (root-> derecho);

Paso 5: Realice la eliminación en el árbol binario

Podemos eliminar el creado Árbol binario eliminando a ambos niños con la función del nodo principal en C de la siguiente manera.

void delete_t (nodo * root)
if (root)
delete_t (root-> izquierda);
delete_t (root-> derecho);
gratis (raíz);

C Programa de árbol de búsqueda binaria

La siguiente es la implementación completa del árbol de búsqueda binario en la programación C:

#incluir
#incluir
nodo de estructura
valor int;
nodo de estructura * izquierda, * derecha;
;
struct node * node1 (int data)
struct nodo * tmp = (nodo struct *) malloc (sizeOf (nodo struct));
tmp -> value = data;
tmp -> izquierda = tmp -> right = null;
return tmp;

Void Print (struct node * root_node) // Mostrando los nodos!

if (root_node != Nulo)
print (root_node -> izquierda);
printf ("%d \ n", root_node -> valor);
print (root_node -> derecho);


struct node * insert_node (struct node * nodo, int data) // insertar nodos!

if (node ​​== null) return node1 (datos);
if (datos < node -> valor)
nodo -> izquierda = insert_node (nodo -> izquierda, datos);
else if (data> nodo -> valor)
nodo -> right = insert_node (nodo -> derecho, datos);

nodo de retorno;

int main ()
printf ("C Implementación del árbol de búsqueda binario!\ n \ n ");
struct nodo * 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);
imprimir (padre);
regresar 0;

En el código anterior, primero declaramos un nodo usando estructura. Luego inicializamos un nuevo nodo como "nodo1"Y asignar memoria dinámicamente usando malloc () en C con datos y dos punteros, tipo niños utilizando el nodo declarado. Después de esto, mostramos el nodo por printf () función y llamarlo en el principal() función. Entonces el insertion_node () Se crea la función, donde si los datos de nodo son nulos entonces nodo1 está retirado, de lo contrario se colocan datos en el nodo(padre) del niño izquierdo y derecho. El programa inicia la ejecución del principal() función, que genera un nodo utilizando algunos nodos de muestra cuando es niños y luego usa métodos de transversión en orden para imprimir el contenido del nodo.

Producción

Conclusión

Los árboles se emplean con frecuencia para mantener los datos en forma no lineal. Árboles binarios son tipos de árboles donde cada nodo (padre) tiene dos descendientes el hijo izquierdo y el niño derecho. A árbol binario es un método versátil para transferir y almacenar datos. Es más eficiente en comparación con la lista vinculada en c. En el artículo anterior, hemos visto el concepto de un Árbol binario con la implementación paso a paso de un Árbol de búsqueda binario Cª.