Kasutaja:Urbanikm/Ühildusmeetod

Ühildusmeetodil sorteerimine (ingl merge sort) on üks esimesi sorteerimisalgoritme, mille pakkus välja 1945. aastal John von Neumann. Sellise sorteerimise halvim, parim ja keskmine keerukus on $O(n\log n)$.

Algoritm

Ühildusmeetod on rekursiivne algoritm, mis esmalt poolitab järjendi kaheks võrdseks osaks. Kui järjend on tühi või seal on ainult üks element, siis loetakse see sorteeritud järjendiks (tegemist on rekursiooni baasiga). Kui järjendis on rohkem kui üks element, siis jaotatakse järjend taas kaheks osaks ja rekursiivselt kasutatakse ühildussorteerimise meetodit mõlemal saadud järjendil. Kui mõlemad pooled on sorteeritud, siis need ühildatakse. Ühildamine tähendab kahe või enama sorteeritud järjendi kombineerimist üheks sorteeritud järjendiks. Lihtsaim viis ühe sorteeritud järjendi saavutamiseks on võrrelda ühildatavate järjendite esimesi ehk väiksemaid elemente ning väljastada neist vähim ning jätkata seda protsessi tulemuse saavutamiseni. Ühildamisel tegeletakse alati kolme järjendiga, neist kaks on sorteeritud järjendid, mis tuleb tulemuseni jõudmiseks ühildada, ning kolmas on tulemusjärjend.
Koodi kujul näeb see välja järgmiselt:

Mergesort(A[1, n]) 
    Merge(MergeSort(A[1, n/2 ]), MergeSort(A[ n/2 + 1, n]))

Ning ühildusmeetodil sorteerimise pseudokood on järgnev:

mergesort(item_type s[], int low, int high) { 
    int middle; 			/* index of middle element */ 
    if (low < high) { 
        middle = (low+high)/2;
        mergesort(s,low,middle); 
        mergesort(s,middle+1,high); 
        merge(s, low, middle, high); 
    } 
}

merge(item_type s[], int low, int middle, int high) { 
    int i;                        /* counter */ 
    queue buffer1, buffer2;       /* buffers to hold elements for merging */ 

    init_queue(&buffer1); 
    init_queue(&buffer2); 

    for (i=low; i<=middle; i++) enqueue(&buffer1,s[i]); 
    for (i=middle+1; i<=high; i++) enqueue(&buffer2,s[i]);

    i = low; 
    while (!(empty_queue(&buffer1) || empty_queue(&buffer2))) 	{
        if (headq(&buffer1) <= headq(&buffer2))
            s[i++] = dequeue(&buffer1);
        else 
            s[i++] = dequeue(&buffer2);
    } 

    while (!empty_queue(&buffer1)) s[i++] = dequeue(&buffer1);
    while (!empty_queue(&buffer2)) s[i++] = dequeue(&buffer2); 
}

Analüüs

Et analüüsida ühildusmeetodi kiirust, tuleb arvesse võtta nii järjendi poolitamise kui ka ühildamise protsessi. Esiteks jagatakse järjendit rekursiivselt pooleks, selle protsessi kiirus on $log(n)$, kus $n$ on elementide arv antud järjendis. Seejärel tuleb sorteeritud järjendid ühildada. Iga järjendi element pannakse lõplikus järjendis õigele kohale, seega $n$ liikme läbi vaatamine nõuab $n$ operatsiooni. Ühildusmeetodil sorteerimine on seega $O(n\log n)$ keerukusega algoritm.
On oluline tähele panna, et järjendite poolitamise järel on vaja mäluruumi, et saadud järjendeid meeles hoida. Kuna järjendid, mida sorteerida on vaja, võivad olla suured, siis võib poolitatud järjendite hoidmiseks vajaminev vaba mälu maht olla piiratud. See teeb ühildusmeetodi kasutamise suurte andmehulkade peal problemaatiliseks.