Dos populares algoritmos de ordenamiento de vectores, de rendimiento cuadratico( son lentos )

#include <iostream>
using namespace std;

void printArray( int *arr, int len )
{
    for( int i = 0; i < len; i++ )
        std::cout << arr[ i ] << std::endl;
}

void interchange( int &a, int &b )
{
    int aux = a;
    a = b;
    b = aux;
}
// algoritmo de la burbuja mejorado
void improvedBubbleSort( int *arr, int len )
{
    bool no_intercambio;
    int i = 1;

    do
    {
        no_intercambio = true;

        for( int j = i; j < len - 1; j++ )
            if( arr[ j ] < arr[ j + 1 ] )
            {
                interchange( arr[ j ], arr[ j + 1 ] );
                no_intercambio = false;
            }

        i++;

    }while( no_intercambio );
}

bool insertarOrdenado( int *arr, int len, int target )
{
    int i = 0;
    bool ret = false;

    // busco una posicion para el objetivo
    while( i < len && target > arr[ i ] )
        i++;

    // si hay una posicion disponible
    if( i != len )
    {
        int pos = i;

        // hago lugar corriendo todos los elementos a la derecha
        while( len > i )
        {
            arr[ len ] = arr[ len - 1 ];
            len--;
        }

        // inserto el objetivo en la posiciono correspondiente
        arr[ pos ] = target;
        ret = true;
    }

    // si realizo alguna insercion devuelve verdadero
    return ret;
}

// mi version del algoritmo de ordenamiento por insercion
void insertionSor( int *arr, int cantidad_elementos )
{
    int posicion = cantidad_elementos - 1;

    // empiezo desde atras para adelante
    while( posicion > 0 )
    {
        // tomo el ultimo elemento y busco su lugar en el arreglo
        bool aux = insertarOrdenado( arr, posicion, arr[ posicion ] );

        // si no se realizo un cambio tomo el siguiente elemento hacia adelante
        if( !aux )
            posicion--;
    }
}

int main()
{
    int arr [] = { 2, 3, 7, 5, 1 };

    insertionSor( arr, 5 );
    printArray( arr, 5 );

    return 0;
}