#shell sort

[nari-online]

Shell sort best sort!!! (reupload from 2 years ago, accidentally deleted the post lmfao)

[prachivermablr]

Shell Sort in Data Structure - TechVidvan

Learn what is shell sort, its working & implementation in various programming languages. See some real-life applications of shell sort.

[prachivermablr]

Shell Sort in Data Structure - DataFlair

Learn about Shell sort which does not require extra memory and makes it an overall efficient algorithm for sorting. See working & algorithm.

[facingissuesonit]

Shell Sort Program and Complexity (Big-O)

Shell Sort Program and Complexity (Big-O)

Shellsort is an in-place comparison sort, also known as Shell sort or Shell’s method. It’s mainly variation of insertion sort or bubble sort . There was one drawback with insertion sort, we move elements only one position ahead but when an elements are too far then lots of movements are involved. To reduce these movements Shell sort come with idea of allow exchange of far items.

Shell Sort Steps

View On WordPress

[algorithmsgeometrypatterns]

Sorting Algorithm Animations

These pages show 8 different sorting algorithms on 4 different initial conditions. 

http://www.sorting-algorithms.com/

Merge sort is the winner..

[openuiz]

Shell sort 에서의 간격?

shell sort에서 MarcinCiura의 연구에 의하면

1,4, 10, 23, 57, 132, 301, 701, 1750 ... 과 같은 간격을 사용하는게 연산 시간을 많이 줄인다고 한다..

그러면 이것이 다른 분할 규칙에서도 유용할 것인가?

그리고.. 당췌 위 기준은 무엇을 기준으로 완성된 기준일까??

하여 아래와 같은 것을 찾았다.

Optimal gap

The fundamental problem of Shell sort is to determine the optimal gap between compared elements. In the original algorithm Donald Shellproposed an initial gap of size ( is the size of the array), divided by in each step. Thich approach has one big disadvantage – elements at odd and even places are mutually compared only in the last step.

Other implementations used gap size (Hibbard) with the worst case complexity , or (Sedgewick) with complexity . The best performance is offered by a sequence by Marcin Ciura - 1, 4, 10, 23, 57, 132, 301, 701, 1750 every next gap size is generated by multiplying the previous size by .

출처: http://en.algoritmy.net/article/41653/Shell-sort

/** * Shell sort - sort with diminishing increment (descending) * @param array to be sorted * @param size array size * @return sorted array */ int * shellSort(int * array, int size) {    int gap = size / 2;    while (gap > 0) {        for (int i = 0; i < size - gap; i++) { //modified insertion sort            int j = i + gap;            int tmp = array[j];            while (j >= gap && tmp > array[j - gap]) {                array[j] = array[j - gap];                j -= gap;            }            array[j] = tmp;        }        if (gap == 2) { //change the gap size            gap = 1;        } else {            gap /= 2.2;        }    }    return array; }

[exacs-blog]

Ordenación Shell (por peine) - Algoritmos de ordenación (2/6)

Hoy vamos a seguir con nuestra serie de algoritmos de ordenación. Después de la ordenación por burbuja, hoy le toca el turno a la ordenación Shell.

Go!

Es una variación de la ordenación por burbuja. Si recordamos la ordenación por burbuja, consistía en tomar un par de elementos adyacentes y reordenarlos. Después tomar el par anterior y repetir. Cuando lleguemos al principio, repetimos el proceso completo hasta terminar de ordenar.

Bien, ¿qué ocurre si en lugar de tomar dos elementos adyacentes, tomamos un par de elementos separados una distancia X?

Supongamos el mismo array desordenado de la otra vez. Y comenzaremos tomando la distancia máxima, es decir, el primero y último:

VUELTA 1 2 - 5 - 6 - 8 - 9 - 3 - 7 - 6 - 1 - 0 ^ ^

Como están colocados al revés, reordenamos

0 - 5 - 6 - 8 - 9 - 3 - 7 - 6 - 1 - 2

Ahora, tomamos una distancia más pequeña y vamos retrocediendo como en burbuja.

VUELTA 2 0 - 5 - 6 - 8 - 9 - 3 - 7 - 6 - 1 - 2 ^ ^ 0 - 5 - 6 - 2 - 9 - 3 - 7 - 6 - 1 - 8 ^ ^ 0 - 5 - 1 - 2 - 9 - 3 - 7 - 6 - 6 - 8 ^ ^ 0 - 5 - 1 - 2 - 9 - 3 - 7 - 6 - 6 - 8 ^ ^ 0 - 5 - 1 - 2 - 9 - 3 - 7 - 6 - 6 - 8

Ahora, reducimos aún más la distancia

VUELTA 3 0 - 5 - 1 - 2 - 9 - 3 - 7 - 6 - 6 - 8 ^ ^ 0 - 5 - 1 - 2 - 9 - 3 - 7 - 6 - 6 - 8 ^ ^ 0 - 5 - 1 - 2 - 6 - 3 - 7 - 6 - 9 - 8 ^ ^ 0 - 5 - 1 - 2 - 6 - 3 - 7 - 6 - 9 - 8 ^ ^ 0 - 5 - 1 - 2 - 6 - 3 - 7 - 6 - 9 - 8 ^ ^ 0 - 3 - 1 - 2 - 6 - 5 - 7 - 6 - 9 - 8 ^ ^ 0 - 3 - 1 - 2 - 6 - 5 - 7 - 6 - 9 - 8

Y así sucesivamente.

Procedemos a implementar

Necesitamos, como en burbuja, una variable que nos lleve la cuenta de las inversiones que hacemos en una vuelta.

int swaps = 0;

Y otra variable que nos lleve la cuenta del “hueco” o “distancia” entre elementos a comparar. Dicha distancia comienza desde el máximo (longitud del array menos 1)

int gap = arr.length-1;

Llegamos al bucle.

while(swaps>0 || gap>1) { swaps=0;

En este caso, nuestra j va desde el final, hasta lo mínimo posible, es decir, hasta que el elemento a comparar (a la izquierda, separado gap unidades) sea el primero.

for (int j=this.arr.length-1; j-gap>=0; j--) { //j=0

Comprobamos si tenemos que invertir

if (this.arr[j] < this.arr[j-gap]) { int aux = this.arr[j]; this.arr[j] = this.arr[j-gap]; this.arr[j-gap] = aux; swaps++; }

Una vez hemos hecho la vuelta completa, tenemos que reducir el gap. La reducción se hace dividiendo la distancia entre 1.3, que se ha estudiado que es un buen coeficiente.

if (gap>1) { gap = (int) (gap / 1.3); }

Además, se ha demostrado que si cuando el hueco debería ser 9 o 10, se configura como 11, el algoritmo mejora.

if (gap==9 || gap==10) { gap = 11; } }

Como veis el algoritmo es similar a la ordenación por burbuja pero este es mucho más eficiente.

Aquí está el código del archivo CombSort.java y el del repositorio completo hasta la fecha de hoy

Podéis encontrar todos los posts sobre Algoritmos de ordenación en el tag #SortingAlgorithms

[hipnosia-visuals]

audacity_AUGverb_GlitchSort3