Mestimissortimine

Mestimissortimine (inglise keeles merge sort) ehk ühildusmeetodil sortimine on sortimisalgoritm, mille leiutas 1945. aastal John von Neumann. See oli üks esimesi sorteerimisalgoritme. Sellise sorteerimise 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]))
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 , kus  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  liikme läbi vaatamine nõuab  operatsiooni. Ühildusmeetodil sorteerimine on seega  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.