Divide et impera - mergesort

Mergesort (összefésülő rendezés)

Rendezési algoritmus divide et impera elv mentén.

Lépések:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
#include <iostream>
using namespace std;

void osszefesul(
    int t[], int bal, int kozep, int jobb)
{
    int ib = bal;
    int ij = kozep+1;

    int seged[1000];
    int n_seged = 0;

    while (ib <= kozep && ij <= jobb) {
        if (t[ib] <= t[ij]) {
            seged[n_seged] = t[ib];
            n_seged++;
            ib++;
        }
        else {
            seged[n_seged] = t[ij];
            n_seged++;
            ij++;
        }
    }

    while (ib <= kozep) {
        seged[n_seged] = t[ib];
        n_seged++;
        ib++;
    }

    while (ij <= jobb) {
        seged[n_seged] = t[ij];
        n_seged++;
        ij++;
    }

    for (int i = 0; i < n_seged; i++)
        t[bal+i] = seged[i];
}

void mergesort(int t[], int bal, int jobb)
{
    if (bal >= jobb)
        return;

    int kozep = (bal+jobb) / 2;

    mergesort(t, bal, kozep);
    mergesort(t, kozep+1, jobb);

    osszefesul(t, bal, kozep, jobb);
}


int main()
{
    int n = 7;
    int t[100] = {1, 5, 3, 0, 2, 7, 3};

    mergesort(t, 0, n-1);

    return 0;
}

Ha ugyanezt csökkenő sorrendbe rendezésre akarjuk felhasználni, akkor csak az öszefésülésben használt feltétel kell változzon (14. sor):

    if (t[ib] >= t[ij]) ...

Feladat

Hasonlítsuk össze az insertion sort, selection sort, exchange sort, bubble sort és mergesort futásidejét a sort-bemenetek.zip állományban található tesztesetekre (győződjünk meg arról is, hogy az algoritmusok kimenete helyes).

A pontosabb mérés érdekében lehet többször futtatni és átlagolni az időket.

Algoritmusinput-1k.txtinput-10k.txtinput-50k.txtinput-100k.txt
Insertion sort19ms – 20ms200ms – 300ms4s – 6.3s25s
Selection sort10ms – 22ms120ms – 260ms2.4s – 5.4s9.5s – 21s
Exchange sort10ms – 73ms250ms – 281ms4s – 10s13s – 34s
Bubble sort16ms – 30ms560ms – 800ms12s – 20s50s – 83s
Merge sort10ms – 31ms31ms – 50ms170ms – 200ms300ms – 440ms