Пример #1
0
        public nodob insertar(ataque nuevo /*, unit atacante_, unit defensor_, DateTime restante_, int cont_*/)
        {
            //buscar nodo de inserción
            nodob insert = buscarinsert(nuevo, raiz);

            if (insert == null)
            {
                raiz   = new nodob(grado, tipo);
                insert = raiz;
            }
            //realizar la inserción
            insert.insertar(nuevo, null, null);
            //si el nodo está lleno, dividir el nodo
            if (insert.llaves[grado - 1] != null)
            {
                nodob ret = insert.dividir();
                if (ret.padre == null)
                {
                    raiz = ret;
                }
                return(ret);
            }
            else
            {
                return(insert);
            }
        }
Пример #2
0
        //método de división de nodos hoja
        public nodob dividir()
        {//cuando el grado es impar, el valor del medio es llaves[grado/2]
         //metodo de prueba para llaves tipo int?

            /*int medio = llaves[grado/2].Value;
             * //hijo izquierdo
             * nodob izq = new nodob(grado);
             * //obtener lista de llaves izquierdas
             * for (int i = 0; i < grado / 2; i++) izq.llaves[i] = llaves[i];
             * //obtener lista de hijos izquierdos
             * for (int i = 0; i < grado / 2 + 1; i++) izq.hijos[i] = hijos[i];
             * //hijo derecho
             * nodob der = new nodob(grado);
             * //obtener lista de llaves derechas
             * for (int i = grado/2 +1; i < grado; i++) der.llaves[i] = llaves[i];
             * //obtener lista de hijos derechos
             * for (int i = grado/2 + 1; i < grado + 1; i++) der.hijos[i] = hijos[i];
             * //insertar los valores en el nodo padre
             * if(padre == null) padre = new nodob(grado);
             * padre.insertar(medio, izq, der);
             * return padre;*/
            //metodo para llaves tipo ataque
            ataque medio = llaves[grado / 2];
            //hijo izquierdo
            nodob izq = new nodob(grado, this.tipo);

            //obtener lista de llaves izquierdas
            for (int i = 0; i < grado / 2; i++)
            {
                izq.llaves[i] = llaves[i];
            }
            //obtener lista de hijos izquierdos
            for (int i = 0; i < grado / 2 + 1; i++)
            {
                izq.hijos[i] = hijos[i];
            }
            //hijo derecho
            nodob der = new nodob(grado, this.tipo);

            //obtener lista de llaves derechas
            for (int i = grado / 2 + 1; i < grado; i++)
            {
                der.llaves[i - (grado / 2) - 1] = llaves[i];
            }
            //obtener lista de hijos derechos
            for (int i = grado / 2 + 1; i < grado + 1; i++)
            {
                der.hijos[i - (grado / 2) - 1] = hijos[i];
            }
            //insertar los valores en el nodo padre
            if (padre == null)
            {
                padre = new nodob(grado, this.tipo);
            }
            padre.insertar(medio, izq, der);
            return(padre);
        }
Пример #3
0
        public void combinarhijos(int pos, bool eliminar)
        {
            //int?[] insert = new int?[grado + 1];
            ataque[] insert = new ataque[grado + 1];
            if (eliminar == false)       //no se debe eliminar la llave
            {
                insert[0] = llaves[pos]; //obtener llave a mover
                                         //agregar el resto de las llaves del hijo izquierdo
                for (int i = 0; i < grado; i++)
                {
                    insert[i + 1] = hijos[pos + 1].llaves[i];
                }
            }//agregar sólo las llaves del hijo izquierdo
            else
            {
                for (int i = 0; i < grado; i++)
                {
                    insert[i] = hijos[pos + 1].llaves[i];
                }
            }
            //correr las llaves
            for (int i = pos; i < grado - 1; i++)
            {
                llaves[i] = llaves[i + 1];
            }
            llaves[grado - 1] = null;
            //obtener hijo que se va a combinar
            nodob hijocomb = hijos[pos + 1];//hijo derecho a la llave

            //correr hijos
            for (int i = pos + 1; i < grado; i++)
            {
                hijos[i] = hijos[i + 1];
            }
            //reinsertar las llaves al nodo
            for (int i = 0; i < grado + 1; i++)
            {
                if (insert[i] != null)
                {
                    this.insertar(insert[i], null, null);
                }
            }
        }
Пример #4
0
        //método de inserción en nodo
        public void insertar(/*int n,*/ ataque ingreso, nodob nodoizq, nodob nododer)
        {
            //inserción de la llave
            int temp = 0;

            if (llaves[temp] == null)
            {
                llaves[temp] = ingreso;
            }
            else
            {
                //obtener el espacio de la inserción
                while (llaves[temp] != null)
                {
                    //ordenamiento por fecha
                    if (tipo == 0)
                    {
                        if (llaves[temp].fecha == ingreso.fecha)
                        {//encontrar la posición si la fecha es igual
                            if (llaves[temp].cont > ingreso.cont)
                            {
                                break;                                  //posición actual
                            }
                            else if (llaves[temp].cont < ingreso.cont)
                            {
                                temp++;//posición siguiente
                                //if (temp == grado) break;
                            }
                        }
                        else if (llaves[temp].fecha > ingreso.fecha)
                        {
                            break;
                        }
                        else
                        {
                            temp++;
                        }
                    }
                    //ordenamiento por numero
                    else if (tipo == 1)
                    {
                        if (llaves[temp].cont >= ingreso.cont)
                        {
                            break;
                        }
                        else
                        {
                            temp++;
                        }
                    }
                }
                //copiar el arreglo de llaves
                //int?[] aux = new int?[grado];

                ataque[] aux = new ataque[grado];
                aux = llaves;
                //insertar la nueva llave
                aux[temp] = ingreso;
                //correr los elementos
                for (int i = temp + 1; i < grado; i++)
                {
                    aux[i] = llaves[i];
                }
                llaves = aux;//sustituir la lista de llaves
            }
            //inserción de los hijos
            if (nodoizq != null && nododer != null)
            {
                nodoizq.padre = this;
                nododer.padre = this;
                //copiar arreglo de hijos
                nodob[] nodotemp = new nodob[grado + 1];
                nodotemp = hijos;
                //insertar los valores
                nodotemp[temp]     = nodoizq;
                nodotemp[temp + 1] = nododer;
                //correr los elementos
                for (int j = temp + 2; j < grado + 1; j++)
                {
                    nodotemp[j] = hijos[j];
                }
                hijos = nodotemp;//sustituir los hijos
            }
        }
Пример #5
0
 //método de búsqueda de nodo para inserción, empieza por la raíz
 //actualizar para inserción con el mismo valor
 //public nodob buscarinsert(int n, nodob nodo)
 public nodob buscarinsert(ataque registro, nodob nodo)
 {
     if (nodo != null)
     {
         if (nodo.hijos[0] == null)
         {
             return(nodo);                      //el nodo es una hoja
         }
         else
         {
             int aux = 0;
             //buscar el hijo
             while (nodo.llaves[aux] != null)
             {
                 //buscar por fecha
                 if (tipo == 0)
                 {
                     if (nodo.llaves[aux].fecha == registro.fecha)
                     {//buscar por numero si la fecha es igual
                         if (nodo.llaves[aux].cont > registro.cont)
                         {
                             if (nodo.hijos[0] != null)
                             {
                                 return(buscarinsert(registro, nodo.hijos[aux]));
                             }
                             else
                             {
                                 return(nodo);
                             }
                         }
                         else
                         {
                             aux++; //continuar con la siguiente llave
                         }
                     }
                     else if (nodo.llaves[aux].fecha > registro.fecha)
                     {
                         return(buscarinsert(registro, nodo.hijos[aux]));
                     }
                     else
                     {
                         aux++;
                     }
                 }
                 //buscar por numero
                 else if (tipo == 1)
                 {
                     if (nodo.llaves[aux].cont > registro.cont)
                     {
                         return(buscarinsert(registro, nodo.hijos[aux]));
                     }
                     else
                     {
                         aux++;
                     }
                 }
             }
             //buscar en el último valor si todos los anteriores son menores
             return(buscarinsert(registro, nodo.hijos[aux]));
         }
     }
     else
     {
         return(null);
     }
 }
Пример #6
0
 //búsqueda de nodo
 //public nodob buscar(int n, nodob nodo)
 public nodob buscar(ataque registro, nodob nodo)
 {
     if (nodo != null)
     {
         if (nodo.llaves[0] != null)
         {
             int pos = 0;
             while (nodo.llaves[pos] != null)
             {
                 if (nodo.llaves[pos] == registro)
                 {
                     return(nodo);
                 }
                 else
                 {
                     if (tipo == 0)//búsqueda por fecha
                     {
                         if (nodo.llaves[pos].fecha == registro.fecha)
                         {//si la fecha es igual, comparar el número de ataque
                             if (nodo.llaves[pos].cont > registro.cont)
                             {
                                 if (nodo.hijos[pos] != null)
                                 {
                                     return(buscar(registro, nodo.hijos[pos]));
                                 }
                                 else
                                 {
                                     return(null);
                                 }
                             }
                         }
                         else if (nodo.llaves[pos].fecha > registro.fecha)
                         {
                             if (nodo.hijos[pos] != null)
                             {
                                 return(buscar(registro, nodo.hijos[pos]));
                             }
                             else
                             {
                                 return(null);
                             }
                         }
                         else
                         {
                             pos++;
                         }
                     }
                     else if (tipo == 1)//la búsqueda es por numero de ataque
                     {
                         if (nodo.llaves[pos].cont > registro.cont)
                         {
                             if (nodo.hijos[pos] != null)
                             {
                                 return(buscar(registro, nodo.hijos[pos]));
                             }
                             else
                             {
                                 return(null);
                             }
                         }
                         else
                         {
                             pos++;
                         }
                     }
                 }
             }
             if (nodo.hijos[pos] != null)
             {
                 return(buscar(registro, nodo.hijos[pos]));
             }
             else
             {
                 return(null);
             }
         }
         else
         {
             return(null);
         }
     }
     else
     {
         return(null);
     }
 }
Пример #7
0
        //eliminar llave del nodo
        //public void eliminar(int n)
        public void eliminar(ataque registro)
        {
            int pos = 0;

            while (llaves[pos] != null)
            {
                if (llaves[pos] == registro)
                {
                    break;                         //obtener la posición de la llave a eliminar
                }
                else
                {
                    pos++; //continuar con la búsqueda
                }
            }
            //el nodo es una hoja
            if (hijos[0] == null)
            {
                //int?[] nuevo = new int?[grado];//prueba con llaves tipo int?
                ataque[] nuevo = new ataque[grado];
                //copiar las llaves
                for (int i = 0; i < pos; i++)
                {
                    if (i != pos)
                    {
                        nuevo[i] = llaves[i];
                    }
                }
                for (int i = pos + 1; i < grado; i++)
                {
                    nuevo[i - 1] = llaves[i];
                }
                //verificar si se tiene la cantidad minima de llaves
                bool ismin = true;
                for (int i = 0; i < grado / 2; i++)
                {
                    if (nuevo[i] == null)
                    {
                        ismin = false;
                    }
                }
                if (ismin == false)
                {
                    //obtener nodo con las llaves del nodo y el nodo padre izquierdo
                    if (padre != null)
                    {
                        //int llaveadd = 0;
                        //ataque llaveadd;
                        try
                        {                                      //obtener la llave izquierda del padre
                            if (padre.llaves[pos - 1] != null) //llaveadd = padre.llaves[pos - 1];
                            {
                                padre.combinarhijos(pos - 1, false);
                            }                                       //combinar los hijos de la llave del padre, sin eliminar la llave
                        }
                        catch (IndexOutOfRangeException e)
                        {                                    //padre.llaves[pos-1] está fuera del rango, se toma la llave derecha del padre por ser el primer elemento
                            //llaveadd = padre.llaves[pos];
                            padre.combinarhijos(pos, false); //combinar los hijos de la llave del padre, sin eliminar la llave
                        }
                    }
                }//else, se ha eliminado un elemento y el nodo tiene el número mímmino de elementos
            }
            //el nodo no es una hoja
            else
            {
                //verificar si el hijo izquierdo puede donar una llave
                nodob hijo = hijos[pos];
                int   cont = 0;
                while (hijo.llaves[cont] != null)
                {
                    cont++;
                }
                if (cont > grado / 2)
                {                                             //el hijo izquierdo tiene suficientes elementos para donar el mayor
                    ataque sustituto = hijo.llaves[cont - 1]; //obtener la llave mayor
                    hijo.eliminar(sustituto);                 //eliminar el elemento mayor en el hijo
                    llaves[pos] = sustituto;                  //correr la llave mayor a la lista de llaves
                }
                else
                {//verificar si el hijo derecho puede donar una llave
                    cont = 0;
                    hijo = hijos[pos + 1];
                    while (hijo.llaves[cont] != null)
                    {
                        cont++;
                    }
                    if (cont > grado / 2)
                    {                                      //el hijo derecho tiene suficientes elementos para donar el menor
                        ataque sustituto = hijo.llaves[0]; //obtener la llave menor
                        hijo.eliminar(sustituto);          //eliminar el elemento mayor en el hijo
                        llaves[pos] = sustituto;           //correr la llave mayor a la lista de llaves
                    }
                    //ninguno de los hijos tiene suficientes llaves
                    else
                    {
                        this.combinarhijos(pos, true); //combinar hijos, eliminar llave
                    }
                }
            }
        }