En el artículo de hoy te mostraré cómo ordenar un arreglo en C# usando el método de la burbuja, ordenamiento de burbuja o bubble sort.

Al final tendremos una función que va a ordenar un arreglo usando el ordenamiento de burbuja. Te mostraré ejemplos para ordenar de manera ascendente y descendente, así como un ejemplo para ordenar arreglos de cadena.

Explicación del algoritmo

Para este método tenemos que recorrer el arreglo en un ciclo que va desde 0 hasta la longitud del arreglo menos 1, y dentro de ese ciclo volver a recorrerlo desde 0 hasta la longitud del arreglo menos 2.

Es un algoritmo lento comparado con otros, pero es sencillo de entender cuando somos principiantes.

Lo que hace el ordenamiento es ir comparando el elemento actual con el de la derecha, y si el actual es mayor que el siguiente, los intercambiamos. Esto en el caso del orden ascendente; si se quiere el orden descendente se intercambia la comparación.

En los ejemplos se explica de mejor manera el cómo ordenar arreglos con el método de la burbuja usando C# o C sharp.

Ordenamiento de burbuja en C#

Veamos nuestro primer ejemplo. En este caso tenemos una función que recibe un arreglo y lo va a ordenar, de manera que no devuelve nada, pues va a modificar al original. El código queda así:

static void ordenarBurbuja(int[] arreglo)
{
    for (int x = 0; x < arreglo.Length; x++)
    {
        // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
        // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
        // del arreglo
        for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si el actual es mayor que el que le sigue a la derecha...
            if (arreglo[indiceActual] > arreglo[indiceSiguienteElemento])
            {
                int temporal = arreglo[indiceActual];
                arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                arreglo[indiceSiguienteElemento] = temporal;
            }
        }
    }
}

Este código que te muestro es para ordenar un arreglo de manera ascendente. Al final del post te mostraré la forma de invocar a esta función.

Ordenamiento descendente con burbuja

Veamos ahora la función de C# para implementar el algoritmo de bubble sort de manera que el arreglo quede ordenado de manera descendente. En este caso solo cambia el operador de comparación:

static void ordenarBurbujaDescendente(int[] arreglo)
{
    for (int x = 0; x < arreglo.Length; x++)
    {
        // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
        // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
        // del arreglo
        for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si el actual es menor que el que le sigue a la derecha...
            if (arreglo[indiceActual] < arreglo[indiceSiguienteElemento])
            {
                int temporal = arreglo[indiceActual];
                arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                arreglo[indiceSiguienteElemento] = temporal;
            }
        }
    }
}

Ordenar arreglo de tipo string

Siguiendo con el código en C# veamos cómo se implementaría el ordenamiento de un arreglo si el mismo fuera de cadenas. En este caso usamos la función CompareTo para saber si una cadena es mayor o menor.

El código queda así:

static void ordenarBurbujaCadenas(string[] arreglo)
{
    for (int x = 0; x < arreglo.Length; x++)
    {
        // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
        // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
        // del arreglo
        for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
             indiceActual++)
        {
            int indiceSiguienteElemento = indiceActual + 1;
            // Si el actual es mayor que el que le sigue a la derecha...
            if (arreglo[indiceActual].CompareTo(arreglo[indiceSiguienteElemento]) > 0)
            {
                string temporal = arreglo[indiceActual];
                arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                arreglo[indiceSiguienteElemento] = temporal;
            }
        }
    }
}

Cuando ordenamos un arreglo de string o cadenas con C# al final el mismo respetará el orden lexicográfico o básicamente el orden del alfabeto.

Modo de uso

La sintaxis básica es:

ordenarBurbujaCadenas(arreglo);

No esperamos el valor de retorno, pues el arreglo original será modificado. A continuación te muestro cómo usar todas estas funciones:

/*
    https://parzibyte.me/blog
*/
static void Main(string[] args)
{
    int[] numeros = { 15, 1, 34, 5, 90, 10, 6 };
    Console.WriteLine("Antes de ordenar");
    foreach (var numero in numeros)
    {
        Console.Write(numero + ",");
    }
    Console.WriteLine("");
    ordenarBurbuja(numeros);
    Console.WriteLine("Después de ordenar ascendente");
    foreach (var numero in numeros)
    {
        Console.Write(numero + ",");
    }
    Console.WriteLine();

    ordenarBurbujaDescendente(numeros);

    Console.WriteLine("Después de ordenar descendente");
    foreach (var numero in numeros)
    {
        Console.Write(numero + ",");
    }
    Console.WriteLine();
    string[] cadenas = { "Luis", "Zelda", "Link", "Aloy", "Ethan" };
    Console.WriteLine("Arreglo de cadenas antes de ordenar: ");
    foreach (var cadena in cadenas)
    {
        Console.Write(cadena + ",");
    }
    Console.WriteLine();
    ordenarBurbujaCadenas(cadenas);
    Console.WriteLine("Arreglo de cadenas antes de ordenar: ");
    foreach (var cadena in cadenas)
    {
        Console.Write(cadena + ",");
    }
    Console.WriteLine();
}

El código es un poco largo porque estoy imprimiendo los valores antes y después de ordenarlos, además de que estoy usando las 3 funciones que te mostré.

Obviamente eres libre de modificar y mejorar el código o adaptarlo a tus necesidades a partir de estos ejemplos básicos que te he mostrado.

Poniendo todo junto

Si te interesa el código completo aquí lo tienes:

using System;
namespace App
{

    class Programa
    {
        static void ordenarBurbuja(int[] arreglo)
        {
            for (int x = 0; x < arreglo.Length; x++)
            {
                // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
                // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
                // del arreglo
                for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
                     indiceActual++)
                {
                    int indiceSiguienteElemento = indiceActual + 1;
                    // Si el actual es mayor que el que le sigue a la derecha...
                    if (arreglo[indiceActual] > arreglo[indiceSiguienteElemento])
                    {
                        int temporal = arreglo[indiceActual];
                        arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                        arreglo[indiceSiguienteElemento] = temporal;
                    }
                }
            }
        }

        static void ordenarBurbujaDescendente(int[] arreglo)
        {
            for (int x = 0; x < arreglo.Length; x++)
            {
                // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
                // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
                // del arreglo
                for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
                     indiceActual++)
                {
                    int indiceSiguienteElemento = indiceActual + 1;
                    // Si el actual es menor que el que le sigue a la derecha...
                    if (arreglo[indiceActual] < arreglo[indiceSiguienteElemento])
                    {
                        int temporal = arreglo[indiceActual];
                        arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                        arreglo[indiceSiguienteElemento] = temporal;
                    }
                }
            }
        }
        static void ordenarBurbujaCadenas(string[] arreglo)
        {
            for (int x = 0; x < arreglo.Length; x++)
            {
                // Recuerda que el -1 es porque no queremos llegar al final ya que hacemos
                // un indiceActual + 1 y si fuéramos hasta el final, intentaríamos acceder a un valor fuera de los límites
                // del arreglo
                for (int indiceActual = 0; indiceActual < arreglo.Length - 1;
                     indiceActual++)
                {
                    int indiceSiguienteElemento = indiceActual + 1;
                    // Si el actual es mayor que el que le sigue a la derecha...
                    if (arreglo[indiceActual].CompareTo(arreglo[indiceSiguienteElemento]) > 0)
                    {
                        string temporal = arreglo[indiceActual];
                        arreglo[indiceActual] = arreglo[indiceSiguienteElemento];
                        arreglo[indiceSiguienteElemento] = temporal;
                    }
                }
            }
        }

        /*
            https://parzibyte.me/blog
        */
        static void Main(string[] args)
        {
            int[] numeros = { 15, 1, 34, 5, 90, 10, 6 };
            Console.WriteLine("Antes de ordenar");
            foreach (var numero in numeros)
            {
                Console.Write(numero + ",");
            }
            Console.WriteLine("");
            ordenarBurbuja(numeros);
            Console.WriteLine("Después de ordenar ascendente");
            foreach (var numero in numeros)
            {
                Console.Write(numero + ",");
            }
            Console.WriteLine();

            ordenarBurbujaDescendente(numeros);

            Console.WriteLine("Después de ordenar descendente");
            foreach (var numero in numeros)
            {
                Console.Write(numero + ",");
            }
            Console.WriteLine();
            string[] cadenas = { "Luis", "Zelda", "Link", "Aloy", "Ethan" };
            Console.WriteLine("Arreglo de cadenas antes de ordenar: ");
            foreach (var cadena in cadenas)
            {
                Console.Write(cadena + ",");
            }
            Console.WriteLine();
            ordenarBurbujaCadenas(cadenas);
            Console.WriteLine("Arreglo de cadenas antes de ordenar: ");
            foreach (var cadena in cadenas)
            {
                Console.Write(cadena + ",");
            }
            Console.WriteLine();
        }
    }
}

La salida ya la pudiste ver en la imagen que acompaña al encabezado.

Por aquí te dejo más tutoriales de C#.