Mestimissortimine

Mestimissortimine (inglise keeles merge sort) ehk ühildusmeetodil sortimine on sortimisalgoritm, mille leiutas 1945. aastal John von Neumann. See oli üks esimesi sortimisalgoritme. Sellise sortimise halvim, parim ja keskmine keerukus on .

Mestimissortimine kasutab ära asjaolu, et kahe sorditud loendi ühendamine üheks sorditud loendiks on lihtne (lineaarse keerukusega). Algoritm jagab loendi kaheks ligikaudu võrdse suurusega loendiks, mis sorditakse omakorda mestimissortimisega, seejärel ühendatakse saadud sorditud loendid.

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]))

Ü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 
Ühildusmeetodi kiiruse analüüsil tuleb arvesse võtta nii järjendi poolitamise kui ka ühildamise protsessi. Esiteks jagatakse järjendit rekursiivselt pooleks, selle protsessi kiirus on , kus  on elementide arv järjendis. Seejärel tuleb sorditud järjendid ühildada. Iga järjendi element pannakse lõplikus järjendis õigele kohale, seega  liikme läbivaatamine nõuab  operatsiooni. Ühildusmeetodil sortimine on seega  keerukusega algoritm. 
On oluline tähele panna, et järjendite poolitamise järel on vaja mäluruumi saadud järjendite meelespidamiseks. Kuna sorditavad järjendid võivad olla suured, siis võib poolitatud järjendite hoidmiseks vajaminev vaba mälumaht olla piiratud. See teeb ühildusmeetodi kasutamise suurte andmehulkade peal problemaatiliseks.

Viited

Matemaatika
Sortimisalgoritmid