Shell sort en java:

El siguiente cdigo escrito en el lenguaje JAVA recibe como parmetro el conjunto de elementos
representado en un arreglo de nmeros enteros y define inicialmente el incremento como la mitad
del tamao del vector, entonces se ordenan por insercin los elementos de las posiciones v[0] y
v[n/2], luego los de las posiciones v[1] y v[n/2] +1, y as sucesivamente. Cuando termina este
proceso, se divide por dos el tamao del incremento y se repite el proceso hasta que el incremento
sea igual a 1, en cuyo caso su comportamiento sera exactamente el del algoritmo de ordenacin
por insercin.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Algoritmo de ordenacion ShellSort
public static void ordenacionShell(int[] v) {
final int N = v.length;
int incremento = N;
do {
incremento = incremento / 2;
for (int k = 0; k < incremento; k++) {
for (int i = incremento + k; i < N; i += incremento) {
int j = i;
while (j - incremento >= 0 && v[j] < v[j - incremento]) {
int tmp = v[j];
v[j] = v[j - incremento];
v[j - incremento] = tmp;
j -= incremento;
}
}
}
} while (incremento > 1);
}

En cuanto a la complejidad del algoritmo, sta tiende a ser O(n log n), teniendo en cuenta que este
mtodo se basa en la ordenacin por insercin la cual tiende a ser O(n) en el mejor de los casos
(es decir, cuando el vector est casi ordenado), y que el proceso de ordenacin por insercin se
repite tantas veces como tarde la variable incremento en llegar al valor de 1, que es
aproximadamente el logaritmo en base 2 del tamao del vector.






MERGE:
Conceptualmente, el ordenamiento por mezcla funciona de la siguiente manera:
1. Si la longitud de la lista es 0 1, entonces ya est ordenada. En otro caso:
2. Dividir la lista desordenada en dos sublistas de aproximadamente la mitad del tamao.
3. Ordenar cada sublista recursivamente aplicando el ordenamiento por mezcla.
4. Mezclar las dos sublistas en una sola lista ordenada.
El ordenamiento por mezcla incorpora dos ideas principales para mejorar su tiempo de ejecucin:
1. Una lista pequea necesitar menos pasos para ordenarse que una lista grande.
2. Se necesitan menos pasos para construir una lista ordenada a partir de dos listas tambin
ordenadas, que a partir de dos listas desordenadas. Por ejemplo, slo ser necesario
entrelazar cada lista una vez que estn ordenadas.

import java.util.*;
public class MergeSort{

public static void main(String [] args){
Random r = new Random();
int test = 10000;
int actest = 0;
while(actest < test){
actest++;
int sz = (int)(r.nextDouble()*10000);
int [] num = new int[sz == 0?1:sz];
for(int i = 0; i < num.length; i++)
num[i] = r.nextInt();
sort(num);
if(!test(num)){
break;
}
}
if(actest == test)
System.out.println("Test superado");
else
System.out.println("BUGS BUGS BUGS !!!");
}

public static boolean test(int n[]){
for(int i = 1; i < n.length;i++)
if(n[i-1] > n[i])
return false;
return true;
}

public static int[] sort(int []n){
int i = 1;
for(i = 1; i < n.length;i*=2){
for(int j = 0;j < n.length; j += i){
int p = i >> 1;
merge(n,j,j+p-1,j+p,j+p+p-1);
}
}
merge(n,0,i/2 - 1,i/2,n.length);
return n;
}

public static void merge(int [] n,int a,int b,int c,int d){
d = Math.min(d,n.length-1);
int mer [] = new int[d-a + 1];
int idx = 0;
int or = a;
while( idx < mer.length)
if((a>b ?false: (c>d? true : n[a] <= n[c])))
mer[idx++] = n[a++];
else
mer[idx++] = n[c++];

for(int i = 0; i < mer.length; i++)
n[or + i] = mer[i];
}
}