Nombre Password [ Regístrate ]

Ordenación

 

Cuestiones generales

Su finalidad es organizar ciertos datos (normalmente arrays o ficheros) en un orden creciente o decreciente mediante una regla prefijada (numérica, alfabética...). Atendiendo al tipo de elemento que se quiera ordenar puede ser:

- Ordenación interna: Los datos se encuentran en memoria (ya sean arrays, listas, etc) y son de acceso aleatorio o directo (se puede acceder a un determinado campo sin pasar por los anteriores).

- Ordenación externa: Los datos están en un dispositivo de almacenamiento externo (ficheros) y su ordenación es más lenta que la interna.

 

Ordenación interna

Los métodos de ordenación interna se aplican principalmente a arrays unidimensionales. Los principales algoritmos de ordenación interna son:

Selección: Este método consiste en buscar el elemento más pequeño del array y ponerlo en primera posición; luego, entre los restantes, se busca el elemento más pequeño y se coloca en segudo lugar, y así sucesivamente hasta colocar el último elemento. Por ejemplo, si tenemos el array {40,21,4,9,10,35}, los pasos a seguir son:

{4,21,40,9,10,35} <-- Se coloca el 4, el más pequeño, en primera posición : se cambia el 4 por el 40.
{4,9,40,21,10,35} <-- Se coloca el 9, en segunda posición: se cambia el 9 por el 21.
{4,9,10,21,40,35} <-- Se coloca el 10, en tercera posición: se cambia el 10 por el 40.
{4,9,10,21,40,35} <-- Se coloca el 21, en tercera posición: ya está colocado.
{4,9,10,21,35,40} <-- Se coloca el 35, en tercera posición: se cambia el 35 por el 40.

Si el array tiene N elementos, el número de comprobaciones que hay que hacer es de N*(N-1)/2, luego el tiempo de ejecución está en O(n2)

int array[N];
int i,j,menor,aux;

// Dar valores a los elementos del array

for(i=0;i<N-1;i++)
{
  for(j=i+1,menor=i;j<N;j++)
  if(array[j]<array[menor]) // Si el elemento j es menor que el menor:
    menor=j; // el menor pasa a ser el elemento j.
  aux=array[i]; // Se intercambian los elementos
  array[i]=array[menor]; // de las posiciones i y menor
  array[menor]=aux; // usando una variable auxiliar.
}

Burbuja: Consiste en comparar pares de elementos adyacentes e intercambiarlos entre sí hasta que estén todos ordenados. Con el array anterior, {40,21,4,9,10,35}:

Primera pasada:
{21,40,4,9,10,35} <-- Se cambia el 21 por el 40.
{21,4,40,9,10,35} <-- Se cambia el 40 por el 4.
{21,4,9,40,10,35} <-- Se cambia el 9 por el 40.
{21,4,9,10,40,35} <-- Se cambia el 40 por el 10.
{21,4,9,10,35,40} <-- Se cambia el 35 por el 40.

Segunda pasada:
{4,21,9,10,35,40} <-- Se cambia el 21 por el 4.
{4,9,21,10,35,40} <-- Se cambia el 9 por el 21.
{4,9,10,21,35,40} <-- Se cambia el 21 por el 10.

Ya están ordenados, pero para comprobarlo habría que acabar esta segunda comprobación y hacer una tercera.

Si el array tiene N elementos, para estar seguro de que el array está ordenado, hay que hacer N-1 pasadas, por lo que habría que hacer (N-1)*(N-i-1) comparaciones, para cada i desde 1 hasta N-1. El número de comparaciones es, por tanto, N(N-1)/2, lo que nos deja un tiempo de ejecución, al igual que en la selección, en O(n2).

int array[N];
int i,j,aux;

// Dar valores a los elementos del array

for(i=0;i<N-1;i++) // Hacer N-1 pasadas.
{
  for(j=0;j<N-i-1;j++) // Mirar los N-i-1 pares.
  {
    if(array[j+1]<array[j]) // Si el elemento j+1 es menor que el elemento j:
    {
      aux=array[j+1]; // Se intercambian los elementos
      array[j+1]=array[j]; // de las posiciones j y j+1
      array[j]=aux; // usando una variable auxiliar.
    }
  }
}

Inserción directa: En este método lo que se hace es tener una sublista ordenada de elementos del array e ir insertando el resto en el lugar adecuado para que la sublista no pierda el orden. La sublista ordenada se va haciendo cada vez mayor, de modo que al final la lista entera queda ordenada. Para el ejemplo {40,21,4,9,10,35}, se tiene:

{40,21,4,9,10,35} <-- La primera sublista ordenada es {40}.

Insertamos el 21:
{40,40,4,9,10,35} <-- aux=21;
{21,40,4,9,10,35} <-- Ahora la sublista ordenada es {21,40}.

Insertamos el 4:
{21,40,40,9,10,35} <-- aux=4;
{21,21,40,9,10,35} <-- aux=4;
{4,21,40,9,10,35} <-- Ahora la sublista ordenada es {4,21,40}.

Insertamos el 9:
{4,21,40,40,10,35} <-- aux=9;
{4,21,21,40,10,35} <-- aux=9;
{4,9,21,40,10,35} <-- Ahora la sublista ordenada es {4,9,21,40}.

Insertamos el 10:
{4,9,21,40,40,35} <-- aux=10;
{4,9,21,21,40,35} <-- aux=10;
{4,9,10,21,40,35} <-- Ahora la sublista ordenada es {4,9,10,21,40}.

Y por último insertamos el 35:
{4,9,10,21,40,40} <-- aux=35;
{4,9,10,21,35,40} <-- El array está ordenado.

En el peor de los casos, el número de comparaciones que hay que realizar es de N*(N+1)/2-1, lo que nos deja un tiempo de ejecución en O(n2). En el mejor caso (cuando la lista ya estaba ordenada), el número de comparaciones es N-2. Todas ellas son falsas, con lo que no se produce ningún intercambio. El tiempo de ejecución está en O(n).

El caso medio dependerá de cómo están inicialmente distribuidos los elementos. Vemos que cuanto más ordenada esté inicialmente más se acerca a O(n) y cuanto más desordenada, más se acerca a O(n2).

El peor caso es igual que en los métodos de burbuja y selección, pero el mejor caso es lineal, algo que no ocurría en éstos, con lo que para ciertas entradas podemos tener ahorros en tiempo de ejecución.

int array[N];
int i,j,aux;

// Dar valores a los elementos del array

for(i=1;i<N;i++) // i contiene el número de elementos de la sublista.
{ 
  // Se intenta añadir el elemento i.
  aux=array[i];
  for(j=i-1;j>=0;j--) // Se recorre la sublista de atrás a adelante para buscar
  {                   // la nueva posición del elemento i.
    if(aux>array[j])  // Si se encuentra la posición:
    {
      array[j+1]=aux; // Ponerlo
      break;          // y colocar el siguiente número.
    }
    else              // si no, sigue buscándola.
      array[j+1]=array[j];
  }
  if(j==-1)     // si se ha mirado todas las posiciones y no se ha encontrado la correcta
    array[0]=aux; // es que la posición es al principio del todo.
}

Inserción binaria: Es el mismo método que la inserción directa, excepto que la búsqueda del orden de un elemento en la sublista ordenada se realiza mediante una búsqueda binaria (ver algoritmos de búsqueda), lo que en principio supone un ahorro de tiempo. No obstante, dado que para la inserción sigue siendo necesario un desplazamiento de los elementos, el ahorro, en la mayoría de los casos, no se produce, si bien hay compiladores que realizan optimizaciones que lo hacen ligeramente más rápido.

Shell: Es una mejora del método de inserción directa, utilizado cuando el array tiene un gran número de elementos. En este método no se compara a cada elemento con el de su izquierda, como en el de inserción, sino con el que está a un cierto número de lugares (llamado salto) a su izquierda. Este salto es constante, y su valor inicial es N/2 (siendo N el número de elementos, y siendo división entera). Se van dando pasadas hasta que en una pasada no se intercambie ningún elemento de sitio. Entonces el salto se reduce a la mitad, y se vuelven a dar pasadas hasta que no se intercambie ningún elemento, y así sucesivamente hasta que el salto vale 1.

Por ejemplo, lo pasos para ordenar el array {40,21,4,9,10,35} mediante el método de Shell serían:

Salto=3:
   Primera pasada:
   {9,21,4,40,10,35} <-- se intercambian el 40 y el 9.
   {9,10,4,40,21,35} <-- se intercambian el 21 y el 10.
Salto=1:
   Primera pasada:
   {9,4,10,40,21,35} <-- se intercambian el 10 y el 4.
   {9,4,10,21,40,35} <-- se intercambian el 40 y el 21.
   {9,4,10,21,35,40} <-- se intercambian el 35 y el 40.
   Segunda pasada:
   {4,9,10,21,35,40} <-- se intercambian el 4 y el 9.

Con sólo 6 intercambios se ha ordenado el array, cuando por inserción se necesitaban muchos más.

int array[N];
int salto,cambios,aux,i;

for(salto=N/2;salto!=0;salto/=2) // El salto va desde N/2 hasta 1.
{
  for(cambios=1;cambios!=0; )    // Mientras se intercambie algún elemento:
  {
    cambios=0;
    for(i=salto;i<N;i++)          // se da una pasada
      if(array[i-salto]>array[i]) // y si están desordenados
      {
        aux=array[i];             // se reordenan
        array[i]=array[i-salto];
        array[i-salto]=aux;
        cambios++;                // y se cuenta como cambio.
      }
  }
}

Ordenación rápida (quicksort): Este método se basa en la táctica "divide y vencerás" (ver sección divide y vencerás), que consiste en ir subdividiendo el array en arrays más pequeños, y ordenar éstos. Para hacer esta división, se toma un valor del array como pivote, y se mueven todos los elementos menores que este pivote a su izquierda, y los mayores a su derecha. A continuación se aplica el mismo método a cada una de las dos partes en las que queda dividido el array.

Normalmente se toma como pivote el primer elemento de array, y se realizan dos búsquedas: una de izquierda a derecha, buscando un elemento mayor que el pivote, y otra de derecha a izquierda, buscando un elemento menor que el pivote. Cuando se han encontrado los dos, se intercambian, y se sigue realizando la búsqueda hasta que las dos búsquedas se encuentran.Por ejemplo, para dividir el array {21,40,4,9,10,35}, los pasos serían:

{21,40,4,9,10,35} <-- se toma como pivote el 21. La búsqueda de izquierda a derecha encuantra el valor 40, mayor que pivote, y la búsqueda de derecha a izquierda encuentra el valor 10, menor que el pivote. Se intercambian:
{21,10,4,9,40,35} <-- Si seguimos la búsqueda, la primera encuentra el valor 40, y la segunda el valor 9, pero ya se han cruzado, así que paramos. Para terminar la división, se coloca el pivote en su lugar (en el número encontrado por la segunda búsqueda, el 9, quedando:
{9,10,4,21,40,35} <-- Ahora tenemos dividido el array en dos arrays más pequeños: el {9,10,4} y el {40,35}, y se repetiría el mismo proceso.

La implementación es claramente recursiva (ver recursividad), y suponiendo el pivote el primer elemento del array, el programa sería:

#include <stdio.h>

void ordenar(int *,int,int);

void main()
{
  // Dar valores al array

  ordenar(array,0,N-1); // Para llamar a la función
}

void ordenar(int *array,int desde,int hasta)
{
  int i,d,aux; // i realiza la búsqueda de izquierda a derecha
               // y j realiza la búsqueda de derecha a izquierda.
  if(desde>=hasta)
    return;

  for(i=desde+1,d=hasta; ; ) // Valores iniciales de la búsqueda.
  {
    for( ;i<=hasta && array[i]<=array[desde];i++); // Primera búsqueda
    for( ;d>=0 && array[d]>=array[desde];d--);     // segunda búsqueda
    if(i<d)                  // si no se han cruzado, intercambiar
    {
      aux=array[i];
      array[i]=array[d];
      array[d]=aux;
    }
    else                     // si se han cruzado, salir del bucle
      break;
  }
  if(d==desde-1) // Si la segunda búsqueda se sale del array es que el
    d=desde;     // pivote es el elemento más pequeño: se cambia con él mismo
  aux=array[d];  // Colocar el pivote en su posición    
  array[d]=array[desde];
  array[desde]=aux;

  ordenar(array,desde,d-1); // Ordenar el primer subarray.
  ordenar(array,d+1,hasta); // Ordenar el segundo subarray.
}

En C hay una función que realiza esta ordenación sin tener que implementarla, llamada qsort (incluida en stdlib.h):

qsort(nombre_array,número,tamaño,función);

donde nombre_array es el nombre del array a ordenar, número es el número de elementos del array, tamaño indica el tamaño en bytes de cada elemento y función es un puntero a una función que hay que implementar, que recibe dos elementos y devuelve 0 si son iguales, algo menor que 0 si el primero es menor que el segundo, y algo mayor que 0 si el segundo es menor que el primero. Por ejemplo, el programa de antes sería:

#include <stdio.h>
#include <stdlib.h>

int funcion(const void *,const void *);

void main()
{
  // Dar valores al array

  qsort(array,N,sizeof(array[0]),funcion);
}

int funcion(const void *a,const void *b)
{
  if(*(int *)a<*(int *)b)
    return(-1);
  else if(*(int *)a>*(int *)b)
    return(1);
  else 
    return(0);
}

Claramente, es mucho más cómodo usar qsort que implementar toda la función, pero hay que tener mucho cuidado con el manejo de los punteros en la función, sobre todo si se está trabajando con estructuras.

Intercalación: no es propiamente un método de ordenación, consiste en la unión de dos arrays ordenados de modo que la unión esté también ordenada. Para ello, basta con recorrer los arrays de izquierda a derecha e ir cogiendo el menor de los dos elementos, de forma que sólo aumenta el contador del array del que sale el elemento siguiente para el array-suma. Si quisiéramos sumar los arrays {1,2,4} y {3,5,6}, los pasos serían:

Inicialmente: i1=0, i2=0, is=0.
Primer elemento: mínimo entre 1 y 3 = 1. Suma={1}. i1=1, i2=0, is=1.
Segundo elemento: mínimo entre 2 y 3 = 2. Suma={1,2}. i1=2, i2=0, is=2.
Tercer elemento: mínimo entre 4 y 3 = 3. Suma={1,2,3}. i1=2, i2=1, is=3.
Cuarto elemento: mínimo entre 4 y 5 = 4. Suma={1,2,3,4}. i1=3, i2=1, is=4.
Como no quedan elementos del primer array, basta con poner los elementos que quedan del segundo array en la suma:
Suma={1,2,3,4}+{5,6}={1,2,3,4,5,6}

int i1,i2,is;
int array1[N1],array2[N2],suma[N1+N2];

for(i1=i2=is=0;i1<N1 && i2<N2;is++) // Mientras no se me acabe ni array1 ni array2:
{
  if(array1[i1]<array2[i2]) // Si el elemento de array1 es menor:
  {
    suma[is]=array1[i1];    // se utiliza el de array1.
    i1++;
  }
  else                 // Pero si el elemento de array2 es menor:
  {
    suma[is]=array2[i2];    // se utiliza el de array2.
    i2++;
  }
}
for( ;i1<N1;i1++,is++)  // Añadir los elementos de array1 (si quedan).
  suma[is]=array1[i1];
for( ;i2<N2;i2++,is++)  // Añadir los elementos de array2 (si quedan).
  suma[is]=array2[i2];

Fusión: Consta de dos partes, una parte de intercalación de listas y otra de divide y vencerás.

- Primera parte: ¿Cómo intercalar dos listas ordenadas en una sola lista ordenada de forma eficiente?

Suponemos que se tienen estas dos listas de enteros ordenadas ascendentemente:

lista 1: 1 -> 3 -> 5 -> 6 -> 8 -> 9
lista 2: 0 -> 2 -> 6 -> 7 -> 10

Tras mezclarlas queda:

lista: 0 -> 1 -> 2 -> 3 -> 5 -> 6 -> 6 -> 7 -> 8 -> 9 -> 10

Esto se puede realizar mediante un único recorrido de cada lista, mediante dos punteros que recorren cada una. En el ejemplo anterior se insertan en este orden -salvo los dos 6 que puede variar según la implementación-: 0 (lista 2), el 1 (lista 1), el 2 (lista 2), el 3, 5 y 6 (lista 1), el 6 y 7 (lista 2), el 8 y 9 (lista 1), y por llegar al final de la lista 1, se introduce directamente todo lo que quede de la lista 2, que es el 10.

En la siguiente implementación no se crea una nueva lista realmente, sólo se modifican los enlaces destruyendo las dos listas y fusionándolas en una sola. Se emplea un centinela que apunta a sí mismo y que contiene como clave el valor más grande posible. El último elemento de cada lista apuntará al centinela, incluso si la lista está vacía.

struct lista
{
  int clave;
  struct lista *sig;
};


struct lista *centinela;
centinela = (struct lista *) malloc(sizeof(struct lista));
centinela->sig = centinela;
centinela->clave = INT_MAX;
...

struct lista *fusion(struct lista *l1, struct lista *l2)
{
  struct lista *inic, *c;

  if (l1->clave < l2->clave) { inic = l1; l1 = l1->sig; }
  else { inic = l2; l2 = l2->sig; }
  c = inic;
  while (l1 != centinela && l2 != centinela) {
    if (l1->clave < l2->clave) {
      c->sig = l1; l1 = l1->sig;
    }
    else {
      c->sig = l2; l2 = l2->sig;
    }
    c = c->sig;
  }
  if (l1 != centinela) c->sig = l1;
  else if (l2 != centinela) c->sig = l2;
  return inic;
}

- Segunda parte: divide y vencerás. Se separa la lista original en dos trozos del mismo tamaño (salvo listas de longitud impar) que se ordenan recursivamente, y una vez ordenados se fusionan obteniendo una lista ordenada. Como todo algoritmo basado en divide y vencerás tiene un caso base y un caso recursivo.

* Caso base: cuando la lista tiene 1 ó 0 elementos (0 se da si se trata de ordenar una lista vacía). Se devuelve la lista tal cual está.

* Caso recursivo: cuando la longitud de la lista es de al menos 2 elementos. Se divide la lista en dos trozos del mismo tamaño que se ordenan recursivamente. Una vez ordenado cada trozo, se fusionan y se devuelve la lista resultante.

El esquema es el siguiente:

Ordenar(lista L)
inicio
  si tamaño de L es 1 o 0 entonces
    devolver L
  si tamaño de L es >= 2 entonces
    separar L en dos trozos: L1 y L2.
    L1 = Ordenar(L1)
    L2 = Ordenar(L2)
    L = Fusionar(L1, L2)
    devolver L
fin

El algoritmo funciona y termina porque llega un momento en el que se obtienen listas de 2 ó 3 elementos que se dividen en dos listas de un elemento (1+1=2) y en dos listas de uno y dos elementos (1+2=3, la lista de 2 elementos se volverá a dividir), respectivamente. Por tanto se vuelve siempre de la recursión con listas ordenadas (pues tienen a lo sumo un elemento) que hacen que el algoritmo de fusión reciba siempre listas ordenadas.

Se incluye un ejemplo explicativo donde cada sublista lleva una etiqueta identificativa.


Dada: 3 -> 2 -> 1 -> 6 -> 9 -> 0 -> 7 -> 4 -> 3 -> 8 (lista original)

se divide en:
3 -> 2 -> 1 -> 6 -> 9 (lista 1)
0 -> 7 -> 4 -> 3 -> 8 (lista 2)
·    se ordena recursivamente cada lista:
·    3 -> 2 -> 1 -> 6 -> 9 (lista 1)
·  ·      se divide en:
·  ·      3 -> 2 -> 1 (lista 11)
·  ·      6 -> 9 (lista 12)
·  ·          se ordena recursivamente cada lista:
·  ·          3 -> 2 -> 1 (lista 11)
·  ·  ·            se divide en:
·  ·  ·            3 -> 2 (lista 111)
·  ·  ·            1 (lista 112)
·  ·  ·                se ordena recursivamente cada lista:
·  ·  ·                3 -> 2 (lista 111)
·  ·  ·                    se divide en:
·  ·  ·                    3 (lista 1111, que no se divide, caso base). Se devuelve 3
·  ·  ·                    2 (lista 1112, que no se divide, caso base). Se devuelve 2
·  ·  ·                    se fusionan 1111-1112 y queda:
·  ·  ·                         2 -> 3. Se devuelve 2 -> 3
·  ·  ·                1 (lista 112)
· · · 1 (lista 1121, que no se divide, caso base). Se devuelve 1
· · · se fusionan 111-112 y queda: · · · 1 -> 2 -> 3 (lista 11). Se devuelve 1 -> 2 -> 3 · · 6 -> 9 (lista 12) · · · se divide en: · · · 6 (lista 121, que no se divide, caso base). Se devuelve 6 · · · 9 (lista 122, que no se divide, caso base). Se devuelve 9 · · · se fusionan 121-122 y queda: · · · 6 -> 9 (lista 12). Se devuelve 6 -> 9
· · se fusionan 11-12 y queda: · · 1 -> 2 -> 3 -> 6 -> 9. Se devuelve 1 -> 2 -> 3 -> 6 -> 9 · 0 -> 7 -> 4 -> 3 -> 8 (lista 2) · ... tras repetir el mismo procedimiento se devuelve 0 -> 3 -> 4 -> 7 -> 8 · se fusionan 1-2 y queda: · 0 -> 1 -> 2 -> 3 -> 3 -> 4 -> 6 -> 7 -> 8 -> 9, que se devuelve y se termina.

 

La implementación propuesta emplea un centinela sobre la lista inicial que apunte hacia sí mismo y que además contiene el máximo valor de un entero. La lista dispone de cabecera y centinela, pero obsérvese como se elimina durante la ordenación.

#include <stdlib.h>
#include <limits.h>

struct lista
{
  int clave;
  struct lista *sig;
};
/* lista con cabecera y centinela */
struct listacc
{
  struct lista *cabecera,
               *centinela;
};

/* centinela declarado como variable global */
struct lista *centinela;

  /* fusiona dos listas */
struct lista *fusion(struct lista *l1, struct lista *l2)
{
  struct lista *inic, *c;

  if (l1->clave < l2->clave) { inic = l1; l1 = l1->sig; }
  else { inic = l2; l2 = l2->sig; }
  c = inic;
  while (l1 != centinela && l2 != centinela) {
    if (l1->clave < l2->clave) {
      c->sig = l1; l1 = l1->sig;
    }
    else {
      c->sig = l2; l2 = l2->sig;
    }
    c = c->sig;
  }
  if (l1 != centinela) c->sig = l1;
  else if (l2 != centinela) c->sig = l2;
  return inic;
}

  /* algoritmo de ordenación por fusión mediante divide y vencerás */
struct lista *ordenfusion(struct lista *l)
{
  struct lista *l1, *l2, *parte1, *parte2;

    /* caso base: 1 ó 0 elementos */
  if (l->sig == centinela) return l;


    /* caso recursivo */
  /* avanza hasta la mitad de la lista */
  l1 = l; l2 = l1->sig->sig;
  while (l2 != centinela) {
    l1 = l1->sig;
    l2 = l2->sig->sig;
  }
  /* la parte en dos */
  l2 = l1->sig;
  l1->sig = centinela;

  /* ordena recursivamente cada parte */
  parte1 = ordenfusion(l);
  parte2 = ordenfusion(l2);

  /* mezcla y devuelve la lista mezclada */
  l = fusion(parte1, parte2);
  return l;
}


  /* operaciones de lista */
void crearLCC(struct listacc *LCC)
{
  LCC->cabecera = (struct lista *) malloc(sizeof(struct lista));
  LCC->centinela = (struct lista *) malloc(sizeof(struct lista));
  LCC->cabecera->sig = LCC->centinela;
  LCC->centinela->sig = LCC->centinela;
}

  /* inserta un elemento al comienzo de la lista */
void insertarPrimero(struct listacc LCC, int elem)
{
  struct lista *nuevo;

  nuevo = (struct lista *) malloc(sizeof(struct lista));
  nuevo->clave = elem;
  nuevo->sig = LCC.cabecera->sig;
  LCC.cabecera->sig = nuevo;
}

int main(void)
{
  struct listacc LCC;
  crearLCC(&LCC);
  centinela = LCC.centinela;
  centinela->clave = INT_MAX;

  insertarPrimero(LCC, 8);
  insertarPrimero(LCC, 3);
  insertarPrimero(LCC, 4);
  insertarPrimero(LCC, 7);
  insertarPrimero(LCC, 0);
  insertarPrimero(LCC, 9);
  insertarPrimero(LCC, 6);
  insertarPrimero(LCC, 1);
  insertarPrimero(LCC, 2);
  insertarPrimero(LCC, 3);
  LCC.cabecera = ordenfusion(LCC.cabecera->sig);

  return 0;
}

Este es un buen algoritmo de ordenación, pues no requiere espacio para una nueva lista y sólo las operaciones recursivas consumen algo de memoria. Es por tanto un algoritmo ideal para ordenar listas.

La complejidad es la misma en todos los casos, ya que no influye cómo esté ordenada la lista inicial -esto es, no existe ni mejor ni peor caso-, puesto que la intercalación de dos listas ordenadas siempre se realiza de una única pasada. La complejidad es proporcional a N·logN, característica de los algoritmos "Divide y Vencerás". Para hacer más eficiente el algoritmo es mejor realizar un primer recorrido sobre toda la lista para contar el número de elementos y añadir como parámetro a la función dicho número.

 

 


© (2001-2008) ALGORITMIA.NET - Política de privacidad