Método de Ordenamiento Burbuja en C#

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

Publicado por Yhonatan Robles Vega No hay comentarios: 

Método de Ordenamiento Quick Sort en C#

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

Publicado por Yhonatan Robles Vega