Metodo de Ordenamiento

SHELL

ESTRUCTURAS DE DATOS
II
 Algoritmo de ordenamiento Shell
El método se denomina así en honor de su inventor Donald Shell.
El Shell sort es una generalización del ordenamiento por inserción, teniendo en cuenta
dos observaciones: El ordenamiento por inserción es eficiente si la entrada está "casi
ordenada". El ordenamiento por inserción es ineficiente, en general, porque mueve los
valores sólo una posición cada vez.
El algoritmo Shell sort mejora el ordenamiento por inserción comparando elementos
separados por un espacio de varias posiciones. Esto permite que un elemento haga
"pasos más grandes" hacia su posición esperada. Los pasos múltiples sobre los datos
se hacen con tamaños de espacio cada vez más pequeños. El último paso del Shell sort
es un simple ordenamiento por inserción, pero para entonces, ya está garantizado que
los datos del vector están casi ordenados.
 El método de Shell es una versión mejorada del método de inserción directa recibe ese nombre en
honor a su autor Donald L. Shell quien lo propuso en 1959. METODO DE ORDENAMIENTO SHELL
Ordenamiento por intervalos decrecientes, nombrado así debido a su inventor Donald Shell, este
algoritmo ordena subgrupos de elementos separados K unidades respecto de su posición en el arreglo.
El valor K es llamado intervalo. Después de que los primeros K subgrupos fueron ordenados
generalmente utilizando Inserción Directa, se escoge un nuevo valor de K más pequeño, y el arreglo es
de nuevo partido entre el nuevo conjunto de subgrupos. Cada uno de los subgrupos mayores es
ordenado y el proceso se repite de nuevo con un valor más pequeño de K. Cuando el incremento toma
un valor de 1, todos los elementos pasan a formar parte del subgrupo y se aplica inserción directa. 
 El método se basa en tomar como salto al principio N/2, siendo N el número de elementos, y luego se
va reduciendo a la mitad en cada repetición hasta lograr un valor de 1. MÉTODO DE ORDENACIÓN
SHELL O SHELL SORT
 1.- Dividir la lista en n/2 grupos de dos, considerando un incremento o salto entre los elementos de
n/2.
 2.- Clarificar cada grupo por separado, comparando las parejas de elementos, y si no están ordenados,
se intercambian.
3.- Se divide ahora la lista en la mitad de grupos (n/4), con un incremento o salto entre los elementos
también (n/4), y nuevamente se clasifica cada grupo por separado.

4.- Así sucesivamente, se sigue dividiendo la lista en la mitad de grupos que en el recorrido anterior
con un incremento o salto decreciente en la mitad que el salto anterior, y luego clasificando cada grupo
por separado.
 5.- El algoritmo termina cuando se consigue cuando el tamaño del salto es 1
 PASOS A SEGUIR DE MÉTODO DE ORDENAMIENTO SHELL
METODO SHELL
0 1 2 3 4 5 6
inc i j temp a[j-inc] a[j] 5 3 9 2 1 4 0
3 3 3 2 5        5     
    0      2 3 9 5 1 4 0
  4 4 1 3          3   
    1      2 1 9 5 3 4 0
  5 5 4 9            9 
    2      2 1 4 5 3 9 0
  6 6 0 5              5
    3      0    2     
    0      0 1 4 2 3 9 5
1 1 1 1 0  0 1 4 2 3 9 5
  2 2 4 1  0 1 4 2 3 9 5
  3 3 2 4        4     
    2  1  0 1 2 4 3 9 5
  4 4 3 4          4   
    3      0 1 2 3 4 9 5
  5 5 9 4  0 1 2 3 4 9 5
  6 6 5 9              9
    5      0 1 2 3 4 5 9
  7                     
0 fin                      
A continuación se presenta el algoritmo de Shell sort en pseudocódigo:
a=elementos a ordenar
inc=(n/2) {inc es el incremento o distancia entre elementos a comparar}
mientras_1 inc>0
hacer con i=inc, i<n, i++
j=i
temp=a[i]
mientras_2 j>=inc y a[j-inc] > temp
temp1=a[j-inc]
a[j]=a[j-inc]
a[j-inc]=temp1
j=j-inc
fin mientras_2
fin hacer
inc=inc/2
fin mientras_1
En java
public static void shell(int A[]){                                      aux=A[i]; // se reordenan
   int salto, aux, i;                                      A[i]=A[i-salto];
   boolean cambios;                                      A[i-salto]=aux;
   for(salto=A.length/2; salto!=0; salto/=2){                                      cambios=true; // y se
marca como cambio.
           cambios=true;
                               }
           while(cambios){ // Mientras se
intercambie algún elemento                         }
                       cambios=false;             }
                       for(i=salto; i< A.length; i++) // se }
da una pasada
                               if(A[i-salto]>A[i]){ // y si
están desordenados