Mostrando entradas con la etiqueta c# métodos de ordenamiento. Mostrar todas las entradas
Mostrando entradas con la etiqueta c# métodos de ordenamiento. Mostrar todas las entradas

Método de Ordenamiento Burbuja en C#

Este método consiste en ir comparando cada par de elementos del array e ir moviendo el mayor elemento hasta la última posición, comenzando desde la posición cero. Una vez acomodado el mayor elemento, prosigue a encontrar y acomodar el segundo más grande comparando de nuevo los elementos desde el inicio de la lista, y así sigue hasta ordenar todos los elementos del arreglo. Al ser necesario revisar varias veces toda la lista hasta que no se necesiten más intercambios, hace que el ordenamiento por burbuja sea uno de los algoritmos más ineficientes que existen. Incluso entre los algoritmos de ordenamiento del mismo orden, otros como el “Ordenamiento por inserción” son considerados más eficientes. Y lo más curioso es que este procedimiento es uno de los más usados para ordenar listas en todos los lenguajes de programación.

Estos serían los pasos a seguir por este algoritmo para ordenar una lista a1, a2, a3, … an
1) Comparar a1 con a2 e intercambiarlos si a1>a2
2) Seguir hasta que se haya comparado an-1 con an
3) Repetir el proceso anterior n-1 veces

Ejemplo:

            25 57 48 37 12 92 86 33

En el primer paso se realizan las siguientes operaciones:

          x[0] con x[1] (25 con 57)  no intercambio.
          x[1] con x[2] (57 con 48)      intercambio.
          x[2] con x[3] (57 con 32)      intercambio.
          x[3] con x[4] (57 con 12)      intercambio.
          x[4] con x[5] (57 con 92)  no intercambio.
          x[5] con x[6] (92 con 86)      intercambio.
          x[6] con x[7] (92 con 33)      intercambio.

Así después del primer paso, el arreglo está en el siguiente orden:

          25 48 37 12 57 86 33 92

Observe que después del primer paso, el elemento mayor (en este caso 92) está en la posición correcta dentro del arreglo. En general x[n-i] estará en su posición correcta después de la iteración i. El método se lama ordenamiento de burbuja porque cada número “burbujea” con lentitud hacia su posición correcta. El conjunto completo de iteraciones es:

         iteración 0 :                     25 57 48 37 12 92 86 33
         iteración 1:                       25 48 37 12 57 86 33 92
         iteración 2:                       25 37 12 48 57 33 86 92
         iteración 3:                       25 12 37 48 33 57 86 92
         iteración 4:                       12 25 37 33 48 57 89 92
         iteración 5:                       12 25 33 37 48 57 89 92

A continuación veamos un ejemplo en Pseudo-Código Para el Método Burbuja 




Ejemplo del Método de Ordenamiento Burbuja en C# 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Burbuja
{
    class Burbuja
    {
        private int[] vector;

        public void Cargar()
        {
            Console.WriteLine("Metodo de Burbuja");
            Console.Write("Cuantos longitud del vector: ");
            string linea;
            linea = Console.ReadLine();
            int cant;
            cant = int.Parse(linea);
            vector = new int[cant];
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write("Ingrese elemento "+(f+1)+": ");
                linea = Console.ReadLine();
                vector[f] = int.Parse(linea);
            }
        }

        public void MetodoBurbuja()
        {
            int t;
            for (int a = 1; a < vector.Length; a++)
                for (int b = vector.Length - 1; b >= a; b--)
                {
                    if (vector[b - 1] > vector[b])
                    {
                        t = vector[b - 1];
                        vector[b - 1] = vector[b];
                        vector[b] = t;
                    }
                }
        }

        public void Imprimir()
        {
            Console.WriteLine("Vector ordenados en forma ascendente");
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write(vector[f]+"  ");
            }
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            Burbuja pv = new Burbuja();
            pv.Cargar();
            pv.MetodoBurbuja();
            pv.Imprimir();
        }
    }
}

Al ejecutar el código muestra el siguiente resultado



Método de Ordenamiento Quick Sort en C#

El método de ordenamiento Quick Sort es actualmente el más eficiente y veloz de los métodos de ordenación interna. Es también conocido con el nombre del método rápido y de ordenamiento por partición, en el mundo de habla hispana.

Este método es una mejora sustancial del método de intercambio directo y recibe el nombre de Quick Sort por la velocidad con que ordena los elementos del arreglo. Su autor C.A. Hoare lo bautizó así.
La idea central de este algoritmo consiste en los siguiente:


  • Se toma un elemento x de una posición cualquiera del arreglo.
  • Se trata de ubicar a x en la posición correcta del arreglo, de tal forma que todos los elementos que se encuentran a su izquierda sean menores o iguales a x y todos los elementos que se encuentren a su derecha sean mayores o iguales a x.
  • Se repiten los pasos anteriores pero ahora para los conjuntos de datos que se encuentran a la izquierda y a la derecha de la posición correcta de x en el arreglo.

Ejemplo:
      A: 15,67,08,16,44,27,12,35
      Se selecciona A[i]  x=15

Primera pasada (DER-IZQ)
     A[8] >= x 35 >= 15 No hay intercambio
     A[7] >= x 12 >= 15 Si hay intercambio

     A: 12,67,08,16,44,27,15,35

(IZQ-DER)
     A[2] < = X 67 < = 15 Si hay intercambio

     A:12,15,08,16,44,27,67,35

2da. Pasada (DER-IZQ)
     A[6] >= x 27 >= 15 No hay intercambio
     A[5] >= x 44 >= 15 No hay intercambio
     A[4] >= x 16 >= 15 No hay intercambio
     A[3] >= x 08 >= 15 Si hay intercambio

     A: 12,08,15,16,44,27,67,35

Como el recorrido de izquierda a derecha debería iniciarse en la misma posición  donde se encuentra el elemento x, el proceso se termina ya que el elemento x, se  encuentra en la posición correcta.

     A: 12, 08, 15, 16, 44, 27, 67, 35

1er 2do Conjunto

     16, 44, 27, 67, 35
     x16

(DER-IZQ)
     A[8]>=x No hay intercambio
     A[7]>=x No hay intercambio
     A[6]>=x No hay intercambio
     A[5]>=x No hay intercambio

     A: 12, 08, 15, 16, 44, 27, 67, 35
     xß44

(DER-IZQ)
     A[8]>= x Si hay intercambio

     A: 12, 08, 15, 16, 35, 27, 67, 44

(IZQ-DER)
     A[6] < = x No hay intercambio
     A[7] < = x Si hay intercambio
     12, 08, 15, 16, 35, 27, 44, 67
     12, 08, 15, 16, 35, 27, 44, 67
     35, 27, 44, 67
     xß35

(DER-IZQ)
     A[8] >= x No hay intercambio
     A[7] >= x No hay intercambio
     A[6] >= x Si hay intercambio
     12, 08, 15, 16, 27, 35, 44, 67
     12,08
     xß12

(DER-IZQ)
    A[2]>=x Si hay intercambio

EL VECTOR ORDENADO:
    08,12,15,16,27,35,44,67

A continuación veamos un ejemplo en Pseudo-Código Para el Método de Quick Sort 



Ejemplo del Método de Ordenamiento Quick Sort en C# 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace quicksort
{
    class Class
    {
        static void Main()
        {
            int n;
            Console.WriteLine("Metodo de Quick Sort");
            Console.Write("Cuantos longitud del vector: ");
            n = Int32.Parse(Console.ReadLine());
            llenar b = new llenar(n);
        }
    }

    class llenar
    {
        int h;
        int[] vector;
        public llenar(int n)
        {
            h = n;
            vector = new int[h];
            for (int i = 0; i < h; i++)
            {
                Console.Write("ingrese valor {0}: ", i + 1);
                vector[i] = Int32.Parse(Console.ReadLine());
            }
            quicksort(vector, 0, h - 1);
            mostrar();
        }

        private void quicksort(int[] vector, int primero, int ultimo)
        {
            int i, j, central;
            double pivote;
            central = (primero + ultimo) / 2;
            pivote = vector[central];
            i = primero;
            j = ultimo;
            do
            {
                while (vector[i] < pivote) i++;
                while (vector[j] > pivote) j--;
                if (i <= j)
                {
                    int temp;
                    temp = vector[i];
                    vector[i] = vector[j];
                    vector[j] = temp;
                    i++;
                    j--;
                }
            } while (i <= j);

            if (primero < j)
            {
                quicksort(vector, primero, j);
            }
            if (i < ultimo)
            {
                quicksort(vector, i, ultimo);
            }
        }

        private void mostrar()
        {
            Console.WriteLine("Vector ordenados en forma ascendente");
            for (int i = 0; i < h; i++)
            {
                Console.Write("{0} ", vector[i]);
            }
            Console.ReadLine();
        }
    }
}

Al ejecutar el código muestra el siguiente resultado



Método de Ordenamiento Shell Sort en C#

Es un algoritmo de ordenación interna muy sencillo pero muy ingenioso, basado en comparaciones e intercambios, y con unos resultados radicalmente mejores que los que se pueden obtener con el método de la burbuja, el des elección directa o el de inserción directa.

Sin embargo, es necesario romper una lanza a favor del algoritmo ShellSort, ya que es el mejor algoritmo de ordenación in-situ... es decir, el mejor de aquellos en los que la cantidad de memoria adicional que necesita -aparte de los propios datos a ordenar, claro está- es constante, sea cual sea la cantidad de datos a ordenar. El algoritmo de la burbuja, el de selección directa, el de inserción directa y el de Shell son todos in-situ, y éste último, el de Shell, es el que mejor resultados da, sin ninguna duda de todos ellos y sus posibles variantes.

El ShellSort es una mejora del método de inserción directa que se utiliza cuando el número de elementos a ordenar es grande. El método se denomina “shell” –en honor de su inventor Donald Shell – y también método de inserción con incrementos decrecientes.

En el método de clasificación por inserción, cada elemento se compara con los elementos contiguos de su izquierda, uno tras otro. Si el elemento a insertar es más pequeño - por ejemplo -, hay que ejecutar muchas comparaciones antes de colocarlo en su lugar definitivamente. Shell modifico los saltos contiguos resultantes de las comparaciones por saltos de mayor tamaño y con eso se conseguía la clasificación más rápida. El método se basa en fijar el tamaño de los saltos constantes, pero de más de una posición.

Considere un valor pequeño que está inicialmente almacenado en el final del vector. Usando un ordenamiento O(n2) como el ordenamiento de burbuja o el ordenamiento por inserción, tomará aproximadamente n comparaciones e intercambios para mover este valor hacia el otro extremo del vector. El Shell sort primero mueve los valores usando tamaños de espacio gigantes, de manera que un valor pequeño se moverá bastantes posiciones hacia su posición final, con sólo unas pocas comparaciones e intercambios.

Uno puede visualizar el algoritmo Shell sort de la siguiente manera: coloque la lista en una tabla y ordene las columnas (usando un ordenamiento por inserción). Repita este proceso, cada vez con un número menor de columnas más largas. Al final, la tabla tiene sólo una columna.

Mientras que transformar la lista en una tabla hace más fácil visualizarlo, el algoritmo propiamente hace su ordenamiento en contexto (incrementando el índice por el tamaño de paso, esto es usando i += tamaño_de_paso en vez de i++).

Por ejemplo, considere una lista de números como [ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]. Si comenzamos con un tamaño de paso de 8, podríamos visualizar esto dividiendo la lista de números en una tabla con 5 columnas. Esto quedaría así:

13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

Entonces ordenamos cada columna, lo que nos da:

10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

Cuando lo leemos de nuevo como una única lista de números, obtenemos:

 [ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]

 Aquí, el 10 que estaba en el extremo final, se ha movido hasta el extremo inicial. Esta lista es entonces de nuevo ordenada usando un ordenamiento con un espacio de 3 posiciones, y después un ordenamiento con un espacio de 1 posición (ordenamiento por inserción simple).

El Shell sort lleva este nombre en honor a su inventor, Donald Shell, que lo publicó en 1959. Algunos libros de texto y referencias antiguas le llaman ordenación "Shell-Metzner" por Marlene Metzner Norton, pero según Metzner, "No tengo nada que ver con el algoritmo de ordenamiento, y mi nombre nunca debe adjuntarse a éste."

A continuación veamos un ejemplo en Pseudo-Código Para el Método de Shell Sort


Ejemplo del Método de Ordenamiento Shell Sort en C# 

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace PruebaVector
{
    class PruebaVector
    {
        private int[] vector;

        public void Cargar()
        {
            Console.WriteLine("Metodo de Shell Sort");
            Console.Write("Cuantos longitud del vector:");
            string linea;
            linea = Console.ReadLine();
            int cant;
            cant = int.Parse(linea);
            vector = new int[cant];
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write("Ingrese elemento "+(f+1)+": ");
                linea = Console.ReadLine();
                vector[f] = int.Parse(linea);
            }
        }

        public void Shell()
        {
            int salto = 0;
            int sw = 0;
            int auxi = 0;
            int e = 0;
            salto = vector.Length / 2;
            while (salto > 0)
            {
                sw = 1;
                while (sw != 0)
                {
                    sw = 0;
                    e = 1;
                    while (e <= (vector.Length - salto))
                    {
                        if (vector[e - 1] > vector[(e - 1) + salto])
                        {
                            auxi = vector[(e - 1) + salto];
                            vector[(e - 1) + salto] = vector[e - 1];
                            vector[(e - 1)] = auxi;
                            sw = 1;
                        }
                        e++;
                    }
                }
                salto = salto / 2;
            }
        }

        public void Imprimir()
        {
            Console.WriteLine("Vector ordenados en forma ascendente");
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write(vector[f]+"  ");
            }
            Console.ReadKey();
        }


        static void Main(string[] args)
        {
            PruebaVector pv = new PruebaVector();
            pv.Cargar();
            pv.Shell();
            pv.Imprimir();
        }
    }
}

Al ejecutar el código muestra el siguiente resultado


Método de Ordenamiento de Inserción Binaria en C#

La Inserción Binaria, es una mejora de la Inserción Directa.
La Inserción Binaria es un método de inserción, que difiere de la Inserción Directa simplemente en la búsqueda de la posición de la Inserción.

Veamos un ejemplo de como funciona este método de ordenamiento de Inserción Binaria, analizando paso a paso.

1. Hallamos el elemento central del área comprendida por la parte ordenada más la posición del elemento a insertar.


2. Comparamos el elemento central con el elemento que queremos insertar. Si dicho elemento central es menor o igual, nos quedamos con la parte derecha (Sin incluir el elemento central). En caso contrario, nos quedamos con la parte izquierda incluyendo al elemento central.


3. Repetimos el mismo proceso sobre el área con la que nos quedamos, hasta que dicha área sea nula.


4. Cuando el área sea nula, tendremos la posición de inserción.



A continuación veamos un ejemplo en Pseudo-Código Para el Método de Inserción Binaria




Ejemplo del Código Implementado 


Un ejemplo de método de inserción binaria en C# 

                    int auxiliar;
                    int q;
                    int izqui;
                    int dere;
                    for (int i = 0; i < numeros.Length; i++)
                    {
                        auxiliar = numeros[i];
                        izqui = 0;
                        dere = i - 1;
                        while (izqui <= dere)
                        {
                            q = ((izqui + dere) / 2);
                            if (auxiliar < numeros[q])
                            {
                                dere = q - 1;
                            }
                            else
                            {
                                izqui = q + 1;
                            }
                            j = i - 1;
                            while (j >= izqui)
                            {
                                numeros[j + 1] = numeros[j];
                                j = j - 1;
                            }
                            numeros[izqui] = auxiliar;
                        }
                    }
                    for (int i = 0; i < longitud; i++)
                        Console.WriteLine(" " + numeros[i]);





Método de Ordenamiento de Inserción Directa en C#

El método de inserción directa es el que generalmente utilizan los jugadores de cartas cuando ordenan éstas, de ahí que también se conozca con el nombre de método de la baraja.

La idea central de este algoritmo consiste en insertar un elemento del arreglo en la parte izquierda del mismo, que ya se encuentra ordenada. Este proceso se repite desde el segundo hasta el n-esimo elemento. 

Ejemplo:

Se desean ordenarse las siguientes clave del arreglo A: 15, 67, 08, 16, 44, 27, 12, 35

Primera pasada
A[2] < A[1] 67 < 15 No hay intercambio

A: 15, 67, 08, 16, 44, 27, 12, 35

Segunda pasada
A[3] < A[2] 08 < 67 Si hay intercambio
A[2] < A[1] 08 < 15 Si hay

A: 15, 08, 67, 16, 44, 27, 12, 35

Tercera pasada 
A[4] < A[3] 08 < 15 Si hay intercambio
A[3] < A[2] 08 < 15 Si hay intercambio

A= 08, 15, 67, 16, 44, 27, 12, 35

Hasta la séptima pasada el arreglo queda ordenado:   08, 12, 15, 16, 27, 35, 44, 67

A continuación veamos un ejemplo en Pseudo-Código Para el Método de Shell Sort

void InsercionDirecta (int arreglo[], int tam)
{
int i ,  j , valorBusqueda; 
for(i = 1; i < tam; i++) 
{
valorBusqueda = a[i];
for (j = i - 1; j >= 0 && a[j] > valorBusqueda; j--)
{
a[j + 1] = a[j];
}
a[j + 1] = valorBusqueda;
}
val = a[i];
 }

Ejemplo del Método de Ordenamiento Inserción Directa  en c#


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
namespace PruebaVector
{
    class PruebaVector
    {
        private int[] vector;

        public void Cargar()
        {
            Console.WriteLine("Metodo de insercion directa");
            Console.Write("Cuantos longitud del vector:");
            string linea;
            linea = Console.ReadLine();
            int cant;
            cant = int.Parse(linea);
            vector = new int[cant];
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write("Ingrese elemento "+(f+1)+": ");
                linea = Console.ReadLine();
                vector[f] = int.Parse(linea);
            }
        }

        public void InsercionDirecta()
        {
            int auxili;
            int j;
            for (int i = 0; i < vector.Length; i++)
            {
                auxili = vector[i];
                j = i - 1;
                while (j >= 0 && vector[j] > auxili)
                {
                    vector[j + 1] = vector[j];
                    j--;
                }
                vector[j + 1] = auxili;
            }
        }

        public void Imprimir()
        {
            Console.WriteLine("Vector ordenados en forma ascendente");
            for (int f = 0; f < vector.Length; f++)
            {
                Console.Write(vector[f]+"  ");
            }
            Console.ReadKey();
        }

        static void Main(string[] args)
        {
            PruebaVector pv = new PruebaVector();
            pv.Cargar();
            pv.InsercionDirecta();
            pv.Imprimir();
        }
    }
}

Al ejecutar el código muestra el siguiente resultado