Sortering
This presentation is the property of its rightful owner.
Sponsored Links
1 / 66

Sortering PowerPoint PPT Presentation


  • 94 Views
  • Uploaded on
  • Presentation posted in: General

Sortering. Plan. Elementære metoder til sortering -sortering ved indsættelse -Shellsort Sorteringsmetoder baseret på rekursion quicksort flettesortering Randomisering.

Download Presentation

Sortering

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript


Sortering

Sortering


Sortering

Plan

  • Elementære metoder til sortering

    • -sortering ved indsættelse

    • -Shellsort

  • Sorteringsmetoder baseret på rekursion

    • quicksort

    • flettesortering

  • Randomisering


Sortering

Uformel definition: Ved sortering forstås en proces, hvorved elementerne i en datamængde ordnes i rangfølge.

Hvorfor sortere?

(1) Det er lettere at søge i en en sorteret datamængde end i en usorteret datamængde, såvel for maskiner som for mennesker.Tænk f.eks. på opslag i en telefonbog.

(2) Mange problemer kan løses mere effektivt, hvis inddata er sorteret. Eksempel: Hvis to filer er sorteret i samme orden, er det muligt i blot ét gennemløb at finde alle de poster, der findes i begge filer.


Bestemmelse af f llesm ngden for to usorterede arrays

0

i

M

a:

0

N

0

k

j

c:

b:

Bestemmelse af fællesmængden for to usorterede arrays

k = 0;

for (i = 0; i < M; i++)

for (j = 0; j < N; j++)

if (a[i] == b[j])

c[k++] = a[i];

Kompleksitet: O(M * N)


Bestemmelse af f llesm ngden for to sorterede arrays

0

k

j

c:

<

b:

Bestemmelse af fællesmængden for to sorterede arrays

0

i

M

a:

<

0

N

<

i = j = k = 0;

while (i < M && j < N)

if (a[i] < b[j]) i++;

else if (a[i] > b[j]) j++;

else { c[k++] = a[i]; i++; j++; }

Kompleksitet: O(M + N)


Permutationer

Permutationer

  • En permutation af en mængde af objekterer en ordning af objekterne.

  • For eksempel er p = (2 3 1) en permutation af {1, 2, 3}. p(1) = 2 p(2) = 3p(3) = 1

  • Der er 6 permutationer af {1, 2, 3}, nemlig (1 2 3)(1 3 2)(2 1 3)(2 3 1)(3 1 2) (3 2 1)

  • Antallet af permutationer af n objekter er n!.


Sortering

En sortering af en fil af n poster er en permutation, p, af mængden {1, 2, ..., n}, som ordner nøglerne i stigende rækkefølge:Kp(1) ≤ K p(2) ≤ ... ≤ Kp(N).

  • Lad der være givet N emner R1, R2, ..., RN, der skal sorteres. Vi kalder dem poster, og hele samlingen kaldes for en fil. Hver post Ri indeholder en nøgle, Ki, til styring af sorteringen. Herudover kan en post indeholde anden information.

Lad der desuden være defineret en ordningsrelation ‘<’ på mængden af nøgleværdier, som er total, dvs. for vilkårlige tre nøgleværdier a, b og c opfylder følgende to betingelser:

(1) Præcis et af følgende 3 udsagn er sandt: a < b, a = b eller b < a (3-delelighed)

(2) Hvis a < b og b < c, så a < c(transitivitet)


Terminologi

Terminologi

  • En sortering af en fil i det indre lager (f.eks. et array), kaldes for intern sortering.

  • En sortering af en fil på et eksternt lagermedium (f.eks. en disk) kaldes for ekstern sortering.


Element re algoritmer

Elementære algoritmer

  • Sortering ved indsættelseShellsort

  • Hvorfor studere elementære algoritmer?

  • (1) De er lette at kode

  • (2) De er (tilstrækkeligt) hurtige for små filer

  • (3) I specielle situationer er de hurtigst

  • (4) Udgør illustrative eksempler på algoritmedesign og -analyse


Sortering ved inds ttelse

Sortering ved indsættelse

  • Problem: Givet et array a med elementernea[0], a[1], ..., a[n-1]. Sorter elementerne i stigende orden.

Løsning (ved induktion):

Basistilfælde: Vi ved, hvordan 1 element sorteres.

Induktionshypotese: Vi ved, hvordan n-1 elementer sorteres.

Vi kan opnå en sortering af n elementer ved (1) at sortere de første n-1 elementer, (2) indsætte det n´te element korrekt blandt disse.


Sortering

  • A S O R T I N G E X A M P L E

  • A S O R T I N G E X A M P L E

  • A O S R T I N G E X A M P L E

  • A O R S T I N G E X A M P L E

  • A O R S T I N G E X A M P L E

  • A I O R S T N G E X A M P L E

  • A I N O R S T G E X A M P L E

  • A G I N O R S T E X A M P L E

  • A E G I N O R S T X A M P L E

  • A E G I N O R S T X A M P L E

  • A A E G I N O R S T X M P L E

  • A A E G I M N O R S T X P L E

  • A A E G I M N O P R S T X L E

  • A A E G I L M N O P R S T X E

  • A A E E G I L M N O P R S T X


Sortering

  • void insertionSort(Comparable[] a, int i) {

  • if (i > 0) {

  • insertionSort(a, i - 1);

  • for (int j = i;

  • j > 0 && a[j].compareTo(a[j - 1]) < 0; j--)

  • swap(a, j, j - 1);

  • }

  • }

  • void swap(Object[] a, int i, int j) {

  • Object tmp = a[i]; a[i] = a[j]; a[j] = tmp;

  • }

Sortering ved indsættelse (rekursiv udgave)


Sortering

Sortering ved indsættelse(iterativ udgave)

  • void insertionSort(Comparable[] a) {

  • for (int i = 1; i < a.length; i++)

  • for (int j = i;

  • j > 0 && a[j].compareTo(a[j - 1]) < 0; j--)

  • swap(a, j, j - 1);

  • }


Sortering

  • void insertionSort(Comparable[] a, int i) {

  • for (int i = 1; i < a.length; i++){

  • Comparable tmp = a[i];

  • int j = i;

  • for ( ; j > 0 && tmp.compareTo(a[j - 1]) < 0; j--)

  • a[j] = a[j - 1];

  • a[j] = tmp;

  • }

  • }

0

i

a:

tmp:

j-1

j

Sortering ved indsættelse (iterativ udgave med flytninger)


Animering af sortering ved inds ttelse

Animering af sortering ved indsættelse


Analyse af sortering ved inds ttelse

Tidsforbruget er lineært for “næsten sorterede” filer.

Analyse af sortering ved indsættelse

  • Antal sammenligninger:

  • Bedste tilfælde: n-1

  • Værste tilfælde: 1 + 2 + ... + (n-1) = n(n-1)/2 = O(n2)

  • Gennemsnitlige tilfælde: n(n-1)/4 = O(n2)

  • Antal flytninger:

  • Bedste tilfælde: 0

  • Værste tilfælde: 1 + 2 + ... + (n-1) = n(n-1)/2 = O(n2)

  • Gennemsnitlige tilfælde: n(n-1)/8 = O(n2)


Shellsort d l shell 1959

Shellsort(D. L. Shell, 1959)

  • Ide: Sortering ved indsættelse er meget effektiv, når filen er “næsten sorteret”. Men for “meget usorterede” filer er den langsom, da den kun tillader ombytning af naboelementer.

  • Spørgsmål: Kan vi sørge for at ombytte elementer, der ligger langt fra hinanden i starten, for så derefter at foretage en sædvanlig sortering ved indsættelse?

  • Svar: Ja, vi kan sortere de delfiler, der fås ved at tage hvert h´te element i den oprindelige fil, hvor h > 1.


4 sortering

4-sortering

  • 1. Opdel filen i 4 delfiler: hvert 4. element startende i det første, hvert 4. element startende i det andet, hvert 4. element startende i det tredje, hvert 4. element startende i det fjerde,

  • 2. Sorter hver af disse.

  • Filen siges da at være 4-sorteret.

  • På tilsvarende måde kan vi definere en h-sortering.

  • Bemærkning: En fil, der er 1-sorteret, er sorteret.


4 sortering ved inds ttelse

4-sortering ved indsættelse

Benyt sortering ved indsættelse med “skridtlængde” 4.

A S O R T I N G E X A M P L E

A S O R T I N G E X A M P L E

A I O R T S N G E X A M P L E

A I N R T S O G E X A M P L E

A I N G T S O R E X A M P L E

A I N G E S O R T X A M P L E

A I N G E S O R T X A M P L E

A I A G E S N R T X O M P L E

A I A G E S N M T X O R P L E

A I A G E S N M P X O R T L E

A I A G E L N M P S O R T X E

A I A G E L E M P S N R T X O


H sortering

h-sortering

  • void h_sort(Comparable[] a, int h) {

  • for (int i = h; i < a.length; i++) {

  • Comparable tmp = a[i];

  • int j = i;

  • for ( ; j >=h && tmp.compareTo(a[j - h]) < 0; j -= h)

  • a[j] = a[j - h];

  • a[j] = tmp;

  • }

  • }

  • I forhold til insertionSort er 1 blot erstattet med h.


Shellsort

Shellsort

Shellsort er h-sortering for en aftagende sekvens af h-værdier, afsluttende med h = 1.

  • void shellsort(Comparable[] a) {

  • int h;

  • for (h = 1; h < a.lenghth / 9; h = 3 * h + 1)

  • ;

  • for ( ; h >= 1; h /= 3)

  • h_sort(a, h);

  • }

I dette tilfælde sekvensen ..., 1093, 364, 121, 40, 13, 4, 1.

Det er en god ide, at vælge sekvenser, hvor successive værdier er indbyrdes primiske (deres største fælles divisor er 1).


Sortering

Shellsort

Lærebogens algoritme:

  • void shellsort(Comparable[] a) {

  • for (int h = a.length / 2;

  • h > 0; h = h == 2 ? 1 : h / 2.2)

  • h_sort(a, h);

  • }


Sortering

Animering af Shellsort


Analyse af shellsort

Analyse af Shellsort

Antal sammenligninger:

Bedste tilfælde: (n-1) + (n-4) + (n-13) + ... ≤ n log3n

Værste tilfælde: højst n1.5 (for sekvensen 1, 4, 13, ...)

Gennemsnitlige tilfælde: kendes ikke. To forslag er O(n1.25) og O(n(log n)2).

Antal flytninger:

Bedste tilfælde: 0

Værste tilfælde: højst n1.5 (for sekvensen 1, 4, 13, ...)

Gennemsnitlige tilfælde: kendes ikke. To forslag er O(n1.25) og O(n(log n)2).


Sortering

C, tid i sekunder:

metode N = 32000 64000 128000 256000 512000 1024000

insertionSort 3.02 12.70 32.22 - - -

shellsort 0.03 0.05 0.13 0.35 0.80 1.97

Måling af køretider(PowerBook G3, 400 MHz, Metrowerks)

  • Java (JIT), tid i sekunder:

  • metode N = 32000 64000 128000 256000 512000 1024000

  • insertionSort 6.59 27.24 114.14 - - -

  • shellsort 0.04 0.08 0.18 0.41 1.03 2.37


Har du brug for en sorteringsmetode

Har du brug for en sorteringsmetode?

  • Så brug Shellsort.

  • lidt kode

  • bedste metode til små og middelstore filer

  • stadig OK for meget store filer


Quicksort c a r hoare 1962

venstre del

højre del

Quicksort(C. A. R. Hoare, 1962)

  • Quicksort er i praksis den hurtigste algoritme til intern sortering.

  • Ide: For at sortere et array, så del det i en venstre og en højre del, således at alle elementer i den venstre del er mindre end eller lig med alle elementer i den højre del.

Sorter derefter den venstre del og den højre del rekursivt.


Deling partition

≤ v

a[i]

a[j]

≥ v

Deling (partition)

  • Delingen af et array a kan foretages således:

  • (1)Vælg en delingsværdi, v, blandt værdierne i a.

  • (2)Gennemløb a fra venstre mod højre, indtil der findes et element a[i]≥ v.

  • (3)Gennemløb a fra højre mod venstre, indtil der findes et element a[j]≤ v.

  • (4) Ombyt a[i]og a[j].

  • (5)Fortsæt med at gennemløbe og ombytte, indtil de to gennemløb “krydser” hinanden.


Sortering

≤ v

X

Y

≥ v

j

i

a[i] ≥ v

a[j] ≤ v

≤ v

≥ v

≤ v

Y

X

≥ v

j

i

v: delingsværdien

i: venstre-mod-højre-pegeren

j: højre-mod-venstre-pegeren


Implementering

Implementering

  • Deling af a[low:high]med hensyn til v:

  • i = low; j = high;

  • while (i <= j) {

  • while (a[i].compareTo(v) < 0) i++;

  • while (a[j].compareTo(v) > 0) j--;

  • if (i <= j)

  • { swap(a, i, j); i++; j--; }

  • }

Resultat: a[low:i] ≤ a[j:high]og i > j.

Kan bevises ved at påvise gyldigheden af løkkeinvarianten

{ a[low:i-1] ≤ v ≤ a[j+1:high]}for den yderste løkke.


Quicksort

Quicksort

Delingsværdien v (også kaldet pivot-værdien) kan være værdien af et vilkårligt element blandt a[low:high], f.eks. a[(low+high)/2].

  • void quicksort(Comparable[] a, int low, int high) {

  • if (low < high) {

  • Comparable v = a[(low + high)/2];

  • int i = low, j = high;

  • while (true) {

  • while (a[i].compareTo(v) < 0) i++;

  • while (a[j].compareTo(v) > 0) j--;

  • if (i >= j) break;

  • swap(a, i, j); i++; j--;

  • }

  • quicksort(a, low, j);

  • quicksort(a, i, high);

  • }

  • }


Sortering

  • int partition(Comparable[] a, int low, int high) {

  • Comparable v = a[high];

  • int i = low - 1, j = high;

  • while (true) {

  • while (a[++i].compareTo(v) < 0) ;

  • while (v.compareTo(a[--j]) < 0)

  • if (j == low) break;

  • if (i >= j) break;

  • swap(a, i, j);

  • }

  • swap(a, i, high);

  • return i;

  • }

Alternativ implementering af delingen

Vi kan alternativt anvende a[high]som delingsværdi.

a[low:high-1] deles, hvorefter a[high]ombyttes med a[i].


Sortering

Metoden quicksort

  • int quicksort(Comparable[] a, int low, int high) {

  • if (low < high) {

  • int i = partition(a, low, high);

  • quicksort(a, low, i - 1);

  • quicksort(a, i + 1, high);

  • }

  • }


Animering af quicksort

Animering af quicksort


Antal sammenligninger

Antal sammenligninger

Lad C(N) betegne antallet af sammenligninger ved kald af quicksort med N elementer.

Ved delingen foretages cirka N sammenligninger. Herefter sorteres den venstre del og den højre del hver for sig.

I gennemsnit består hver del af cirka N/2 elementer, og får vi derfor rekursionsrelationen:

C(N) = N + 2*C(N/2) for N ≥ 2, og C(1) = 0.

som har løsningenC(N) = N log2N.


Sortering

Antal sammenligninger i gennemsnit

  • Mere præcise beregninger giver

  • Quicksort bruger i gennemsnit cirka 2N lnN sammenligninger.

  • hvor ln betegner den naturlige logaritme.

2N ln N ≈ 1.38 N log2N

Det gennemsnitlige antal sammenligninger er altså kun 38% højere end antallet af sammenligninger i det bedste tilfælde.


Antal sammenligninger i v rste tilf lde

Antal sammenligninger i værste tilfælde

  • Det værste tilfælde optræder, når delingen for hvert N resulterer i en del med 1 element og en del med N-1 elementer.

  • Vi få daC(N) = N + C(N-1), for N ≥ 2, og C(1) = 0.

  • som har løsningen C(N) = N(N+1)/2.

  • Det værste tilfælde optræder, når filen er sorteret (eventuelt i omvendt orden).

  • Valg af tilfældigt delingselement (eller “median af 3”) reducerer chancen for, at det værste tilfælde optræder.


Quicksort med median af 3

Quicksort med median af 3

  • void quicksort(Comparable[] a, int low, int high) {

  • if (low < high) {

  • if (a[high].compareTo(a[low]) < 0)

  • swap(a, low, high);

  • int mid = (low + high)/2;

  • if (mid == low) return;

  • if (a[mid].compareTo(a[low]) < 0)

  • swap(a, low, mid);

  • if (a[high].compareTo(a[mid]) < 0)

  • swap(a, mid, high);

  • swap(a, mid, high - 1);

  • int i = partition(a, low + 1, high - 1);

  • quicksort(a, low, i - 1);

  • quicksort(a, i + 1, high);

  • }

  • }


Benyt en simpel metode for sm delfiler

Benyt en simpel metode for små delfiler

if (high - low < CUTOFF) insertionSort(a, low, high);

elseindsættes i stedet for

if (low < high) i starten af quicksort, hvor CUTOFF f.eks. er 10.


Empirisk unders gelse af quicksort powerbook g3 400 mhz metrowerks

Empirisk undersøgelse af quicksort(PowerBook G3, 400 MHz, Metrowerks)

  • Tid i sekunder:

  • Metode N = 32000 64000128000 256000 512000 1024000

  • quicksort 0.03 0.05 0.09 0.17 0.36 0.76

  • shellsort 0.04 0.08 0.18 0.41 1.03 2.37

  • insertionSort 6.59 27.24 114.14 ≈ 8 min ≈ 32 min ≈ 2 timer

  • quicksort: median af 3 og insertionSort for små delfiler (CUTOFF = 10).


Sortering

Udvælgelse

Problem: Find det k’te mindste element blandt en mængde af N elementer.

Eksempel: Det 3. mindste tal blandt {3, 6, 5, 2, 8, 4} er 4.

Løsningsmulighed 1: Sorter elementerne i stigende orden. Det k´te element i den sorterede rækkefølge er løsning på problemet.

Kompleksitet: afhænger af sorteringsmetode - med quicksort: O(N log N).


Sortering

Løsningsmulighed 2: Hvis k er lille, så anvend sortering ved udvælgelse, men stop, når de første k elementer er på plads.

Kompleksitet: O(k N),

idet N + (N-1) + … + (N - k + 1)≈ k N

Løsningsmulighed 3: Anvend en “hob” (en datastruktur til repræsentation af prioritetskøer - mere herom senere).

Kompleksitet: O(k log N)

Kan vi gøre det bedre?


Sortering

void quickSelect(Comparable[] a, int low, int high, int k) {

if (low < high) {

int i = partition(a, low, high);

if (i > k) quickSelect(a, low, i - 1, k);

if (i < k) quickSelect(a, i + 1, high, k);

}

}

void quickSelect(Comparable a[], int low, int high, int k) {

while (low < high) {

int i = partition(a, low, high);

if (i >= k) high = i - 1;

if (i <= k) low = i + 1;

}

}

Udvælgelse ved brug af partition

Metoden omordner a, så a[low:k-1] ≤ a[k] ≤ a[k+1:high].

Da der kun benyttes halerekursion, kan rekursionen let elimineres:


Sortering

Kompleksitet af quickSelect

O(N) i gennemsnit,

idet N + N/2 + N/4 + … ≤ 2N.

Det er muligt (men ikke helt let) at sørge for garanteret lineær køretid.


Sortering ved del og hersk

Sortering ved del-og-hersk

  • void sort(Comparable[] a, int low, int high) {

  • if (low < high) {

  • //Del: Del a[low:high]i to delfiler, a[low:i]og a[j:high],hvor i ≥ j.

  • //Hersk:sort(a, low, i);

  • sort(a, j, high);

  • //Kombiner:Sammensæt de to sorterede delfiler, så de udgør en sortering af a[low:high].

  • }

  • }

Quicksort:

Del:Vælg en værdi, v. Ombyt elementerne i a[low:high],

således ata[low:i] ≤ v ≤ a[j:high], ogi≥j.

Kombiner:Intet.

Mergesort (sortering ved fletning):

Del:i = (low+high)/2; j = i+1;

Kombiner:Flet de to sorterede delfiler, og placer resultatet i a[low:high].


Fletning

0

i

M

a:

0

j

N

b:

0

k

M+N

c:

Fletning

for (i = j = k = 0; k < M + N; k++)

if (i >= M) c[k] = b[j++]; else

if (j >= N) c[k] = a[i++]; else

c[k] = a[i].compareTo(b[j]) < 0 ? a[i++] : b[j++];


Mergesort

mergeSort

void mergeSort(Comparable[] a, int low, int high) {

if (low < high) {

int mid = (low + high)/2;

mergesort(a, low, mid);

mergesort(a, mid + 1, high);

merge(a, low, mid, high);

}

}


Simpel fletning

low

mid + 1

mid

high

Fletning:

a:

b:

low

high

Kopiering:

a:

low

high

void merge(Comparable[] a, int low, int mid, int high) {

int i = low, j = mid + 1;

for (int k = low; k <= high; k++)

if (i > mid) b[k] = a[j++]; else

if (j > high) b[k] = a[i++]; else

b[k] = a[i].compareTo(a[j]) < 0 ? a[i++] : a[j++];

for (int k = low; k <= high; k++) a[k] = b[k];

}

Simpel fletning

  • Fletning af a[low:mid]med a[mid+1:high]over i a[low:high]:


Sortering

  • A S O R T I N G E X A M P L E

  • A S O R T I N G E X A M P L E

  • A S O R T I N G E X A M P L E

  • A O R S T I N G E X A M P L E

  • A O R S I T N G E X A M P L E

  • A O R S I T G N E X A M P L E

  • A O R S G I N T E X A M P L E

  • A G I N O R S T E X A M P L E

  • A G I N O R S T E X A M P L E

  • A G I N O R S T E X A M P L E

  • A G I N O R S T A E M X P L E

  • A G I N O R S T A E M L L P E

  • A G I N O R S T A E M L E L P

  • A G I N O R S T A E E L M P X

  • A A E E G I L M N O P R S T X


Sortering

Animering af mergesort


Kaldtr er

16

8

8

4

4

4

4

2

2

2

2

2

2

2

2

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

21

10

11

6

5

5

5

2

3

3

3

2

2

3

3

2

1

1

1

2

1

1

2

1

1

1

1

2

1

2

1

1

1

1

1

1

1

1

1

1

1

Kaldtræer

8


Vurdering af sortering ved fletning

Vurdering af sortering ved fletning

  • Fordele:

  • er ufølsom over for startorden i inddata

  • kræver cirka N log2N sammenligninger for at sortere enhver fil C(N) = 2C(N/2) + N, C(1) = 0

  • er stabil

  • kan benyttes til at sortere lister

  • er velegnet til ekstern sortering

  • Ulemper:

  • kræver (i praksis) ekstra plads proportional med N


Stabile metoder

Stabile metoder

  • En sorteringsmetode siges at være stabil, hvis den bevarer den relative orden af poster med samme nøgle i filen.

At en metode er stabil kan være hensigtsmæssigt ved sortering på flere nøgler.

Hans 9Arne 9Jørgen03

Karen11Erling 11Mette 7

Jørgen03Hans 9Niels 7

Niels 7Jørgen03Arne 9

Mette 7Karen11Hans 9

Arne 9Mette 7Erling 11

Erling 11Niels 7Karen11

Sorter på første nøgle. Derefter på anden.

For samme anden nøgle bevares rækkefølgen for ens nøgler fra første sortering.


Empirisk unders gelse af mergesort

Empirisk undersøgelse af mergesort

  • Tid i sekunder:

  • Metode N = 32000 64000 128000 256000 512000 102400

  • mergesort 0.06 0.12 0.25 0.54 1.15 2.67

  • quicksort 0.03 0.05 0.09 0.17 0.36 0.76

  • shellsort 0.04 0.08 0.18 0.41 1.03 2.37


Kompleksiteten af sortering

Kompleksiteten af sortering

  • Enhver sorteringsalgoritme, der er baseret på nøglesammenligninger, kræver i værste tilfælde mindst cNlog2N sammenligninger for at sortere N elementer, hvor c er en konstant > 0.

Uformelt bevis:

Sortering er ækvivalent med bestemmelse af en permutation. Sortering kan derfor modelleres ved et beslutningstræ, hvor hver interne knude svarer til en sammenligning af to nøgler, mens hver eksterne knude svarer til en af de N! mulige permutationer. Højden i dette træ er mindst log2(N!).

Af Stirlings formel

fås

log2(N!) ≈ Nlog2N - 1.44N.


Kriterier for valg af sorteringsmetode

Kriterier for valg af sorteringsmetode

  • • Størrelse af nøgler (sammenligninger)

  • • Størrelse af poster (flytninger/ombytninger)

  • • Størrelse af fil (elementær/avanceret metode)

  • • Nøgletype (sammenligninger/radix)

  • • Mange ens nøgler?

  • • Er filen næsten sorteret?

  • • Kræves stabilitet?


Sortering

Randomisering


Sortering

Behovet for tilfældige tal

  • Mange anvendelser: • Programafprøvning (generering af tilfældige inddata)

    • Sortering (f.eks. bestemmelse af pivot-elementet i quicksort)

    • Simulering (f.eks. generering af kunders ankomst til en bank)

    • Spil (f.eks. valg af åbningstræk)

    • Randomiserede algoritmer (f.eks. test af om et tal er et primtal)


Sortering

Generering af tilfældige tal

Ægte tilfældighed på en computer er umuligt at opnå.

Vi må nøjes med pseudotilfældige tal, d.v.s. tal der forekommer at være tilfældige.

Sekvenser af genererede tal skal kunne modstå en lang række statistiske tests.

For det meste benyttes en lineær kongruens generator (Lehmer, 1951):Xi+1 = AXi + B (mod M) hvor Xi+1, Xi, A, B og M er heltal.

X0 kaldes for generatorens sæd.

A, B og M skal vælges således, at længden af en sekvens (perioden) bliver så lang som muligt. M bør være et stort primtal.


Sortering

Generering af tilfældige tal i Java

Java tilbyder klassen java.util.Random.

public class Random {

public Random();

public Random(long seed);

public int nextInt();

public long nextLong();

public float nextFloat();

public double nextDouble();

public double nextBytes(byte[] bytes);

public double nextGaussian();

public void setSeed(long seed);

protected int next(int bits);

}


Sortering

Til generering af tilfældige heltal benyttes Lehmers metode

public class Random {

private long seed;

private final static long multiplier = 0x5DEECE66DL;// = 25214903917

private final static long addend = 0xBL;// = 11

private final static long mask = (1L << 48) - 1;

public Random() { this(System.currentTimeMillis()); }

public Random(long seed) {

this.seed = (seed ^ multiplier) & mask;

}

public int nextInt() { return next(32); }

protected int next(int bits) {

long nextseed = (seed * multiplier + addend) & mask;

seed = nextseed;

return (int) (nextseed >>> (48 - bits));

}

}


Sortering

void permute(Object[] a) {

Random r = new Random();

for (int i = 1; i < a.length; i++)

swap(a, i, r.nextInt(i + 1));

}

Generering af tilfældige permutationer

(kan f.eks. benyttes til blanding af kort)


Sortering

Ugeseddel 623. oktober - 30. oktober

  • • Læs kapitel 10 og 11

  • Løs følgende opgaver

  • Opgave 20: 8.2 (1 point)

  • Opgave 21: 8.11 (2 point)

  • Opgave 22: Se de næste sider (4 - 6 point, ikke-obligatorisk)

  • Afleveringsfrist: tirsdag den 6. november


Sortering

fortsættes


Sortering

fortsættes


  • Login