static void Main(string[] args)
        {
            Lista_Ligada lista = new Lista_Ligada();

            lista.Agregar(77);
            lista.Agregar(34);
            lista.Agregar(68);
            lista.Agregar(24);
            lista.Agregar(75);
            lista.Transversa();

            Lista_Ligada mergeSort = new Lista_Ligada();

            mergeSort = MergeSortMethod(lista);
            mergeSort.Transversa();
            //Lista_Ligada izq = new Lista_Ligada();
            //izq.Agregar(1);
            //izq.Agregar(3);
            //izq.Agregar(5);
            //izq.Agregar(7);
            //izq.Transversa();

            //Lista_Ligada der = new Lista_Ligada();
            //der.Agregar(2);
            //der.Agregar(4);
            //der.Agregar(6);
            //der.Agregar(8);
            //der.Agregar(10);
            //der.Agregar(12);
            //der.Transversa();

            //Lista_Ligada merged = Merge(izq, der);
            //merged.Transversa();
        }
        private static Lista_Ligada Merge(Lista_Ligada izq, Lista_Ligada der)
        {
            // Lista dónde se unen los valores
            Lista_Ligada union = new Lista_Ligada();
            // Indices de cada lista.
            int indexIzq = 1;
            int indexDer = 1;
            // Cantidad de elementos.
            int cantIzq = izq.getSize() + 1;
            int cantDer = der.getSize() + 1;

            // Recorremos los elementos mientras las 2 listas tengan elementos para procesar.
            while (indexIzq < cantIzq && indexDer < cantDer)
            {
                // Si el de la izquierda es menor o igual adicionamos el de la izquierda.
                if (izq[indexIzq] <= der[indexDer])
                {
                    union.Agregar((int)izq[indexIzq]);
                    // Avanzamos el indice izquierdo.
                    indexIzq++;
                }
                else // Si el de la derecha es menor, adicionamos el de la derecha.
                {
                    union.Agregar((int)der[indexDer]);
                    // Avanzamos el indice derecho.
                    indexDer++;
                }
            }

            // Si en dado caso han sobrado elementos en la lista izquierda los agregaremos
            while (indexIzq < cantIzq)
            {
                union.Agregar((int)izq[indexIzq]);
                indexIzq++;
            }
            // Si en dado caso han sobrado elementos en la lista derecha los agregaremos
            while (indexDer < cantDer)
            {
                union.Agregar((int)der[indexDer]);
                indexDer++;
            }

            return(union);
        }
        private static Lista_Ligada MergeSortMethod(Lista_Ligada lista)
        {
            // Cantidad de elementos en la lista.
            int cantidad = lista.getSize() + 1;

            // Caso base, una lista de un solo elemento ya está ordenada
            if (cantidad < 3)
            {
                return(lista);
            }

            //Obtenemos el punto medio de la lista
            int mitad = cantidad / 2;

            Lista_Ligada left = new Lista_Ligada();
            Lista_Ligada der  = new Lista_Ligada();

            // Adicionamos a la izquierda desde el inicio hasta antes de la mitad
            for (int i = 1; i <= mitad; i++)
            {
                left.Agregar((int)lista[i]);
            }
            for (int i = mitad + 1; i < cantidad; i++)
            {
                der.Agregar((int)lista[i]);
            }

            // Casos Inductivos
            // Hacemos el MergeSort de las listas izquierda y derecha
            Lista_Ligada tempoLeft  = MergeSortMethod(left);
            Lista_Ligada tempoRight = MergeSortMethod(der);

            // Hacemos el merge de lo que nos regresa el caso inductivo
            Lista_Ligada ordenado = Merge(tempoLeft, tempoRight);

            // Regresamos la lista ordenada
            return(ordenado);
        }
Exemple #4
0
        static void Main(string[] args)
        {
            // Selection Sort
            Lista_Ligada lista = new Lista_Ligada();

            lista.Agregar(4);
            lista.Agregar(5);
            lista.Agregar(8);
            lista.Agregar(2);
            lista.Agregar(9);
            lista.Agregar(3);
            lista.Agregar(1);
            lista.Agregar(8);
            lista.Agregar(9);
            lista.Agregar(2);
            lista.Agregar(7);
            lista.Agregar(5);
            lista.Transversa();
            // Datos necesarios
            int cantidad = lista.getSize() + 1;
            int iMenor   = 0;
            int temporal = 0;

            // Ascendente
            Console.WriteLine("Lista Ordenada Ascendente");
            for (int i = 0; i < cantidad - 1; i++)
            {
                //El indice menor es la posición actual desde donde comenzamos
                iMenor = i;
                // Encontramos el nuevo indice del menor
                for (int j = i + 1; j < cantidad; j++)
                {
                    if (lista[j] < lista[iMenor])
                    {
                        iMenor = j;
                    }
                }
                temporal      = (int)lista[i];
                lista[i]      = lista[iMenor];
                lista[iMenor] = temporal;
            }
            lista.Transversa();
            // Descendente
            Console.WriteLine("Lista Ordenada Descendente");
            for (int i = 1; i < cantidad; i++)
            {
                //El indice menor es la posición actual desde donde comenzamos
                iMenor = i;
                // Encontramos el nuevo indice del menor
                for (int j = i + 1; j < cantidad; j++)
                {
                    if (lista[j] > lista[iMenor])
                    {
                        iMenor = j;
                    }
                }
                temporal      = (int)lista[i];
                lista[i]      = lista[iMenor];
                lista[iMenor] = temporal;
            }
            lista.Transversa();

            // Ejercicio Programando el orden con 2 listas...
            Lista_Ligada listaResultado = new Lista_Ligada();
            int          cantidadLista  = lista.getSize() + 1;
            int          indiceBorrar   = 0;
            int          menor          = 0;
            int          mayor          = (int)lista[1];

            for (int i = 1; i < cantidadLista; i++)
            {
                menor = mayor;
                for (int j = 1; j < cantidadLista; j++)
                {
                    // Mientras busco el menor, voy buscando el mayor disponible para luego igualarlo
                    // Para luego hallar menores en base al mayor...
                    if (lista[i] > mayor && lista[i] > 0)
                    {
                        mayor = (int)lista[i];
                    }
                    // Recorro la lista y encuentro el menor
                    if (lista[j] < menor && lista[j] > 0)
                    {
                        menor        = (int)lista[j];
                        indiceBorrar = j;
                    }
                }
                lista[indiceBorrar] = 0;
                listaResultado.Agregar(menor);
            }
            Console.WriteLine("Selection Sort 2 Listas");
            listaResultado.Transversa();
        }
Exemple #5
0
        static void Main(string[] args)
        {
            Lista_Ligada lista = new Lista_Ligada();

            lista.Agregar(5);
            lista.Agregar(2);
            lista.Agregar(4);
            lista.Agregar(8);
            lista.Transversa();
            Console.WriteLine(lista[1]);
            Console.WriteLine(lista[2]);
            Console.WriteLine(lista[3]);
            Console.WriteLine(lista[4]);
            //Insertion Sort
            int cantidad     = lista.getSize() + 1;
            int indexAgujero = 0;
            int dato         = 0;

            // Ascendente
            //Recorremos los elementos
            for (int i = 0; i < cantidad; i++)
            {
                //Obtenemos el dato
                dato = (int)lista[i];
                //Indicamos la posición del agujero
                indexAgujero = i;
                //Recorremos los elementos hacia el agujero
                while (indexAgujero > 0 && lista[indexAgujero - 1] > dato)
                {
                    lista[indexAgujero] = lista[indexAgujero - 1];
                    indexAgujero       -= 1;
                }
                //Le colocamos al agujero el dato correspondiente
                lista[indexAgujero] = dato;
                //lista.Transversa();
            }
            //Mostrar lista ordenada
            Console.WriteLine("Lista Ordenada");
            lista.Transversa();

            // Descendente
            //Insertion Sort
            int size       = lista.getSize() + 1;
            int indiceHole = 0;
            int numerito   = 0;

            // Ascendente
            //Recorremos los elementos
            for (int i = 2; i < size; i++)
            {
                //Obtenemos el dato
                numerito = (int)lista[i];
                //Indicamos la posición del agujero
                indiceHole = i;
                //Recorremos los elementos hacia el agujero
                while (indiceHole > 1 && lista[indiceHole - 1] < numerito)
                {
                    lista[indiceHole] = lista[indiceHole - 1];
                    indiceHole       -= 1;
                }
                //Le colocamos al agujero el dato correspondiente
                lista[indiceHole] = numerito;
            }
            //Mostrar lista ordenada
            Console.WriteLine("Lista Ordenada");
            lista.Transversa();
        }