Ordenación por burbuja

comparaciones = intercambios = 0


def burbuja(a):
    """Ordena a con el método de la burbuja; para en cuanto una pasada no intercambia nada."""
    global comparaciones, intercambios
    for i in range(len(a) - 1):
        cambio = False
        for j in range(len(a) - 1 - i):         # los últimos i ya están en su sitio
            comparaciones += 1
            if a[j] > a[j + 1]:                 # vecinos al revés: se intercambian
                a[j], a[j + 1] = a[j + 1], a[j]
                intercambios += 1
                cambio = True
        if not cambio:                          # ninguna pareja al revés: ya está ordenado
            break


def probar(a):
    global comparaciones, intercambios
    comparaciones = intercambios = 0
    antes = str(a)
    burbuja(a)
    print(f"{antes} → {a} ({comparaciones} comparaciones, {intercambios} intercambios)")


probar([5, 1, 4, 2, 8, 3])
probar([1, 2, 3, 4, 5, 6])      # ya ordenado: una sola pasada
probar([6, 5, 4, 3, 2, 1])      # al revés: el peor caso

let comparaciones = 0, intercambios = 0;

/** Ordena a con el método de la burbuja; para en cuanto una pasada no intercambia nada. */
function burbuja(a) {
    for (let i = 0; i < a.length - 1; i++) {
        let cambio = false;
        for (let j = 0; j < a.length - 1 - i; j++) {   // los últimos i ya están en su sitio
            comparaciones++;
            if (a[j] > a[j + 1]) {                     // vecinos al revés: se intercambian
                [a[j], a[j + 1]] = [a[j + 1], a[j]];
                intercambios++;
                cambio = true;
            }
        }
        if (!cambio) break;                            // ninguna pareja al revés: ya está ordenado
    }
}

const texto = (a) => "[" + a.join(", ") + "]";

function probar(a) {
    comparaciones = intercambios = 0;
    const antes = texto(a);
    burbuja(a);
    console.log(`${antes} → ${texto(a)} (${comparaciones} comparaciones, ${intercambios} intercambios)`);
}

probar([5, 1, 4, 2, 8, 3]);
probar([1, 2, 3, 4, 5, 6]);      // ya ordenado: una sola pasada
probar([6, 5, 4, 3, 2, 1]);      // al revés: el peor caso

using System;

class Program {
    static int comparaciones, intercambios;

    // Ordena a con el método de la burbuja; para en cuanto una pasada no intercambia nada.
    static void Burbuja(int[] a) {
        for (int i = 0; i < a.Length - 1; i++) {
            bool cambio = false;
            for (int j = 0; j < a.Length - 1 - i; j++) {   // los últimos i ya están en su sitio
                comparaciones++;
                if (a[j] > a[j + 1]) {                     // vecinos al revés: se intercambian
                    (a[j], a[j + 1]) = (a[j + 1], a[j]);
                    intercambios++;
                    cambio = true;
                }
            }
            if (!cambio) break;                            // ninguna pareja al revés: ya está ordenado
        }
    }

    static string Texto(int[] a) => "[" + string.Join(", ", a) + "]";

    static void Probar(int[] a) {
        comparaciones = intercambios = 0;
        string antes = Texto(a);
        Burbuja(a);
        Console.WriteLine(
quot;{antes} → {Texto(a)} ({comparaciones} comparaciones, {intercambios} intercambios)");
    }

    static void Main() {
        Probar(new[] { 5, 1, 4, 2, 8, 3 });
        Probar(new[] { 1, 2, 3, 4, 5, 6 });      // ya ordenado: una sola pasada
        Probar(new[] { 6, 5, 4, 3, 2, 1 });      // al revés: el peor caso
    }
}

<?php
$comparaciones = 0;
$intercambios = 0;

/** Ordena $a con el método de la burbuja; para en cuanto una pasada no intercambia nada. */
function burbuja(array &$a): void {
    global $comparaciones, $intercambios;
    $n = count($a);
    for ($i = 0; $i < $n - 1; $i++) {
        $cambio = false;
        for ($j = 0; $j < $n - 1 - $i; $j++) {        // los últimos $i ya están en su sitio
            $comparaciones++;
            if ($a[$j] > $a[$j + 1]) {                 // vecinos al revés: se intercambian
                [$a[$j], $a[$j + 1]] = [$a[$j + 1], $a[$j]];
                $intercambios++;
                $cambio = true;
            }
        }
        if (!$cambio) break;                           // ninguna pareja al revés: ya está ordenado
    }
}

function texto(array $a): string { return "[" . implode(", ", $a) . "]"; }

function probar(array $a): void {
    global $comparaciones, $intercambios;
    $comparaciones = $intercambios = 0;
    $antes = texto($a);
    burbuja($a);
    echo "$antes → " . texto($a) . " ($comparaciones comparaciones, $intercambios intercambios)\n";
}

probar([5, 1, 4, 2, 8, 3]);
probar([1, 2, 3, 4, 5, 6]);      // ya ordenado: una sola pasada
probar([6, 5, 4, 3, 2, 1]);      // al revés: el peor caso

def burbuja(a):
    """En Python los textos se comparan con > igual que los números (por orden de sus caracteres)."""
    for i in range(len(a) - 1):
        for j in range(len(a) - 1 - i):
            if a[j] > a[j + 1]:                 # a[j] va después que a[j + 1]
                a[j], a[j + 1] = a[j + 1], a[j]

/** Con textos se usa localeCompare, que además respeta las reglas del idioma (á, ñ…). */
function burbuja(a) {
    for (let i = 0; i < a.length - 1; i++)
        for (let j = 0; j < a.length - 1 - i; j++)
            if (a[j].localeCompare(a[j + 1], "es") > 0)    // a[j] va después que a[j + 1]
                [a[j], a[j + 1]] = [a[j + 1], a[j]];
}

// Con textos u objetos se compara con CompareTo (o con un IComparer).
static void Burbuja(string[] a) {
    for (int i = 0; i < a.Length - 1; i++)
        for (int j = 0; j < a.Length - 1 - i; j++)
            if (string.CompareOrdinal(a[j], a[j + 1]) > 0)   // a[j] va después que a[j + 1]
                (a[j], a[j + 1]) = (a[j + 1], a[j]);
}

/** Con textos se compara con strcmp (o con el operador <=>). */
function burbuja(array &$a): void {
    $n = count($a);
    for ($i = 0; $i < $n - 1; $i++)
        for ($j = 0; $j < $n - 1 - $i; $j++)
            if (strcmp($a[$j], $a[$j + 1]) > 0)              // $a[$j] va después que $a[$j + 1]
                [$a[$j], $a[$j + 1]] = [$a[$j + 1], $a[$j]];
}