05# Algoritmo de Ordenamiento

Un algoritmo de ordenamiento es aquel que se encarga de mover elementos de una estructura de datos y mover con una relación de orden especifica. (Abecedario, números ascendentes, descendentes, etc..).

Gracias a estos ordenamientos se puede lograr una mayor eficiencia en los algoritmos de búsqueda que hablamos anteriormente.

El beneficio principal como se mencionó es la de identificar la ubicación de un dato con mayor facilidad, ya que los elementos de la estructura llevan un orden definido.

La clasificación de estos algoritmos se define mayormente en 3 partes:

1-      Según desde donde está realizando el ordenamiento (memoria RAM o memoria secundaria)

2-      Según el tiempo que utilice para realizar el ordenamiento dependiendo de cómo se le entreguen los datos.

3-      La estabilidad del proceso de ordenamiento.

Bubble Sort:

Uno de los algoritmos más conocidos gracias a su fácil implementación.

Los pasos de este algoritmo son los siguientes:

#include<iostream>

using namespace std;

int main() {

   int num, aux;

   int comparaciones = 0;

   int intercambios = 0;

   int* arreglo;

   cout << "Cuantos numeros seran: ";

   cin >> num;

   arreglo = new int[num];

   cout << endl << "***CAPTURA DE NUMEROS***" << endl;

   for(int x = 0; x < num; x++) {

      cout << "Ingresa el numero " << x << " de la serie: ";

      cin >> arreglo[x];

      cout << endl;

   }

   cout << "***MUESTRA DE NUMEROS***" << endl;

   for(int y = 0; y < num; y++) {

      cout << "Numero " << y << ".- " << arreglo[y] << endl;

   }

   for(int z = 1; z < num; ++z) {

      for(int v = 0; v < (num - z); ++v) {

         comparaciones++;

         if(arreglo[v] > arreglo[v + 1]) {

            aux = arreglo[v];

            arreglo[v] = arreglo[v + 1];

            arreglo[v + 1] = aux;

            intercambios++;

         }

      }

    }

   cout << "***NUMEROS ARREGLADOS***" << endl;

   for(int w = 0; w < num; w++) {

      cout << "Numero " << w << ".- " << arreglo[w] << endl;

   }

   cout << "Numero de comparaciones: " << comparaciones << endl;

   cout << "Numero de intercambios: " << intercambios << endl;

 

   delete[] arreglo;

   return 0;

}

Fuente : https://es.wikipedia.org/wiki/Ordenamiento_de_burbuja

Random Sort o Fisher-Yates

Este puede no ser muy conocido, pero lo vemos a menudo en la vida diaria por ejemplo cuando pones el modo aleatorio en los reproductores de música o cuando estamos en un juego al azar en la computadora o el celular, detrás de todo esos procesos está el algoritmo mencionado.

Aquí los pasos que rige este algoritmo

Algoritmo BarajadoAleatorio:

 Entrada:

      Un Array(0,1,2,3,4... Cantidad-1) de valores.

 Salida:

      El mismo array con sus valores en posiciones aleatorias.

 Definición de variables:

      Cantidad: Un entero que señala la cantidad total de ítems que tiene el array.

      k: Un entero, que rige la cuenta del bucle.

      az: Un entero, elegido por una función Random en el rango 0-k (nótese que k se va reduciendo).

      tmp: Un entero, que ha de contener un valor para intercambiar valores entre 2 posiciones.

 Funciones auxiliares:

      Tamaño: Una función que devuelve la cantidad de elementos que contiene el array.

      Random: Una función que devuelve un número aleatorio de un rango de valores.

 Cantidad = Tamaño(Array)  

 Recorrer con k desde Cantidad-1 hasta 1 Regresivamente

    az = Random(entre 0 y k)

    tmp = Array(az)

    Array(az) = Array(k)

    Array(k) = tmp

 Siguiente

Fuente: Wikipedia

Si nos ponemos a ver mucho más a fondo existen muchos algoritmos que cumplen este mismo propósito, pero unos orientados de diferente manera.