Lataa esitys
Esittely latautuu. Ole hyvä ja odota
1
Prioriteettijonot ja kekolajittelu (heapsort)
Käytetään kekoa kahden ongelman ratkaisemiseen: Prioriteettijono: keko ylläpitää keko-ominaisuutta lisäys –ja poisto-operaatioiden kanssa, kukin operaatio vie O(log n) ajan Lajittelu: O(n log n) huonoimmassa tapauksessa, tarvitsee vain vähän ylimääräistä muistia
2
Keon toteutus Juuri = 1 i:n vasen lapsi = 2*i i:n oikea lapsi = 2*i+1
i:n vanhempi = i/2 x[1] x[2] X[3] x[4] x[5] X[6] Täydellinen binääripuu jonka jokaisen solmun avain on suurempi tai yhtäsuuri kun lasten avain Suurimman alkion etsiminen on nopeaa
3
Keko – siftup Uudet alkiot lisätään aina taulukon viimeiseen paikkaan,
minkä jälkeen puu päivitetään keoksi seuraavalla funktiolla: kekoylos(alkio a[], int k) { while(k > 1 && PIENEMPI(a[k / 2], a[k])) { VAIHDA(a[k], a[k / 2]); k = k / 2; } a[1] a[2] a[3] a[4] a[5] a[6]
4
Keko – siftdown a[1] a[2] a[3] a[4] a[5] a[6]
Poisto maksimikeon juurisolmusta suoritetaan siten, että viimeinen taulukon alkio vaihdetaan juurisolmuun ja päivitetään tietorakenne keoksi seuraavalla funktiolla: kekoalas(alkio a[], int k, int n) { int j; while(2 * k <= n) { j = 2 * k; if(j < n && PIENEMPI(a[j], a[j + 1])) j++; if(!PIENEMPI(a[k], a[j])) break; VAIHDA(a[k], a[j]); k = j; } a[1] a[2] a[3] a[4] a[5] a[6]
![Keko – siftdown a[1] a[2] a[3] a[4] a[5] a[6]](http://slideplayer.fi/slide/4914826/16/images/4/Keko+%E2%80%93+siftdown+a%5B1%5D+a%5B2%5D+a%5B3%5D+a%5B4%5D+a%5B5%5D+a%5B6%5D.jpg "Poisto maksimikeon juurisolmusta suoritetaan siten, että viimeinen. taulukon alkio vaihdetaan juurisolmuun ja päivitetään tietorakenne. keoksi seuraavalla funktiolla: kekoalas(alkio a[], int k, int n) { int j; while(2 * k <= n) { j = 2 * k; if(j < n && PIENEMPI(a[j], a[j + 1])) j++; if(!PIENEMPI(a[k], a[j])) break; VAIHDA(a[k], a[j]); k = j; } a[1] a[2] a[3] a[4] a[5] a[6]")
5
Prioriteettijonot esim. käyttöjärjestelmä voisi käyttää prioriteettijonoa esittämään joukkoa prosesseja, joista valitaan seuraavaksi suoritukseen otettava Diskreetissä simuloinnissa jonosta otetaan seuraava tapahtuma suoritettavaksi sekä mahdollisesti lisätään uusia tapahtumia jonoon Tietorakenne lisäys suurimman poisto Lajiteltu taulukko O(n) O(1) Keko O(log n) Lajittelematon taulukko
6
Kekoon perustuva prioriteettijono
static alkio *pq; /* taulukon osoite */ static int n; /* alkioiden lukumäärä */ void PQalusta(int maxn) { if((pq = (alkio *)malloc((maxn + 1) * sizeof(alkio))) == (alkio *)NULL) { perror("Taulukon muistinvaraus"); exit(1); } n = 0; } int PQtyhja() { return n == 0; } void PQlisaa(alkio v) { pq[++n] = v; kekoylos(pq, n); } alkio PQpoistamax() { VAIHDA(pq[1], pq[n]); kekoalas(pq, 1, n - 1); return pq[n--];
7
Kekolajittelu (heapsort)
Yhdistää pikalajittelun ja limityslajittelun edut O(n log n) huonoimmassa tapauksessa aivan kuten limityslajittelu Ei tarvitse lisätilaa aivan kuten pikalajittelu Parannettu versio valintalajittelusta: Taulukko muutetaan keoksi, jonka jälkeen isoin alkio poistetaan keosta ja laitetaan lajiteltuun järjestykseen Ei ole stabiili
8
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 3 5 7 2 4 8 11 1 3 5 7 2 4 8 11
9
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 3 5 11 2 4 8 7 1 3 5 11 2 4 8 7
10
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 3 8 11 2 4 5 7 1 3 8 11 2 4 5 7
11
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 11 8 7 2 4 5 3 1 11 8 7 2 4 5 3
12
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 11 7 8 3 2 4 5 1 11 7 8 3 2 4 5 1
13
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 7 8 3 2 4 5 1 7 8 3 2 4 5 11 11
14
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 8 7 5 3 2 4 1 8 7 5 3 2 4 1 11 11
15
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 7 5 3 2 4 1 7 5 3 2 4 8 11 8 11
16
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 7 3 5 1 2 4 7 3 5 1 2 4 8 11 8 11
17
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 4 3 5 1 2 4 3 5 1 2 7 8 11 7 8 11
18
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 5 3 4 1 2 5 3 4 1 2 7 8 11 7 8 11
19
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 2 3 4 1 2 3 4 1 5 7 8 11 5 7 8 11
20
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 4 3 2 1 4 3 2 1 5 7 8 11 5 7 8 11
21
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 3 2 1 3 2 4 5 7 8 11 4 5 7 8 11
22
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 3 1 2 3 1 2 4 5 7 8 11 4 5 7 8 11
23
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 2 1 2 1 3 4 5 7 8 11 3 4 5 7 8 11
24
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 2 1 2 1 3 4 5 7 8 11 3 4 5 7 8 11
25
Kekolajittelu (heapsort)
#define pq(A) a[l A] void kekolajittelu(alkio a[], int l, int r) { int k, n = r - l + 1; for(k = n / 2; k >= 1; k--) kekoalas(&pq(0), k, n); while(n > 1) { VAIHDA(pq(1), pq(n)); kekoalas(&pq(0), 1, --n); } 1 2 3 4 5 7 8 11 1 2 3 4 5 7 8 11
Samankaltaiset esitykset
