示例#1
0
        private string inorden2(AVL rama, ref string cadena)
        {
            if (rama != null)
            {
                inorden2(rama.NodoIzquierdo, ref cadena);

                visitar(rama, ref cadena);

                inorden2(rama.NodoDerecho, ref cadena);
            }

            return(cadena);
        }
示例#2
0
文件: AVL.cs 项目: Gissela25/PED-2020
        //Funcion para insertar nuevo valor en el arbol AVL
        public AVL Insertar(int valorNuevo, AVL Raiz)
        {
            if (Raiz == null)
            {
                Raiz = new AVL(valorNuevo, null, null, null);
            }
            else if (valorNuevo < Raiz.valor)
            {
                Raiz.NodoIzquierdo = Insertar(valorNuevo, Raiz.NodoIzquierdo);
            }
            else if (valorNuevo > Raiz.valor)
            {
                Raiz.NodoDerecho = Insertar(valorNuevo, Raiz.NodoDerecho);
            }
            else
            {
                MessageBox.Show("Valor existente en el Arbol", "Error", MessageBoxButtons.OK);
            }


            //Realizar las rotaciones simples o dobles segun caso
            if (Alturas(Raiz.NodoIzquierdo) - Alturas(Raiz.NodoDerecho) == 2)
            {
                if (valorNuevo < Raiz.NodoIzquierdo.valor)
                {
                    Raiz = RotacionIzquierdaSimple(Raiz);
                }
                else
                {
                    Raiz = RotacionIzquierdaDoble(Raiz);
                }
            }
            if (Alturas(Raiz.NodoDerecho) - Alturas(Raiz.NodoIzquierdo) == 2)
            {
                if (valorNuevo > Raiz.NodoDerecho.valor)
                {
                    Raiz = RotacionDerechaSimple(Raiz);
                }
                else
                {
                    Raiz = RotacionDerechaDoble(Raiz);
                }
            }
            Raiz.altura = max(Alturas(Raiz.NodoIzquierdo), Alturas(Raiz.NodoDerecho)) + 1;
            return(Raiz);
        }
示例#3
0
文件: AVL.cs 项目: Gissela25/PED-2020
 //Buscar un valor en el arbol
 public void buscar(int valorBuscar, AVL Raiz)
 {
     if (Raiz != null)
     {
         if (valorBuscar < Raiz.valor)
         {
             buscar(valorBuscar, Raiz.NodoIzquierdo);
         }
         else
         {
             if (valorBuscar > Raiz.valor)
             {
                 buscar(valorBuscar, Raiz.NodoDerecho);
             }
         }
     }
     else
     {
         MessageBox.Show("Valor no encontrado", "Error", MessageBoxButtons.OK);
     }
 }
示例#4
0
文件: AVL.cs 项目: Gissela25/PED-2020
 private static int Alturas(AVL Raiz)
 {
     return(Raiz == null ? -1 : Raiz.altura);
 }
示例#5
0
文件: AVL.cs 项目: Gissela25/PED-2020
 //Doble Rotacion Derecha
 private static AVL RotacionDerechaDoble(AVL k1)
 {
     k1.NodoDerecho = RotacionIzquierdaSimple(k1.NodoDerecho);
     return(RotacionDerechaSimple(k1));
 }
示例#6
0
文件: AVL.cs 项目: Gissela25/PED-2020
 //Doble Rotacion Izquierda
 private static AVL RotacionIzquierdaDoble(AVL k3)
 {
     k3.NodoDerecho = RotacionDerechaSimple(k3.NodoIzquierdo);
     return(RotacionIzquierdaSimple(k3));
 }
示例#7
0
文件: AVL.cs 项目: Gissela25/PED-2020
        public AVL Eliminar(int valorEliminar, ref AVL Raiz)
        {
            if (Raiz != null)
            {
                if (valorEliminar < Raiz.valor)
                {
                    nodoE = Raiz;
                    Eliminar(valorEliminar, ref Raiz.NodoIzquierdo);
                }
                else
                {
                    if (valorEliminar > Raiz.valor)
                    {
                        nodoE = Raiz;
                        Eliminar(valorEliminar, ref Raiz.NodoDerecho);
                    }
                    else
                    {
                        //posicionado sobre el elemento a eliminar
                        AVL NodoEliminar = Raiz;
                        if (NodoEliminar.NodoDerecho == null)
                        {
                            Raiz = NodoEliminar.NodoIzquierdo;

                            if (Alturas(nodoE.NodoIzquierdo) - Alturas(nodoE.NodoDerecho) == 2)
                            {
                                if (valorEliminar < nodoE.valor)
                                {
                                    nodoP = RotacionIzquierdaSimple(nodoE);
                                }
                                else
                                {
                                    nodoE = RotacionDerechaSimple(nodoE);
                                }
                            }
                            if (Alturas(nodoE.NodoDerecho) - Alturas(nodoE.NodoIzquierdo) == 2)
                            {
                                if (valorEliminar > nodoE.NodoDerecho.valor)
                                {
                                    nodoE = RotacionDerechaSimple(nodoE);
                                }
                                else
                                {
                                    nodoE = RotacionDerechaDoble(nodoE);
                                }
                                nodoP = RotacionDerechaSimple(nodoE);
                            }
                            else
                            {
                                if (NodoEliminar.NodoIzquierdo == null)
                                {
                                    Raiz = NodoEliminar.NodoDerecho;
                                }
                                else
                                {
                                    if (Alturas(Raiz.NodoIzquierdo) - Alturas(Raiz.NodoDerecho) > 0)
                                    {
                                        AVL  AuxiliarNodo = null;
                                        AVL  Auxiliar     = Raiz.NodoIzquierdo;
                                        bool Bandera      = false;
                                        while (Auxiliar.NodoDerecho != null)
                                        {
                                            AuxiliarNodo = Auxiliar;
                                            Auxiliar     = Auxiliar.NodoDerecho;
                                            Bandera      = true;
                                        }
                                        Raiz.valor   = Auxiliar.valor;
                                        NodoEliminar = Auxiliar;
                                        if (Bandera == true)
                                        {
                                            AuxiliarNodo.NodoDerecho = Auxiliar.NodoIzquierdo;
                                        }
                                        else
                                        {
                                            Raiz.NodoIzquierdo = Auxiliar.NodoIzquierdo;
                                        }//Realiza las operaciones simples o dobles segun sea el caso
                                    }
                                    else
                                    {
                                        if (Alturas(Raiz.NodoDerecho) - Alturas(Raiz.NodoIzquierdo) > 0)
                                        {
                                            AVL  AuxiliarNodo = null;
                                            AVL  Auxiliar     = Raiz.NodoDerecho;
                                            bool Bandera      = false;
                                            while (Auxiliar.NodoIzquierdo != null)
                                            {
                                                AuxiliarNodo = Auxiliar;
                                                Auxiliar     = Auxiliar.NodoIzquierdo;
                                                Bandera      = true;
                                            }
                                            Raiz.valor   = Auxiliar.valor;
                                            NodoEliminar = Auxiliar;
                                            if (Bandera == true)
                                            {
                                                AuxiliarNodo.NodoIzquierdo = Auxiliar.NodoDerecho;
                                            }
                                            else
                                            {
                                                Raiz.NodoDerecho = Auxiliar.NodoDerecho;
                                            }
                                        }
                                        else
                                        {
                                            if (Alturas(Raiz.NodoDerecho) - Alturas(Raiz.NodoIzquierdo) == 0)
                                            {
                                                AVL  AuxiliarNodo = null;
                                                AVL  Auxiliar     = Raiz.NodoIzquierdo;
                                                bool Bandera      = false;
                                                while (Auxiliar.NodoDerecho != null)
                                                {
                                                    AuxiliarNodo = Auxiliar;
                                                    Auxiliar     = Auxiliar.NodoDerecho;
                                                    Bandera      = true;
                                                }
                                                Raiz.valor   = Auxiliar.valor;
                                                NodoEliminar = Auxiliar;
                                                if (Bandera == true)
                                                {
                                                    AuxiliarNodo.NodoDerecho = Auxiliar.NodoIzquierdo;
                                                }
                                                else
                                                {
                                                    Raiz.NodoIzquierdo = Auxiliar.NodoIzquierdo;
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                MessageBox.Show("Nodo inexistente en el árbol", "Error", MessageBoxButtons.OK);
            }
            return(nodoP);
        }
示例#8
0
        public void colorear(Graphics grafo, Font fuente, Brush Relleno, Brush RellenoFuente, Pen Lapiz, AVL Raiz, bool post, bool inor, bool preor)
        {
            Brush entorno = Brushes.Red;

            if (inor == true)
            {
                if (Raiz != null)
                {
                    colorear(grafo, fuente, Brushes.Blue, RellenoFuente, Lapiz, Raiz.NodoIzquierdo, post, inor, preor);
                    Raiz.colorear(grafo, fuente, entorno, RellenoFuente, Lapiz);
                    Thread.Sleep(500);
                    Raiz.colorear(grafo, fuente, Relleno, RellenoFuente, Lapiz);
                    colorear(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoDerecho, post, inor, preor);
                }
            }
            else if (preor == true)
            {
                if (Raiz != null)
                {
                    Raiz.colorear(grafo, fuente, Brushes.Yellow, Brushes.Blue, Pens.Black);
                    Thread.Sleep(500);
                    Raiz.colorear(grafo, fuente, Brushes.White, Brushes.Black, Pens.Black);
                    colorear(grafo, fuente, Brushes.Blue, RellenoFuente, Lapiz, Raiz.NodoIzquierdo, post, inor, preor);
                    colorear(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoDerecho, post, inor, preor);
                }
            }
            else if (post == true)
            {
                if (Raiz != null)
                {
                    colorear(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoIzquierdo, post, inor, preor);
                    colorear(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoDerecho, post, inor, preor);
                    Raiz.colorear(grafo, fuente, entorno, RellenoFuente, Lapiz);
                    Thread.Sleep(500);
                    Raiz.colorear(grafo, fuente, entorno, RellenoFuente, Lapiz);
                }
            }
        }
示例#9
0
 public DibujaAVL(AVL RaizNueva)
 {
     Raiz = RaizNueva;
 }
示例#10
0
 //Constructor
 public DibujaAVL()
 {
     aux = new AVL();
 }
示例#11
0
        public void colorearB(Graphics grafo, Font fuente, Brush Relleno, Brush RellenoFuente, Pen Lapiz, AVL Raiz, int busqueda)
        {
            Brush entorno = Brushes.Red;

            if (Raiz != null)
            {
                Raiz.colorear(grafo, fuente, entorno, RellenoFuente, Lapiz);
                if (busqueda < Raiz.valor)
                {
                    Thread.Sleep(500);
                    Raiz.colorear(grafo, fuente, entorno, Brushes.Blue, Lapiz);
                    colorearB(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoIzquierdo, busqueda);
                }
                else
                {
                    if (busqueda > Raiz.valor)
                    {
                        Thread.Sleep(500);
                        Raiz.colorear(grafo, fuente, entorno, RellenoFuente, Lapiz);
                        colorearB(grafo, fuente, Relleno, RellenoFuente, Lapiz, Raiz.NodoDerecho, busqueda);
                    }
                    else
                    {
                        Raiz.colorear(grafo, fuente, entorno, Relleno, Lapiz);
                        Thread.Sleep(500);
                    }
                }
            }
        }