Esempio n. 1
0
 public void TransversaPost(NodoArbolG nodo)
 {
     if (nodo == null)
     {
         return;
     }
     // Primero proceso a mi hijo
     if (nodo.Hijo != null)
     {
         i++;
         TransversaPost(nodo.Hijo);
         i--;
     }
     // Si tengo hermanos los proceso
     if (nodo.Hermano != null)
     {
         TransversaPost(nodo.Hermano);
     }
     // Luego me proceso a mí.
     for (int n = 0; n < i; n++)
     {
         Console.Write(" ");
     }
     Console.WriteLine(nodo.Dato);
 }
Esempio n. 2
0
        public NodoArbolG Buscar(string valor, NodoArbolG nodo)
        {
            NodoArbolG encontrado = null;

            if (nodo == null)
            {
                return(encontrado);
            }
            if (nodo.Dato.CompareTo(valor) == 0)
            {
                encontrado = nodo;
                return(encontrado);
            }
            // Luego proceso a mi hijo
            if (nodo.Hijo != null)
            {
                encontrado = Buscar(valor, nodo.Hijo);
                if (encontrado != null)
                {
                    return(encontrado);
                }
            }
            // Si tengo hermanos los proceso
            if (nodo.Hermano != null)
            {
                encontrado = Buscar(valor, nodo.Hermano);
                if (encontrado != null)
                {
                    return(encontrado);
                }
            }

            return(encontrado);
        }
        static void Main(string[] args)
        {
            // Árbol Genérico
            Arbol      arbolito = new Arbol();
            NodoArbolG raiz     = arbolito.Insertar("A", null);

            arbolito.Insertar("B", raiz);
            arbolito.Insertar("C", raiz);

            //arbolito.TransversaPre(raiz);

            NodoArbolG n = arbolito.Insertar("D", raiz);

            arbolito.Insertar("H", n);
            n = arbolito.Insertar("E", raiz);
            NodoArbolG i = arbolito.Insertar("I", n);

            arbolito.Insertar("J", i);
            NodoArbolG p = arbolito.Insertar("Q", n);

            arbolito.Insertar("P", p);

            n = arbolito.Insertar("F", raiz);
            arbolito.Insertar("k", n);
            arbolito.Insertar("L", n);
            arbolito.Insertar("M", n);
            n = arbolito.Insertar("G", raiz);
            arbolito.Insertar("N", n);

            arbolito.TransversaPre(raiz);
            Console.WriteLine("-------");
            Console.WriteLine("Transversa Post-Order");
            arbolito.TransversaPost(raiz);
            //
            Console.WriteLine("Busqueda");
            if (arbolito.Buscar("N", raiz) != null)
            {
                Console.WriteLine("Dato encontrado = " + arbolito.Buscar("k", raiz).Dato);
            }
            else
            {
                Console.WriteLine("No lo encontre :(");
            }

            // Proceso de Inserción
            string donde = "";
            string que   = "";

            Console.WriteLine("En dónde deseas insertar?");
            donde = Console.ReadLine();
            Console.WriteLine("Qué deseas insertar?");
            que = Console.ReadLine();
            NodoArbolG encontrado = arbolito.Buscar(donde, raiz);

            arbolito.Insertar(que, encontrado);
            arbolito.TransversaPre(raiz);
        }
Esempio n. 4
0
 public NodoArbolG Insertar(string cadena, NodoArbolG nodo)
 {
     // Si no hay nodo donde insertar, tomamos como si fuera en la raiz
     if (nodo == null)
     {
         raiz      = new NodoArbolG();
         raiz.Dato = cadena;
         // No hay hijo
         raiz.Hijo = null;
         // No hay hermano
         raiz.Hermano = null;
         return(raiz);
     }
     // Verificamos si no tiene hijo
     if (nodo.Hijo == null)
     {
         NodoArbolG temp = new NodoArbolG();
         temp.Dato = cadena;
         // Conectamos el nuevo nodo como hijo
         nodo.Hijo = temp;
         return(temp);
     }
     else // Ya tiene un hijo, tenemos que insertarlo como hermano.
     {
         trabajo = nodo.Hijo;
         // Avanzamos hasta el ultimo hermano
         while (trabajo.Hermano != null)
         {
             trabajo = trabajo.Hermano;
         }
         // Creamos nodo temporal
         NodoArbolG temp = new NodoArbolG();
         temp.Dato = cadena;
         // Unimos el temp al último hermano
         trabajo.Hermano = temp;
         return(temp);
     }
 }
Esempio n. 5
0
 // constructor de nuevo árbol
 public Arbol()
 {
     raiz = new NodoArbolG();
 }
Esempio n. 6
0
 public NodoArbolG()
 {
     dato    = "";
     hijo    = null;
     hermano = null;
 }