• Miércoles 18 de Julio de 2018, 22:29

Autor Tema:  Sobre Árboles en C#  (Leído 23040 veces)

lexor

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Sobre Árboles en C#
« en: Miércoles 29 de Octubre de 2008, 06:24 »
0
Necesito ejemplos sobre algoritmos de recorrido de árboles en c#
Saludos a toda la comunidad.
lexor
 ;)

LEGOLASYEE

  • Miembro activo
  • **
  • Mensajes: 42
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #1 en: Miércoles 29 de Octubre de 2008, 22:54 »
0
bueno compa quien sabe para que quieras los ejemplos, podra ser para estudiar o talves una tarea, pero aqui te paso este que tengo yo, sale saludos:

Código: Text
  1. public class NodoT
  2.     {
  3.         public NodoT NodoIzquierdo;
  4.         public int Informacion;
  5.         public NodoT NodoDerecho;
  6.         //Constructor
  7.         public NodoT()
  8.         {
  9.             this.NodoIzquierdo=null;
  10.             this.Informacion=0;
  11.             this.NodoDerecho=null;
  12.         }
  13.     }
  14.     /// <summary>
  15.     /// Summary description for Class1.
  16.     /// </summary>
  17.     class Class1
  18.     {
  19.         /// <summary>
  20.         /// The main entry point for the application.
  21.         /// </summary>
  22.         [STAThread]
  23.         static void Main(string[] args)
  24.         {
  25.             ClearConsole ClearMyConsole = new ClearConsole();
  26.             int Opcion=0;
  27.             NodoT Raiz=null;
  28.             int Dato;
  29.             do
  30.             {
  31.                 Opcion=Menu();
  32.                 switch(Opcion)
  33.                 {
  34.                     case 1: Console.Write("Valor del Nuevo Nodo: ");
  35.                             Dato=int.Parse(Console.ReadLine());
  36.                             if(Raiz==null)
  37.                             {
  38.                                 NodoT NuevoNodo=new NodoT();
  39.                                 NuevoNodo.Informacion=Dato;
  40.                                 Raiz=NuevoNodo;
  41.                             }
  42.                             else
  43.                             {
  44.                                 Insertar(Raiz, Dato);
  45.                             }
  46.                             ClearMyConsole.Clear();
  47.                             break;
  48.                             //Recorrido en Pre Orden del Arbol
  49.                     case 2: RecorridoPreorden(Raiz);
  50.                             Console.WriteLine("Fin del Recorrido,...");
  51.                             Console.ReadLine();
  52.                             ClearMyConsole.Clear();
  53.                             break;
  54.                             //Recorrido en Post Orden del Arbol
  55.                     case 3: RecorridoPostorden(Raiz);
  56.                             Console.WriteLine("Fin del Recorrido,...");
  57.                             Console.ReadLine();
  58.                             ClearMyConsole.Clear();
  59.                             break;
  60.                             //Recorrido en In Orden del Arbol
  61.                     case 4: RecorridoInorden(Raiz);
  62.                             Console.WriteLine("Fin del Recorrido,...");
  63.                             Console.ReadLine();
  64.                             ClearMyConsole.Clear();
  65.                             break;
  66.                     case 5: Console.Write("Teclee el Dato a Buscar: ");
  67.                             Dato=int.Parse(Console.ReadLine());
  68.                             if(Raiz!=null)
  69.                             {
  70.                                 BuscarNodo(Raiz, Dato);
  71.                             }
  72.                             else
  73.                             {
  74.                                 Console.WriteLine("ERROR, Arbol Vacio....");
  75.                             }                          
  76.                             ClearMyConsole.Clear();
  77.                             break;
  78.                     case 6: Console.Write("Teclee el Dato a Eliminar: ");
  79.                             Dato=int.Parse(Console.ReadLine());
  80.                             if(Raiz!=null)
  81.                             {
  82.                                 EliminarNodo(ref Raiz, Dato);
  83.                             }
  84.                             else
  85.                             {
  86.                                 Console.WriteLine("ERROR, Arbol Vacio....");
  87.                             }   
  88.                             ClearMyConsole.Clear();
  89.                             break;
  90.                     case 7: Finalizar();
  91.                             break;
  92.                 }
  93.             }while(Opcion!=7);
  94.  
  95.         }
  96.         static int Menu()
  97.         {
  98.             ClearConsole ClearMyConsole = new ClearConsole();
  99.             int Resultado=0;
  100.             do
  101.             {
  102.                 Console.WriteLine("MENU DE ARBOLES");
  103.                 Console.WriteLine("");
  104.                 Console.WriteLine("1.- Registrar un Nuevo Nodo");
  105.                 Console.WriteLine("2.- Recorrido en Pre-orden");
  106.                 Console.WriteLine("3.- Recorrido en Post-orden");
  107.                 Console.WriteLine("4.- Recorrido en In-orden");
  108.                 Console.WriteLine("5.- Buscar un Nodo");
  109.                 Console.WriteLine("6.- Eliminar un Nodo");
  110.                 Console.WriteLine("7.- Finalizar el Programa");
  111.                 Console.WriteLine("");
  112.                 Console.Write("Teclee la Opcion Deseada: ");
  113.                 Resultado=int.Parse(Console.ReadLine());
  114.                 Console.WriteLine("");
  115.                 if(Resultado<1||Resultado>7)
  116.                 {
  117.                     Console.WriteLine("ERROR, Opcion Invalida....");
  118.                     Console.ReadLine();
  119.                     Console.WriteLine("");
  120.                 }
  121.                 ClearMyConsole.Clear();
  122.             }while(Resultado<1||Resultado>7);
  123.             return Resultado;
  124.         }
  125.         //Insertar en un arbol binario
  126.         static void Insertar(NodoT Raiz, int Dato)
  127.         {
  128.             if(Dato<Raiz.Informacion)
  129.             {
  130.                 if(Raiz.NodoIzquierdo==null)
  131.                 {
  132.                     NodoT NuevoNodo=new NodoT();
  133.                     NuevoNodo.Informacion=Dato;
  134.                     Raiz.NodoIzquierdo=NuevoNodo;
  135.                 }
  136.                 else
  137.                 {
  138.                     //Llamada recursiva
  139.                     Insertar(Raiz.NodoIzquierdo, Dato);
  140.                 }
  141.             }
  142.             else//Buscar por el lado derecho
  143.             {
  144.                 if(Dato>Raiz.Informacion)
  145.                 {
  146.                     if(Raiz.NodoDerecho==null)
  147.                     {
  148.                         NodoT NuevoNodo=new NodoT();
  149.                         NuevoNodo.Informacion=Dato;
  150.                         Raiz.NodoDerecho=NuevoNodo;
  151.                     }
  152.                     else
  153.                     {
  154.                         //Llamada recursiva por el lado derecho
  155.                         Insertar(Raiz.NodoDerecho, Dato);
  156.                     }
  157.                 }
  158.                 else
  159.                 {
  160.                     //El Nodo existe en el Arbol
  161.                     Console.WriteLine("Nodo Existente, Imposible Insertar...");
  162.                     Console.ReadLine();
  163.                 }
  164.             }
  165.         }
  166.         //Metodo de recorrido en Pre-Orden
  167.         static void RecorridoPreorden(NodoT Raiz)
  168.         {
  169.             if(Raiz!=null)
  170.             {
  171.                 Console.Write("{0}, ",Raiz.Informacion);
  172.                 RecorridoPreorden(Raiz.NodoIzquierdo);
  173.                 RecorridoPreorden(Raiz.NodoDerecho);
  174.             }
  175.         }
  176.         //Metodo de recorrido en In-Orden
  177.         static void RecorridoInorden(NodoT Raiz)
  178.         {
  179.             if(Raiz!=null)
  180.             {
  181.                 RecorridoInorden(Raiz.NodoIzquierdo);
  182.                 Console.Write("{0}, ",Raiz.Informacion);               
  183.                 RecorridoInorden(Raiz.NodoDerecho);
  184.             }
  185.         }
  186.         //Metodo de recorrido en Post-Orden
  187.         static void RecorridoPostorden(NodoT Raiz)
  188.         {
  189.             if(Raiz!=null)
  190.             {
  191.                 RecorridoPostorden(Raiz.NodoIzquierdo);                            
  192.                 RecorridoPostorden(Raiz.NodoDerecho);
  193.                 Console.Write("{0}, ",Raiz.Informacion);
  194.             }
  195.         }
  196.         //Metodo de Buscar un nodo
  197.         static void BuscarNodo(NodoT Raiz, int Dato)
  198.         {
  199.             if(Dato<Raiz.Informacion)
  200.             {
  201.                 //Buscar por el Sub-Arbol izquierdo
  202.                 if(Raiz.NodoIzquierdo==null)
  203.                 {
  204.                     Console.WriteLine("ERROR, No se encuentra el Nodo...");
  205.                     Console.ReadLine();
  206.                 }
  207.                 else
  208.                 {
  209.                     BuscarNodo(Raiz.NodoIzquierdo, Dato);
  210.                 }
  211.             }
  212.             else
  213.             {
  214.                 if(Dato>Raiz.Informacion)
  215.                 {
  216.                     //Buscar por el Sub-Arbol derecho
  217.                     if(Raiz.NodoDerecho==null)
  218.                     {
  219.                         Console.WriteLine("ERROR, No se encuentra el Nodo...");
  220.                         Console.ReadLine();
  221.                     }
  222.                     else
  223.                     {
  224.                         BuscarNodo(Raiz.NodoDerecho, Dato);
  225.                     }
  226.                 }
  227.                 else
  228.                 {
  229.                     //El nodo se encontro
  230.                     Console.WriteLine("Nodo Localizado en el Arbol...");
  231.                     Console.ReadLine();
  232.                 }
  233.             }
  234.         }
  235.         //Metodo de Eliminar
  236.         static void EliminarNodo(ref NodoT Raiz, int Dato)
  237.         {
  238.             if(Raiz!=null)
  239.             {
  240.                 if(Dato<Raiz.Informacion)
  241.                 {
  242.                     EliminarNodo(ref Raiz.NodoIzquierdo, Dato);
  243.                 }
  244.                 else
  245.                 {
  246.                     if(Dato>Raiz.Informacion)
  247.                     {
  248.                         EliminarNodo(ref Raiz.NodoDerecho, Dato);
  249.                     }
  250.                     else
  251.                     {
  252.                         //Si lo Encontro
  253.                         NodoT NodoEliminar=Raiz;
  254.                         if(NodoEliminar.NodoDerecho==null)
  255.                         {
  256.                             Raiz=NodoEliminar.NodoIzquierdo;
  257.                         }
  258.                         else
  259.                         {
  260.                             if(NodoEliminar.NodoIzquierdo==null)
  261.                             {
  262.                                 Raiz=NodoEliminar.NodoDerecho;
  263.                             }
  264.                             else
  265.                             {
  266.                                 NodoT AuxiliarNodo=null;
  267.                                 NodoT Auxiliar=Raiz.NodoIzquierdo;
  268.                                 bool Bandera=false;
  269.                                 while(Auxiliar.NodoDerecho!=null)
  270.                                 {
  271.                                     AuxiliarNodo=Auxiliar;
  272.                                     Auxiliar=Auxiliar.NodoDerecho;
  273.                                     Bandera=true;
  274.                                 }
  275.                                 Raiz.Informacion=Auxiliar.Informacion;
  276.                                 NodoEliminar=Auxiliar;
  277.                                 if(Bandera==true)
  278.                                 {
  279.                                     AuxiliarNodo.NodoDerecho=Auxiliar.NodoIzquierdo;
  280.                                 }
  281.                                 else
  282.                                 {
  283.                                     Raiz.NodoIzquierdo=Auxiliar.NodoIzquierdo;
  284.                                 }
  285.                             }
  286.                         }
  287.                     }
  288.                 }              
  289.             }
  290.             else
  291.             {
  292.                 Console.WriteLine("ERROR, EL Nodo no se Encuentra en el Arbol...");
  293.                 Console.ReadLine();
  294.             }
  295.         }
  296.         //Metodo de Finalizacion
  297.         static void Finalizar()
  298.         {
  299.             Console.WriteLine("Fin del Programa, press any key to continue,...");
  300.             Console.ReadLine();
  301.         }
  302.     }
  303.  
COMPAÑEROS VENIMOS CONTENTOS A LAS VOZ DE NUESTRO CORAZON...CORAZON...
Y AL CARIÑO QUE TODO TENEMOS AL GLORIOSO PENTATHLON...PENTATHLON...

lexor

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #2 en: Martes 4 de Noviembre de 2008, 04:07 »
0
compa, gracias por la ayuda, lo queria para estudiar y compararlo con los recorridos que tengo por aqui, me fueron muy utiles. Si no es mucho pedir me gustaria ver si tienes algo sobre digrafos, es el tema que nos imparten en estos momentos en mi universidad.
Muchas gracias

LEGOLASYEE

  • Miembro activo
  • **
  • Mensajes: 42
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #3 en: Martes 4 de Noviembre de 2008, 04:44 »
0
mmm sobre los digrafos creo que no, deja ver si tengo algo pero no creo, y que temas ven ustedes y de que escuela eres.
COMPAÑEROS VENIMOS CONTENTOS A LAS VOZ DE NUESTRO CORAZON...CORAZON...
Y AL CARIÑO QUE TODO TENEMOS AL GLORIOSO PENTATHLON...PENTATHLON...

lexor

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #4 en: Miércoles 5 de Noviembre de 2008, 06:48 »
0
compa, mis saludos.
Estudio Ing. Informatica en la Universidad de Matanzas, en Cuba, curso el segundo año.
En primer año recibi Introduccion a la programacion orientada a objetos en c#, con conceptos basicos de creacion de clases, metodos, bucles repetitivos (for.., while..do, etc ), condiciones (if... else..., switch..case), arreglos unidimencionales, bidimencionales e irregulares, etc. Eso fue el primer semestre. En el segundo semestre recibi Programacion I, con herencia, interfaces, polimorfismo, ect. Y ahora en segundo año estoy recibiendo recursividad, arboles, grafos y nos falta por dar busqueda y ordenamiendo.
Si necesitas algo de estos temas me lo dices y te lo mando, y si no encuentras sobre grafos me dices y te mando lo que he implementado por aqui.
Saludos.

Cesar77

  • Nuevo Miembro
  • *
  • Mensajes: 2
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #5 en: Jueves 13 de Noviembre de 2008, 02:15 »
0
saludos a ambos!
Bueno soy una persona mas interesada en la programacion, respecto a los temas que estan tratando son de mi interes y quisiera saber si me pudieran pasar algunas de sus aplicaciones son solo para estudiar y hacer algo asi como un libro de eso (claro que entienda) para que cuando tenga dudas sepa de donde consultar, solo por si no me creen estudio en la universidad tecnologica de puebla; se los agradeceria mucho si me hicieran ese favor.
y si no fuera abuso me pasaran apuntes desde lo primero para que este completa esta recopilacion, y si la quisieran despues con todo gusto se los propocionare(si esta completo o con lo que tenga).
si me pudieran mandar alguna respuesta a mi correo sera mejor, es: sweeting_77@hotmail.com

Por lo Pronto Gracias!

Cesar77

  • Nuevo Miembro
  • *
  • Mensajes: 2
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #6 en: Jueves 13 de Noviembre de 2008, 23:14 »
0
Con un pequeño aporte de todos se logran muchas cosas!
Gracias por la ayuda!

Lasker_11

  • Nuevo Miembro
  • *
  • Mensajes: 6
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #7 en: Martes 9 de Diciembre de 2008, 17:32 »
0
Saludos a todos, bueno dejare mi opinion a un tema que de por si ya esta cerrado :), los arboles en C++ y en Java tiene un gigantesco parecido he hecho algunos como para sustentar mi  opinion y pues cada dia me convenzo un poco mas de que las listas enlazadas(y su implementacion: Arboles) manejan los mismos principios de enlace y recorrido asi que la frase favorita de la programacion podria ser cierta: "El que domina un lenguaje de programacion... Los domina todos"
Bueno fuera no es asi :) .
hasta luego.

roydel87

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #8 en: Viernes 13 de Marzo de 2009, 17:00 »
0
hola lasker_11 queria saber si me puedes ayudar a implementar un arbol b+ con listas enlazadas por favor si puedes me escribes a roydel_h@hotmail.com

foapanghelo

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #9 en: Jueves 2 de Abril de 2009, 17:28 »
0
Hola que tal soy estudiante de programacion de Universidad central del ecuador. Porfavor si me podrias explicar que significa esto: ClearConsole. Trato de compilarle en vs.net 2005 y me da un error.
Gracias.

Jerkylink

  • Nuevo Miembro
  • *
  • Mensajes: 2
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #10 en: Sábado 2 de Mayo de 2009, 09:06 »
0
Si no es mucha molestia, me podrian explicar la recursividad que se usa en los metodos de Recorridos porfavor y gracias de antemano.

angelus007

  • Nuevo Miembro
  • *
  • Mensajes: 3
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #11 en: Jueves 18 de Junio de 2009, 00:52 »
0
Amigo.
Hola estudio ingenieria informatica en Arequipa-Peru y me an dejado que haga un programa que resuelva ecuaciones con arboles binarios osea algo asi :
2+4*5/(2-1*(9+6)) algo asi. ya ise la distribucion de los numeros y los simbolos en cada nodo pero no hallo la forma de resolverlo. Algunos companeros ya casi lo an resuelto pero no hallan la forma de como resolver un parentesis dentro de otro parentesis, porfa amigo podrias darme la solucion es muy urgente el Profesor ta que molesta muxo con este ejercicio pofa amigo si podrias resolverlo.......
De antemano gracias..
porfa respondeme a mi correo angelus-007@hot...
PD: el profe es una mi...... que solo nos dio la teoria de un arbol y too lo hacemos nosotros disq pa motivarnos aser mejores..

ChemoKaiba

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #12 en: Sábado 4 de Julio de 2009, 18:32 »
0
Cita de: "angelus007"
Amigo.
Hola estudio ingenieria informatica en Arequipa-Peru y me an dejado que haga un programa que resuelva ecuaciones con arboles binarios osea algo asi :
2+4*5/(2-1*(9+6)) algo asi. ya ise la distribucion de los numeros y los simbolos en cada nodo pero no hallo la forma de resolverlo. Algunos companeros ya casi lo an resuelto pero no hallan la forma de como resolver un parentesis dentro de otro parentesis, porfa amigo podrias darme la solucion es muy urgente el Profesor ta que molesta muxo con este ejercicio pofa amigo si podrias resolverlo.......
De antemano gracias..
porfa respondeme a mi correo angelus-007@hot...
PD: el profe es una mi...... que solo nos dio la teoria de un arbol y too lo hacemos nosotros disq pa motivarnos aser mejores..

Hola, tambien mi profesor me dejo lo mismo... y no puedo hacerlo :( uhmm pero por ahi averigue q los parentesis tienen q tener un contador,para ver cuando se cierra un nodo, y tb tienen q tener un peso mayor q el digito... un favor si ya lo has resuelto me lo podrias pasar mi correo es sbratt_35@hotmail.com gracias...

Roxany

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #13 en: Jueves 6 de Agosto de 2009, 22:50 »
0
Hola amigos soy nueva en esto de Programar..Por fis estoy que paso el codigo al C# pero me vota  que  ClearConsole ClearMyConsole = new ClearConsole(); le falta una directiva using o una referencia de ensamblado, es por el cual que te pido una ayudita para ver como le hago para que el programa corra. GRACIAS!
Roxany

MiguelAngel_Cod

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #14 en: Lunes 26 de Octubre de 2009, 22:13 »
0
holas people , cuanto a la duda de
Cita de: angelus007
Amigo.
.Este problema puede ser resuelto si es que usas el concepto de pilas asi,puedes utilizar un tokenizador y una relacion de presedencia en cuanto a las operaciones que utilices (incluyendo "()", "[]", "{}", y demas ) y zas problema resuelto, bytes. ^_^

ana isabel

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #15 en: Viernes 14 de Mayo de 2010, 17:29 »
0
HOLA NECESITO AYUDA SOBRE EL TEMA DE ARBOLES, ME GUSTARIA QUE ME ENVIARA UN EJEMPLO DE UN PROGRAMA ESTAMOS BATALLANDO EN LA IMPRESION.
GRACIAS

bugmenot2

  • Nuevo Miembro
  • *
  • Mensajes: 1
    • Ver Perfil
Re: Sobre Árboles en C#
« Respuesta #16 en: Viernes 29 de Junio de 2018, 16:55 »
0
using System;


namespace ejemplo{
   
public class NodoT
    {
        public NodoT NodoIzquierdo;
        public int Informacion;
        public NodoT NodoDerecho;
        //Constructor
        public NodoT()
        {
            this.NodoIzquierdo=null;
            this.Informacion=0;
            this.NodoDerecho=null;
        }
    }
    /// <summary>
    /// Summary description for Class1.
    /// </summary>
    class Class1
    {
        /// <summary>
        /// The main entry point for the application.
        /// </summary>
        [STAThread]
        static void Main(string[] args)
        {
//            ClearConsole ClearMyConsole = new ClearConsole();
            int Opcion=0;
            NodoT Raiz=null;
            int Dato;
            do
            {
                Opcion=Menu();
                switch(Opcion)
                {
                    case 1: Console.Write("Valor del Nuevo Nodo: ");
                            Dato=int.Parse(Console.ReadLine());
                            if(Raiz==null)
                            {
                                NodoT NuevoNodo=new NodoT();
                                NuevoNodo.Informacion=Dato;
                                Raiz=NuevoNodo;
                            }
                            else
                            {
                                Insertar(Raiz, Dato);
                            }
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                            //Recorrido en Pre Orden del Arbol
                    case 2: RecorridoPreorden(Raiz);
                            Console.WriteLine("Fin del Recorrido,...");
                            Console.ReadLine();
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                            //Recorrido en Post Orden del Arbol
                    case 3: RecorridoPostorden(Raiz);
                            Console.WriteLine("Fin del Recorrido,...");
                            Console.ReadLine();
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                            //Recorrido en In Orden del Arbol
                    case 4: RecorridoInorden(Raiz);
                            Console.WriteLine("Fin del Recorrido,...");
                            Console.ReadLine();
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                    case 5: Console.Write("Teclee el Dato a Buscar: ");
                            Dato=int.Parse(Console.ReadLine());
                            if(Raiz!=null)
                            {
                                BuscarNodo(Raiz, Dato);
                            }
                            else
                            {
                                Console.WriteLine("ERROR, Arbol Vacio....");
                            }                           
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                    case 6: Console.Write("Teclee el Dato a Eliminar: ");
                            Dato=int.Parse(Console.ReadLine());
                            if(Raiz!=null)
                            {
                                EliminarNodo(ref Raiz, Dato);
                            }
                            else
                            {
                                Console.WriteLine("ERROR, Arbol Vacio....");
                            }   
//                            ClearMyConsole.Clear();
                            Console.Clear();
                            break;
                    case 7: Finalizar();
                            break;
                }
            }while(Opcion!=7);
 
        }
        static int Menu()
        {
//            ClearConsole ClearMyConsole = new ClearConsole();
            int Resultado=0;
            do
            {
                Console.WriteLine("MENU DE ARBOLES");
                Console.WriteLine("");
                Console.WriteLine("1.- Registrar un Nuevo Nodo");
                Console.WriteLine("2.- Recorrido en Pre-orden");
                Console.WriteLine("3.- Recorrido en Post-orden");
                Console.WriteLine("4.- Recorrido en In-orden");
                Console.WriteLine("5.- Buscar un Nodo");
                Console.WriteLine("6.- Eliminar un Nodo");
                Console.WriteLine("7.- Finalizar el Programa");
                Console.WriteLine("");
                Console.Write("Teclee la Opcion Deseada: ");
                Resultado=int.Parse(Console.ReadLine());
                Console.WriteLine("");
                if(Resultado<1||Resultado>7)
                {
                    Console.WriteLine("ERROR, Opcion Invalida....");
                    Console.ReadLine();
                    Console.WriteLine("");
                }
//                ClearMyConsole.Clear();
                Console.Clear();
            }while(Resultado<1||Resultado>7);
            return Resultado;
        }
        //Insertar en un arbol binario
        static void Insertar(NodoT Raiz, int Dato)
        {
            if(Dato<Raiz.Informacion)
            {
                if(Raiz.NodoIzquierdo==null)
                {
                    NodoT NuevoNodo=new NodoT();
                    NuevoNodo.Informacion=Dato;
                    Raiz.NodoIzquierdo=NuevoNodo;
                }
                else
                {
                    //Llamada recursiva
                    Insertar(Raiz.NodoIzquierdo, Dato);
                }
            }
            else//Buscar por el lado derecho
            {
                if(Dato>Raiz.Informacion)
                {
                    if(Raiz.NodoDerecho==null)
                    {
                        NodoT NuevoNodo=new NodoT();
                        NuevoNodo.Informacion=Dato;
                        Raiz.NodoDerecho=NuevoNodo;
                    }
                    else
                    {
                        //Llamada recursiva por el lado derecho
                        Insertar(Raiz.NodoDerecho, Dato);
                    }
                }
                else
                {
                    //El Nodo existe en el Arbol
                    Console.WriteLine("Nodo Existente, Imposible Insertar...");
                    Console.ReadLine();
                }
            }
        }
        //Metodo de recorrido en Pre-Orden
        static void RecorridoPreorden(NodoT Raiz)
        {
            if(Raiz!=null)
            {
                Console.Write("{0}, ",Raiz.Informacion);
                RecorridoPreorden(Raiz.NodoIzquierdo);
                RecorridoPreorden(Raiz.NodoDerecho);
            }
        }
        //Metodo de recorrido en In-Orden
        static void RecorridoInorden(NodoT Raiz)
        {
            if(Raiz!=null)
            {
                RecorridoInorden(Raiz.NodoIzquierdo);
                Console.Write("{0}, ",Raiz.Informacion);               
                RecorridoInorden(Raiz.NodoDerecho);
            }
        }
        //Metodo de recorrido en Post-Orden
        static void RecorridoPostorden(NodoT Raiz)
        {
            if(Raiz!=null)
            {
                RecorridoPostorden(Raiz.NodoIzquierdo);                             
                RecorridoPostorden(Raiz.NodoDerecho);
                Console.Write("{0}, ",Raiz.Informacion);
            }
        }
        //Metodo de Buscar un nodo
        static void BuscarNodo(NodoT Raiz, int Dato)
        {
            if(Dato<Raiz.Informacion)
            {
                //Buscar por el Sub-Arbol izquierdo
                if(Raiz.NodoIzquierdo==null)
                {
                    Console.WriteLine("ERROR, No se encuentra el Nodo...");
                    Console.ReadLine();
                }
                else
                {
                    BuscarNodo(Raiz.NodoIzquierdo, Dato);
                }
            }
            else
            {
                if(Dato>Raiz.Informacion)
                {
                    //Buscar por el Sub-Arbol derecho
                    if(Raiz.NodoDerecho==null)
                    {
                        Console.WriteLine("ERROR, No se encuentra el Nodo...");
                        Console.ReadLine();
                    }
                    else
                    {
                        BuscarNodo(Raiz.NodoDerecho, Dato);
                    }
                }
                else
                {
                    //El nodo se encontro
                    Console.WriteLine("Nodo Localizado en el Arbol...");
                    Console.ReadLine();
                }
            }
        }
        //Metodo de Eliminar
        static void EliminarNodo(ref NodoT Raiz, int Dato)
        {
            if(Raiz!=null)
            {
                if(Dato<Raiz.Informacion)
                {
                    EliminarNodo(ref Raiz.NodoIzquierdo, Dato);
                }
                else
                {
                    if(Dato>Raiz.Informacion)
                    {
                        EliminarNodo(ref Raiz.NodoDerecho, Dato);
                    }
                    else
                    {
                        //Si lo Encontro
                        NodoT NodoEliminar=Raiz;
                        if(NodoEliminar.NodoDerecho==null)
                        {
                            Raiz=NodoEliminar.NodoIzquierdo;
                        }
                        else
                        {
                            if(NodoEliminar.NodoIzquierdo==null)
                            {
                                Raiz=NodoEliminar.NodoDerecho;
                            }
                            else
                            {
                                NodoT AuxiliarNodo=null;
                                NodoT Auxiliar=Raiz.NodoIzquierdo;
                                bool Bandera=false;
                                while(Auxiliar.NodoDerecho!=null)
                                {
                                    AuxiliarNodo=Auxiliar;
                                    Auxiliar=Auxiliar.NodoDerecho;
                                    Bandera=true;
                                }
                                Raiz.Informacion=Auxiliar.Informacion;
                                NodoEliminar=Auxiliar;
                                if(Bandera==true)
                                {
                                    AuxiliarNodo.NodoDerecho=Auxiliar.NodoIzquierdo;
                                }
                                else
                                {
                                    Raiz.NodoIzquierdo=Auxiliar.NodoIzquierdo;
                                }
                            }
                        }
                    }
                }               
            }
            else
            {
                Console.WriteLine("ERROR, EL Nodo no se Encuentra en el Arbol...");
                Console.ReadLine();
            }
        }
        //Metodo de Finalizacion
        static void Finalizar()
        {
            Console.WriteLine("Fin del Programa, presione una tecla para continuar,...");
            Console.ReadLine();
        }
    }
}