Sorterings algoritmer
This presentation is the property of its rightful owner.
Sponsored Links
1 / 81

Sorterings-Algoritmer PowerPoint PPT Presentation


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

Sorterings-Algoritmer. Algoritmer og Datastrukturer. Hva er sortering?. Input : en sekvens av N nummer Output : reorganisering input-sekvensen slik at: Vi søker algoritmer som gjør dette på en korrekt og effektiv måte. a 1 < a 2 < a 3 ... < a n-1 < a n. Hvorfor sortering?.

Download Presentation

Sorterings-Algoritmer

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


Sorterings algoritmer

Sorterings-Algoritmer

Algoritmer og Datastrukturer


Hva er sortering

Hva er sortering?

  • Input: en sekvens av N nummer

  • Output: reorganisering input-sekvensen slik at:

  • Vi søker algoritmer som gjør dette på en korrekt og effektiv måte.

a1 < a2 < a3 ... < an-1 < an


Hvorfor sortering

Hvorfor sortering?

  • Den største grunnen til at det er så viktig å kunne sortere et sett av elementer er at mange andre problem blir lettere å løse dersom elementene er sortert


Applikasjoner til sortering

Applikasjoner til sortering

  • Søking: Binær søking finner ut om et element er i en ordliste i O(lg n) tid

    • Å gjøre søking raskere er vel det viktigste bruksområdet til sortering

  • Nærmeste nabo: Gitt n nummer, finn paret som er nærmest hverandre

    • Med en gang nummerene er sortert, vil de nærmeste parene ligge ved siden av hverandre, slik at en O(n) linjær søking gjør jobben


Applikasjoner til sortering1

Applikasjoner til sortering

  • Element-Unikhet: Gitt et sett av n elementer, er de alle unike eller finnes der duplikater?

  • Medianer og seleksjon: Hva er det k-te største elementet i en liste?

  • Frekvens distrubisjoner: Gitt et sett av n elementer, hvilket element opptrer flest ganger i settet?


Hvordan kan vi sortere

Hvordan kan vi sortere?

  • Begrensinger til CPU

    • Kan bare gjøre en operasjon av gangen,

    • Siden en sammen-ligning er en operasjon, fører dette til at vi bare kan sammenligne to elementer samtidig når vi skal sortere

    • Men kan gjøre denne sammenligningen veldig raskt.


Repetisjon tr r

Repetisjon Trær

Sorterings-Algoritmer


Trestrukturer begreper

Trestrukturer: Begreper

Rot

R

B og C’s

Mor/Far-node

Grener

Noder

R’s

subtre

H

A

D

Terminalnode,

(endenode, løvnode)

B

C

F

G

A’s barn

(venstre)

A’s barn

(høyre)

Søskennoder


Egenskap bin rt s ke tre

5

3

7

2

5

8

Egenskap Binært-Søke-Tre

  • Et binært søketre er organisert som et binærtre, og har følgende egenskap

  • Operasjoner på et binært søketre, er derfor proposjonal med høyden på treet

O(lg n)


Haug sortering

Haug-Sortering

Sorterings-Algoritmer


Hva er en haug heap

Hva er en Haug (Heap)?

  • En haug er et komplett binærtre,

    • der alle nivå er fylt opp,

    • untatt eventuelt det siste,

    • som er fylt opp fra venstre til høyre

  • En haug brukes til blant annet

    • Prioritetskøer og til

    • Haugsortering (Heapsort)


Haug datastruktur

i/2

≥x

i

x

2i+1

2i

≤x

≤x

16

14

10

8

7

9

3

2

4

1

2

3

4

5

6

7

8

9

Haug : Datastruktur

  • Binærtre som er lagret i indekserbar variabel (array)

Generelle far/barn

relasjoner

1

16

2

3

14

10

4

5

6

7

8

7

9

3

8

9

2

4

rot

(Heap-egenskapen)


Max heapify o lg n

1

16

2

3

4

10

4

5

6

7

14

7

9

3

2

8

”Max-Heapify”: O(lg n)

  • Subrutine som vedlikeholder Heap-egenskapen,

  • ...dvs at barna til roten er mindre enn roten

Max-Heapify(A,i)

l = left(i)

r = right(i)

if l ≤ heap-size[A] and A[l] > A[i]

then largest = l

else largest = i

if r ≤ heap-size[A] and A[r] > A[largest]

then largest = r

if largest ≠ i

then exchange A[i]↔ A[largest]

Max-Heapify(A,largest)

i


Max heapify o lg n1

1

16

2

3

14

10

4

5

6

7

4

7

9

3

2

8

”Max-Heapify”: O(lg n)

  • Subrutine som vedlikeholder Heap-egenskapen,

  • ...dvs at barna til roten er mindre enn roten

Max-Heapify(A,i)

l = left(i)

r = right(i)

if l ≤ heap-size[A] and A[l] > A[i]

then largest = l

else largest = i

if r ≤ heap-size[A] and A[r] > A[largest]

then largest = r

if largest ≠ i

then exchange A[i]↔ A[largest]

Max-Heapify(A,largest)

1

i


Max heapify o lg n2

1

16

2

3

14

10

4

5

6

7

8

7

9

3

2

4

”Max-Heapify”: O(lg n)

  • Subrutine som vedlikeholder Heap-egenskapen,

  • ...dvs at barna til roten er mindre enn roten

Max-Heapify(A,i)

l = left(i)

r = right(i)

if l ≤ heap-size[A] and A[l] > A[i]

then largest = l

else largest = i

if r ≤ heap-size[A] and A[r] > A[largest]

then largest = r

if largest ≠ i

then exchange A[i] ↔ A[largest]

Max-Heapify(A,largest)

1

i


Build max heap o n

4

1

3

2

16

9

10

Build-Max-Heap : O(n)

  • Lager en heap fra en (ikke-ordnet) array,

  • i angir de indre nodene i heap’en

Eksempel

1

Build-Max-Heap(A)

heap-size[A] = length[a]

for i = [length[a]/2] downto 1

do heapify(A,i)

4

i

2

3

1

3

4

5

6

2

16

9

10


Build max heap o n1

4

1

3

2

16

9

10

Build-Max-Heap : O(n)

  • Lager en heap fra en (ikke-ordnet) array,

  • i angir de indre nodene i heap’en

Eksempel

1

Build-Max-Heap(A)

heap-size[A] = length[a]

for i = [length[a]/2] downto 1

do heapify(A,i)

4

2

3

i

1

3

4

6

7

2

16

9

10


Build max heap o n2

4

1

3

2

16

9

10

Build-Max-Heap : O(n)

  • Lager en heap fra en (ikke-ordnet) array,

  • i angir de indre nodene i heap’en

Eksempel

1

i

Build-Max-Heap(A)

heap-size[A] = length[a]

for i = [length[a]/2] downto 1

do heapify(A,i)

4

3

16

10

4

5

6

7

2

1

9

3


Build max heap o n3

4

1

3

2

16

9

10

Build-Max-Heap : O(n)

  • Lager en heap fra en (ikke-ordnet) array,

  • i angir de indre nodene i heap’en

Eksempel

1

Build-Max-Heap(A)

heap-size[A] = length[a]

for i = [length[a]/2] downto 1

do heapify(A,i)

16

3

4

10

4

5

6

7

2

1

9

3


Heapsort algoritmen

Heapsort-Algoritmen

  • Prosedyre for løsning

    • Lag heap av tallene (i arrayet)

    • For tall = [lengden til arrayet] ned til 2

      • Bytt første tall med array[tall]

      • Reetabler treet forarray[1...tall-1]

    • Ferdig sortert

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)


Heapsort o n lg n

Eksempel

14

8

7

2

4

1

Heapsort : O(n*lg n)

  • Kjøretid til heapsort

    • Heapsort tar O(n*lg n) tid

      • Siden kallet til Build-Max-Heap tar O(n) tid og

      • Hver av de n-1 kallene til Heapify tar O(lg n) tid

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

16

4

10

2

1

9


Heapsort o n lg n1

14

8

7

i

2

4

1

(1)

Eksempel

14

8

7

2

4

1

1

Max-Heapify(A,1)

8

7

2

4

14

(2)

Heapsort : O(n*lg n)

Usortert

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

8

4

1

Kapplinje

2

1

14

(2)


Heapsort o n lg n2

Eksempel

14

8

7

2

4

1

Heapsort : O(n*lg n)

Usortert

8

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

4

7

2

1

14

(2)

i

7

1

Max-Heapify(A,1)

4

1

4

7

Kapplinje

2

8

14

(3)

2

8

14

(3)


Heapsort o n lg n3

Eksempel

14

8

7

2

4

1

Heapsort : O(n*lg n)

Usortert

7

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

4

1

2

8

14

(3)

i

4

2

Max-Heapify(A,1)

2

1

4

1

Kapplinje

7

8

14

(4)

7

8

14

(4)


Heapsort o n lg n4

Eksempel

14

8

7

2

4

1

Heapsort : O(n*lg n)

Usortert

4

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

2

1

i

7

8

14

(4)

2

1

Max-Heapify(A,1)

1

4

2

4

Kapplinje

7

8

14

(5)

7

8

14

(5)


Heapsort o n lg n5

Sortert : A

Eksempel

14

1

8

2

7

4

7

2

4

8

1

14

Heapsort : O(n*lg n)

Usortert

2

Heapsort(A)

for i = [length[a]] downto 2

do exchange A[1]↔ A[i]

heap-size[A] = heap-size[A]-1

Max-Heapify(A,1)

i

1

4

7

8

14

(5)

1

1

Max-Heapify(A,1)

2

4

2

4

Kapplinje

7

8

14

(3)

7

8

14

(2)


Prioritetsk er bruker heap

Prioritetskøer bruker Heap

  • Haugsortering er en glimrende algoritme, men en god implementasjon av quicksort, slår den som regel i praksis

  • Men selve heap-data-strukturen har et stort bruksområde.

  • Den mest populære applikasjonen til en heap er å bruke den som en prioritetskø.


Prioritetsk er bruker heap1

Prioritetskøer bruker Heap

  • En prioritetskø er en datastruktur for å holde vedlike et sett av S elementer,

  • ...der hvert element har en assosiert verdi

  • En har to typer prioritetskøer:

    • En max-prioritets-kø

    • En min-prioritets-kø


Prioritets k operasjoner

Prioritets-kø : Operasjoner

  • Operasjoner til en max-prioritets-kø

    • Insert(S,x), kjøretid O(lg n)

      • setter et element x inn i settet S

      • Setter en node inn i heapen

    • Maximum(S), kjøretid O(1)

      • returnerer elementet S med den største verdien

    • Extract-Max(S), kjøretid O(lg n)

      • Returnerer elementet S med den største verdien

      • ...og fjerner elementet fra heapen


Prioritets k operasjoner1

Prioritets-kø : Operasjoner

  • Operasjoner til en max-prioritets-kø

    • Increase-Key(S,x,k), kjøretid O(lg n)

      • Øker verdien til et element x til en ny verdi k,

      • ...som en antar er minst like stor som x

  • Operasjoner til en min-prioritets-kø

    • Insert(S,x), Minimum(S), Extract-Min(S), Decrease-Key(S,x,k)


Merge sortering

Merge-Sortering

Sorterings-Algoritmer


Hva er merge sort

Hva er Merge-Sort?

  • Merge-sortering (flette-sortering) er basert på ”splitt-og-hersk”-paradimet

    • Splitt: del arrayet med n elementer i 2 deler med n/2 elementer

    • Hersk: sorter de to halvdelene rekursivt ved kall til ”mergesort”

    • Kombiner: flett sammen de to halvdelene for å produsere det sorterte arrayet


Merge sort algoritmen

5

2

4

6

1

3

2

6

5

2

4

6

1

3

2

6

5

2

4

6

1

3

2

6

2

5

4

6

1

3

2

6

2

4

5

6

1

2

3

6

1

2

2

3

4

5

6

6

Merge-Sort : Algoritmen

Merge-Sort(A,p,r)

if p <r

then q = [(p+r)/2]

Merge-Sort(A,p,q)

Merge-Sort(A,q+1,r)

Merge(A,p,q,r)

splitt

5

2

4

6

1

3

2

6

Dette gir oss rekurrensen:

hersk

kombiner

T(n) = 2T(n/2) + c*n)

O(n*lg n)


Merging

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

minste

minste

A

hjelpearray


Merging1

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

hjelpearray


Merging2

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

hjelpearray


Merging3

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

I

hjelpearray


Merging4

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

I

L

hjelpearray


Merging5

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

I

L

M

hjelpearray


Merging6

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

I

L

M

O

hjelpe array


Merging7

minste

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

A

G

H

I

L

M

O

R

hjelpearray


Merging8

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

Første halvdel ferdig

A

G

H

I

L

M

O

R

S

hjelpearray


Merging9

minste

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

Første halvdel ferdig

A

G

H

I

L

M

O

R

S

T

hjelpearray


Merging10

A

G

L

O

R

H

I

M

S

T

Merging

  • Hold oversikt over det minste elementet i hver sortert halvdel.

  • Sett inn det minste av de to elementene i det sorterte arrayet

  • Gjenta dette til du er ferdig.

Første halvdel ferdig

Andre halvdel ferdig

A

G

H

I

L

M

O

R

S

T

hjelpearray


Quicksort

QuickSort

Sorterings-Algoritmer


Hva er quicksort

Hva er Quicksort?

  • Quicksort er basert på ”splitt-og-hersk”-paradimet, slik som merge-sort.

    • ...men inneholder i tillegg en viktigsubrutinesom heter partition

  • Kjøretiden til quicksort er

    • O(n2) i verste tilfelle, men

    • O(n*lg n) i gjennomsnitt


Id bak partition

Idê bak partition

  • Metode som deler arrayet slik at

    • Elementet a[i] en deler arrayet i er på rett plass

    • Det ikke er noen større elementer til ventre for i

    • Det ikke er noen mindre elementer til høyre for i

  • Deretter sorterer quicksort den venstre og høyre delen rekursivt


Partitioning algoritme

Q

U

I

C

K

S

O

R

T

I

S

C

O

O

L

partition element

ikke partitionert

venstre

partitioned

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”


Partitioning algoritme1

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

Q

U

I

C

K

S

O

R

T

I

S

C

O

O

L


Partitioning algoritme2

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

Q

U

I

C

K

S

O

R

T

I

S

C

O

O

L


Partitioning algoritme3

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

Q

U

I

C

K

S

O

R

T

I

S

C

O

O

L


Partitioning algoritme4

Bytt meg

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

Q

U

I

C

K

S

O

R

T

I

S

C

O

O

L


Partitioning algoritme5

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

U

I

C

K

S

O

R

T

I

S

Q

O

O

L


Partitioning algoritme6

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

U

I

C

K

S

O

R

T

I

S

Q

O

O

L


Partitioning algoritme7

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

U

I

C

K

S

O

R

T

I

S

Q

O

O

L


Partitioning algoritme8

Bytt meg

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

U

I

C

K

S

O

R

T

I

S

Q

O

O

L


Partitioning algoritme9

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme10

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme11

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme12

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme13

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme14

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme15

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme16

Bytt meg

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme17

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

Bytt med partition element

Pekere krysser

C

I

I

C

K

S

O

R

T

U

S

Q

O

O

L


Partitioning algoritme18

partition element

ikke partitionert

venstre

partitionert

høyre

PartitioningAlgoritme

- Velg partition element til å være det lengst til høyre

- Scan fra venstre for et større element

- Scan fra høyre for et mindre element

- Bytt elementer

- Gjenta til pekerne krysser

- Bitt partition element med ”kryss-elementet”

partition er ferdig

C

I

I

C

K

L

O

R

T

U

S

Q

O

O

S


Quicksort algoritmen

Quicksort : Algoritmen

Quicksort(A,p,r)

if p <r

then q = Partition(A,p,r)

Quiksort(A,p,q-1)

Quicksort(A,q+1,r)

Partition(A,p,r)

x = A[r]

i = p-1

for j = p to r-1

do if A[j] ≤ x

then i = i+1

exchange A[i]↔ A[j]

exchange A[i] ↔ A[j]

return i+1


Kj re eksempel

Vi få da et

sortert array

2

1

1

4

5

9

3

6

2

1

1

4

5

9

3

6

1

1

2

3

4

5

6

9

1

1

2

3

5

9

4

6

1

1

5

9

4

6

4

9

5

6

9

5

6

6

5

9

6

5

Kjøre-Eksempel

Usortert array

3

1

4

1

5

9

2

6

Kjøre-eksempel

2

3

1

1

4

Kombinerer

sett sammen

de sorterte

subarrayene

9

5

6


Worst case partition

1

2

2

2

n

n

n

• • •

• • •

• • •

”Worst case Partition”

  • n

  • - n

  • n

  • - 3

  • 2

  • O(n2)

1

2

Dårlig pga svært skjeve

splittinger; en region med

bare ett element og den

andre regionen (subarray)

inneholder resten av

elementene.

n-1

n

n-1

n

O(n2) hvis input-array

allereder er sortert

T(n) = T(n-1) + O(n)


Best case partiton

”Best-Case Partiton”

1

n/2

n

• • •

• • •

Alternerer

mellom gode og

dårlige delinger

• • •

• • •

• • •

• • •

• • •

• • •

• • •

• • •

Gjennomsnittlig dybde

I binærtre = 1,4 lg n

Konstanten er mindre enn

For noen annen sorteringsrutine

O(n*lg n)

O(n • 1,4 lg n)


Average case partition

”Average Case Partition”

1

n/2

n

• • •

• • •

• • •

• • •

• • •

• • •

• • •

• • •

• • •

• • •

O(n*lg n)

T(n) = 2T(n/2) + O(n)


Hva er quicksort1

Hva er Quicksort?

  • Den er i praktiske tilfeller som oftes den beste sorterings-algoritmen

    • Den er veldig effektiv i gjennomsnitt. Den antatte kjøretiden er O(n*ln n)

      • ...der konstantfaktoren er veldig liten

    • Den sorterer dessuten ”in place”,

      • ...der ingen spesielle input lokker frem worst-case-oppførsel

    • Den fungerer også godt i omgivelser med virtuelle minne


Tellesortering

Tellesortering

Sorterings-Algoritmer


Telle sortering counting sort

Telle-Sortering (Counting-Sort)

  • Sorteringsrutinen antar at hvert av de n-elementene, som skal sorteres, er heltall mellom 1 og k, der k er et heltall

  • Ide: For hvert element x skal antall elementer mindre enn x finnes.

    • Informasjonen brukes til å plassere x direkte i det sorterte arrayet


Plassforbruk tellesortering

Plassforbruk Tellesortering

  • Sorteringsrutinen krever stor plass da 3 array brukes

    • Array A[1..n] som skal sorteres

    • Array B[1..n] er sortert resultat

    • Array C[1..k] er temporært arbeidslager

  • Algoritmen sorterer i linjær tid

    • O(n), k = O(n)


Eksempel

1

2

3

4

5

6

7

8

B

4

j = 8

1

2

3

4

5

6

C

2

2

4

6

7

8

j

1

2

3

4

5

6

7

8

1

2

3

4

5

6

7

8

B

A

1

4

3

6

4

1

3

4

1

4

j = 7

1

2

3

4

5

6

Array som skal sorteres

B

1

2

4

6

7

8

1

2

3

4

5

6

1

2

3

4

5

6

7

8

B

B

2

0

2

3

0

1

1

4

4

j = 6

1

2

3

4

5

6

Antall 4’ere i A

C

1

2

4

5

7

8

1

2

3

4

5

6

1

2

3

4

5

6

7

8

C

2

2

4

7

7

8

B

1

3

4

4

j = 5

1

2

3

4

5

6

Antall elementer ≤ 3

C

1

2

3

5

7

8

Eksempel


Eksempel1

1

2

3

4

5

6

7

8

B

1

1

3

4

4

j = 4

1

2

3

4

5

6

C

0

2

3

5

7

8

1

2

3

4

5

6

7

8

1

2

3

4

5

6

7

8

B

A

1

1

3

4

4

4

3

6

4

1

3

4

1

4

j = 3

1

2

3

4

5

6

Array som skal sorteres

C

0

2

3

4

7

8

1

2

3

4

5

6

1

2

3

4

5

6

7

8

B

B

2

0

2

3

0

1

1

1

3

4

4

4

6

j = 2

1

2

3

4

5

6

Antall 4’ere i A

C

0

2

3

4

7

7

1

2

3

4

5

6

1

2

3

4

5

6

7

8

C

2

2

4

7

7

8

B

1

1

3

4

4

4

4

6

j = 1

1

2

3

4

5

6

Antall elementer ≤ 3

C

0

2

2

4

7

7

Eksempel

SORTERT


Radix sort

Radix-Sort

Sorterings-Algoritmer


Radix sort1

Radix-sort

  • Radix-sort er ulik andre sorteringsmetder, ettersom den tar hensyn til strukturen til nøklene som skal sorteres.

Element: {td, td-1 … t1}

Minst tellende siffer

Mest tellende siffer


Radix sort2

Sorterer bits fra høyre til venstre

Radix-sort

Radix-Sort(A,d)

for i=1 to d

do use a stable sort to sort array A on digit i


Analyse radix sort

Analyse Radix-Sort

  • Kjøretiden avhenger av hvilken sorteringsrutine som blir brukt

    • Couting-sort: (dn + kd)

      • Nar d er konstant og k = O(n) → O(n)

      • Krever ekstra lagerplass

    • Quicksort : (n*log n)

      • Når d er konstant

      • Krever ikke ekstra lagerplass


  • Login