Shell sorteringsalgoritme med eksempel

Hvad er Shell-sortering?

Shell Sort, også kaldet Shells metode, er en effektiv sorteringsalgoritme baseret på in-place sammenligning. Opkaldt efter Donald Shell, der introducerede ideen i 1959, er det en generaliseret udvidelse af indsættelsessortering, der overvinder dens kvadratiske opførsel på spredte data.

Den grundlæggende idé er at gruppere elementer, der er langt fra hinanden, sortere hver gruppe ved hjælp af indsættelsessortering og formindske mellemrummet trin for trin, indtil det når én. På det tidspunkt er arrayet næsten sorteret.

Dette hul, intervallet, følger en valgt rækkefølge såsom Shells original, Knuths, Hibbards eller Sedgewicks. Shells original er n/2, n/4, ..., 1.

Skalsorteringsalgoritme

Trin 1) Initialiser intervalværdien h = n/2, hvor n er størrelsen af ​​arrayet.

Trin 2) Placer alle elementerne inden for en afstand af intervallet h i en underliste.

Trin 3) Sorter hver underliste ved hjælp af indsættelsessortering.

Trin 4) Indstil et nyt interval h = h/2.

Trin 5) Hvis h > 0, gå tilbage til trin 2. Ellers gå til trin 6.

Trin 6) Det resulterende array er nu fuldt sorteret.

Sådan fungerer Shell-sortering

I indsættelsessortering flyttes elementer kun én position ad gangen. Shell Sort opdeler i stedet arrayet i underlister med bred afstand baseret på intervallet og kører indsættelsessortering på hver underliste.

Efterhånden som intervallet krymper, vokser dellistens størrelse. Da tidligere gennemløb efterlader dataene delvist sorteret, kræver kortere intervaller langt færre ombytninger end at køre indsætnings sortering fra bunden. Figuren nedenfor illustrerer ét Shell Sort-gennemløb.

Shell Sort-algoritmens funktion med eksempel

Lad os sortere arrayet nedenfor ved hjælp af Shell Sort.

Trin 1) Arraystørrelsen er 8, så den indledende intervalværdi er h = 8/2 = 4.

Trin 2) Gruppér elementer fire positioner fra hinanden. Underlister: {8, 1}, {6, 4}, {7, 5}, {2, 3}.

Trin 3) Sortér hver underliste ved hjælp af indsættelsessortering. En midlertidig variabel holder den værdi, der placeres, mens elementerne flyttes. Efter ombytningerne ser arrayet sådan ud.

Trin 4) Formindsk intervallet. Det nye interval er h = 4/2 = 2.

Trin 5) Fordi 2 > 0, vend tilbage til trin 2 og grupper elementerne to positioner fra hinanden: {1, 5, 8, 7} og {4, 2, 6, 3}.

Sortér den første underliste. Arrayet bliver:

Efter sortering af den anden underliste:

Reducer intervallet igen til h = 2/2 = 1. Med et mellemrum på én kører Shell Sort en sidste indsættelses-sorteringsproces over hele arrayet, som vist nedenfor.

Trin 6) Hvis man dividerer intervallet igen, får man 0. Arrayet er nu fuldt sorteret:

pseudoCode til Shell-sortering

Start
Input array a of size n
for (interval = n / 2; interval > 0; interval /= 2)
    for (i = interval; i < n; i += 1)
        temp = a[i];
        for (j = i; j >= interval && a[j - interval] > temp; j -= interval)
            a[j] = a[j - interval];
        a[j] = temp;
End

Shell Sorteringsprogram i C/C++

Input:

//Shell Sort Program in C/C++
#include <bits/stdc++.h>
using namespace std;
void ShellSort(int data[], int size) {
    for (int interval = size / 2; interval > 0; interval /= 2) {
        for (int i = interval; i < size; i += 1) {
            int temp = data[i];
            int j;
            for (j = i; j >= interval && data[j - interval] > temp; j -= interval) {
                data[j] = data[j - interval];
            }
            data[j] = temp;
        }
    }
}
int main() {
    int data[] = {8, 6, 7, 2, 1, 4, 5, 3};
    int size = sizeof(data) / sizeof(data[0]);
    ShellSort(data, size);
    cout << "Sorted Output: \n";
    for (int i = 0; i < size; i++)
        cout << data[i] << " ";
    cout << "\n";
}

Output:

Sorted Output:

1 2 3 4 5 6 7 8

Shell Sortering Eksempel i Python

Input:

#Shell Sort Example in Python
def ShellSort(data, size):
    interval = size // 2
    while interval > 0:
        for i in range(interval, size):
            temp = data[i]
            j = i
            while j >= interval and data[j - interval] > temp:
                data[j] = data[j - interval]
                j -= interval
            data[j] = temp
        interval //= 2
data = [8, 6, 7, 2, 1, 4, 5, 3]
ShellSort(data, len(data))
print('Sorted Output:')
print(data)

Output:

Sorted Output:
[1, 2, 3, 4, 5, 6, 7, 8]

Anvendelser af Shell Sort

Shell Sort vises stadig i moderne systemer, hvor stakplads eller enkelhed er vigtig.

• Linux-kernen bruger Shell Sort på steder, hvor det er vigtigt at undgå en kaldstak.
• uClibc's indlejrede C-bibliotek bruger Shell Sort til at holde hukommelsesforbruget lavt.
• bzip2 bruger Shell Sort til at undgå dyb rekursion under bloksortering.
• Indlejret firmware favoriserer Shell Sort til små datasæt, hvor rekursion er begrænset.

Fordele og ulemper ved skalsortering

Shell Sort kompleksitetsanalyse

Tidskompleksitet af Shell-sortering

Tidskompleksiteten af ​​Shell Sort afhænger af den anvendte gap-sekvens.

I bedste fald, når arrayet allerede næsten er arrangeret, behøver hver gennemløb kun et logaritmisk antal tests, hvilket giver O(n log n).

I værste fald er arrayet arrangeret, så elementerne har brug for maksimale sammenligninger, og den endelige forøgelse dominerer ved O(n^2) med Shells oprindelige sekvens.

1. Bedste-case kompleksitet: O(n log n)
2. Gennemsnitlig kompleksitet i tilfældet: O(n log n) til O(n^(4/3)) afhængigt af gapsekvensen
3. Worst-case kompleksitet: O(n^2) med Shells oprindelige sekvens

Den bedste generelle gap-sekvens er stadig et åbent forskningsspørgsmål, selvom Sedgewick- og Ciura-sekvenser fungerer godt i praksis.

Shell Sort Space kompleksitet

Shell Sort kræver ikke hjælpearrays, så rumkompleksiteten er O(1) uanset inputstørrelse, hvilket er en af ​​dens stærkeste praktiske fordele.

Ofte Stillede Spørgsmål