//Integrantes: Ariana Nuñez, Marcel Bohórquez, Pablo Jácome y Alejandro Rivadeneira

//Grupo: #1

//Fecha: 25/10/2021

//Operaciones Árboles Binarios

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

using System.Threading.Tasks;

namespace ArbolBinario

class Nodo // definición del elemento base de un árbol, llamado nodo, que contiene un
dato y apunta a 2 nodos uno por izquierda y otro por derecha.

public int Dato { get; set; }

public Nodo NodoIzquierda { get; set; }

public Nodo NodoDerecha { get; set; }

class ArbolBinario

public Nodo Raiz { get; set; }

public bool Anadir(int valor)

Nodo anterior = null;

Nodo posterior = this.Raiz;

while (posterior != null) //Caso en que al revisar contenido previo a

insertar encontramos que existe un nodo

{
 anterior = posterior;

if (valor < posterior.Dato) // Colocar el nuevo nodo en el SubÁrbol

Izquierdo

posterior = posterior.NodoIzquierda;

else if (valor > posterior.Dato) // Colocar el nuevo nodo en el SubÁrbol

Derecho

posterior = posterior.NodoDerecha;

else

//Si existe el mismo valor en el Árbol retornar falso y no insertar

return false;

// Caso en que al revisar contenido previo a insertar NO encontramos que

exista un nodo

Nodo nuevoNodo = new Nodo();

nuevoNodo.Dato = valor;

if (this.Raiz == null) // El Árbol está vacío

this.Raiz = nuevoNodo;

else

if (valor < anterior.Dato)

anterior.NodoIzquierda = nuevoNodo;

else

anterior.NodoDerecha = nuevoNodo;

return true;

public void Remover(int valor)//Funcion para remover un nodo

{
 this.Raiz = Remover(this.Raiz, valor);

public Nodo Remover(Nodo padre, int valor)

if (padre == null)

return padre;

if (valor < padre.Dato)

padre.NodoIzquierda = Remover(padre.NodoIzquierda, valor);

else if (valor > padre.Dato)

padre.NodoDerecha = Remover(padre.NodoDerecha, valor);

else

// nodo tiene un solo hijo o no tiene hijos

if (padre.NodoIzquierda == null)

return padre.NodoDerecha;

else if (padre.NodoDerecha == null)

return padre.NodoIzquierda;

// nodo con dos hijos. Obtener el menor valor en el subárbol derecho

padre.Dato = ValorMinimo(padre.NodoDerecha);

padre.NodoDerecha = Remover(padre.NodoDerecha, padre.Dato);

return padre;

private int ValorMinimo(Nodo nodo)//Funcion para encontrar el valor minimo

int valmin = nodo.Dato;

 while (nodo.NodoIzquierda != null)

valmin = nodo.NodoIzquierda.Dato;

nodo = nodo.NodoIzquierda;

return valmin;

public Nodo Buscar(int valor)

return this.Buscar(valor, this.Raiz);

private Nodo Buscar(int valor, Nodo padre)

if (padre != null)

if (valor == padre.Dato) return padre;

if (valor < padre.Dato)

return Buscar(valor, padre.NodoIzquierda);

else return Buscar(valor, padre.NodoDerecha);

else return null;

public int ObtenerProfundidad()

return this.ObtenerProfundidad(this.Raiz);//Llama a la profundidaddel nodo

private int ObtenerProfundidad(Nodo padre)//Calcula la profundidad del nodo

return padre == null ? 0 : Math.Max(ObtenerProfundidad(padre.NodoIzquierda),

ObtenerProfundidad(padre.NodoDerecha)) + 1;
 }

public void RecorridoPreOrden(Nodo padre)//Funcion que te da el recorrido antes

del orden

if (padre != null)

Console.Write(padre.Dato + " ");

RecorridoPreOrden(padre.NodoIzquierda);

RecorridoPreOrden(padre.NodoDerecha);

public void RecorridoInOrden(Nodo padre)//Funcion que te da el recorrido en orden

if (padre != null)

RecorridoInOrden(padre.NodoIzquierda);

Console.Write(padre.Dato + " ");

RecorridoInOrden(padre.NodoDerecha);

public void RecorridoPostOrden(Nodo padre)//Funcion que te da el recorrido

despues de estar en orden

if (padre != null)

RecorridoPostOrden(padre.NodoIzquierda);

RecorridoPostOrden(padre.NodoDerecha);

Console.Write(padre.Dato + " ");

public void Info(int data)

 {

Nodo nodo = Buscar(data);//Funcion qu busca un nodo depende del número y da

la informacion de sus hijos

if (nodo.NodoDerecha != null && nodo.NodoIzquierda != null)

Console.WriteLine("El nodo buscado contiene el número " + nodo.Dato +

"\nSus hijos son:\n" +

nodo.NodoIzquierda.Dato + "\n" +

nodo.NodoDerecha.Dato);//Mensaje para el usuario

else if (nodo.NodoDerecha == null && nodo.NodoIzquierda == null)

Console.WriteLine("El nodo buscado contiene el número " + nodo.Dato + "

como dato, y no tiene hijos");//Mensaje para el usuario

else

Console.Write("El nodo buscado contiene el número " + nodo.Dato + "como

dato.\n" +

"Su hijo es: \n");//Mensaje para el usuario

if (nodo.NodoDerecha != null)

Console.WriteLine(nodo.NodoDerecha.Dato);

else

Console.WriteLine(nodo.NodoIzquierda.Dato);

public void Left(int data)//Funcion que dira si el nodo tiene un hijo en la

izquierda

Nodo nodo = Buscar(data);

if (nodo.NodoIzquierda == null)
 {

Console.WriteLine("\nEl nodo no tiene hijos por la izquierda.");//Mensaje

para el usuario

else

Console.WriteLine("\nEl nodo tiene como hijo al número " +

nodo.NodoIzquierda.Dato + " por la izquierda");//Mensaje para el usuario

public void Right(int data)//Funcion que dira si el nodo tiene un hijo en la

derecha

Nodo nodo = Buscar(data);

if (nodo.NodoDerecha == null)

Console.WriteLine("\nEl nodo no tiene hijos por la derecha.");//Mensaje

para el usuario

else

Console.WriteLine("\nEl nodo tiene como hijo al número " +

nodo.NodoDerecha.Dato + " por la derecha");//Mensaje para el usuario

public void Padre(int data)//Funcion para imprimir el padre de un nodo

Nodo padre = Padre(this.Raiz, data);

if (padre != null)

Console.WriteLine("\nEl padre del nodo que contiene el dato " + data + "
es " + padre.Dato);//Mensaje para el usuario

else

Console.WriteLine("\nEl nodo del dato" + data + "no tiene

padre");//Mensaje para el usuario
 }

private Nodo Padre(Nodo node, int data)//Funcion para encontrar el padre de un

nodo

if (node == null || node.Dato == data)

return null;

if ((node.NodoIzquierda != null && node.NodoIzquierda.Dato == data) ||

(node.NodoDerecha != null && node.NodoDerecha.Dato == data))

return node;

Nodo l = Padre(node.NodoIzquierda, data);

if (l != null)

return l;

l = Padre(node.NodoDerecha, data);

return l;

public void Brother(int data)

Nodo brother = Brother(this.Raiz, data);

if (brother != null)

Console.WriteLine("\nEl hermano del nodo que contiene el dato" + data + "

es " + brother.Dato);

else
 {

Console.WriteLine("\nEl nodo del dato " + data + " no tiene hermano");

private Nodo Brother(Nodo nodo, int data)//Funcion para encontrar el hermano de

un nodo

if (nodo == null || nodo.Dato == data)

return null;

if (nodo.NodoIzquierda != null && nodo.NodoIzquierda.Dato == data)

return nodo.NodoDerecha;

if (nodo.NodoDerecha != null && nodo.NodoDerecha.Dato == data)

return nodo.NodoIzquierda;

Nodo l = Brother(nodo.NodoIzquierda, data);//Funcion para imprimir el hermano

de un nodo

if (l != null)

return l;

l = Brother(nodo.NodoDerecha, data);

return l;

public void IngresarIzq(Nodo nodo, int llave)//Funcion para ingresar un valor en

la derecha
 {

Nodo nuevoNodo = new Nodo();

nuevoNodo.Dato = llave;

if (Buscar(llave) != null)

Console.WriteLine("\nNo se pueden ingresar duplicados del mismo

nodo");//Mensaje para el usuario

return;

if (nodo.NodoIzquierda == null)

nodo.NodoIzquierda = nuevoNodo;

else

Console.WriteLine("Ya esta ocupado ese nodo hijo");//Mensaje para el

usuario

return;

public void IngresarDer(Nodo nodo, int llave)//Funcion para ingresar un valor en

la derecha

Nodo nuevoNodo = new Nodo();

nuevoNodo.Dato = llave;

if (Buscar(llave) != null)

Console.WriteLine("\nNo se pueden ingresar duplicados del mismo

nodo");//Mensaje para el usuario

return;

if (nodo.NodoDerecha == null)

nodo.NodoDerecha = nuevoNodo;

}
 else

Console.WriteLine("Ya esta ocupado ese nodo hijo");//Mensaje para el

usuario

return;

class Program

static void Main(string[] args)//Main que imprimira los resultados

//Se llaman y se imprimen los resultados

ArbolBinario binaryTree = new ArbolBinario();

binaryTree.Anadir(1);

binaryTree.Anadir(2);

binaryTree.Anadir(7);

binaryTree.Anadir(3);

binaryTree.Anadir(10);

binaryTree.Anadir(5);

binaryTree.Anadir(8);

Nodo nodo = binaryTree.Buscar(5);

int depth = binaryTree.ObtenerProfundidad();

Console.WriteLine("La profundidad de arbol es : " + " " + depth);

Console.WriteLine("Recorrido en PreOrden:");

binaryTree.RecorridoPreOrden(binaryTree.Raiz);
Console.WriteLine();

Console.WriteLine("Recorrido en InOrden:");

binaryTree.RecorridoInOrden(binaryTree.Raiz);

Console.WriteLine();

Console.WriteLine("Recorrido en PostOrden:");

binaryTree.RecorridoPostOrden(binaryTree.Raiz);

Console.WriteLine();

Console.WriteLine("La profundidad del arbol es" + depth);

Console.WriteLine();

binaryTree.Info(7);

binaryTree.Left(7);

binaryTree.Right(7);

binaryTree.Padre(7);

binaryTree.Brother(7);

binaryTree.Remover(7);

binaryTree.Remover(8);

Console.WriteLine("\nRecorrido en PreOrden Luego de Operación Remover:");

binaryTree.RecorridoPreOrden(binaryTree.Raiz);

Console.WriteLine();
 binaryTree.IngresarDer(binaryTree.Buscar(10), 11);

binaryTree.IngresarDer(binaryTree.Buscar(10), 2);

binaryTree.RecorridoPreOrden(binaryTree.Raiz);

Console.WriteLine();

Console.WriteLine("\nRecorrido en PreOrden:");

binaryTree.RecorridoPreOrden(binaryTree.Raiz);

Console.WriteLine();

Console.WriteLine();

Console.WriteLine("\nRecorrido en InOrden:");

binaryTree.RecorridoInOrden(binaryTree.Raiz);

Console.WriteLine();

Console.WriteLine("Ingrese");

Console.ReadKey();

//Fin

}
Impresión por consola: