10. Sortieren III

(1)

Bucketsort

269

(2)

270

(3)

Untere Schranke f ¨ur das Sortieren

Bis hierher: Sortieren im schlechtesten Fall benötigtΩ(nlogn) Schritte.

Geht es besser?

und im Mittel mindestens Ω(nlogn)Schlüsselvergleiche.

271

(4)

Bis hierher: Sortieren im schlechtesten Fall benötigtΩ(nlogn) Schritte.

Geht es besser? Nein:

Theorem

Vergleichsbasierte Sortierverfahren benötigen im schlechtesten Fall und im Mittel mindestens Ω(nlogn)Schlüsselvergleiche.

271

(5)

Vergleichsbasiertes Sortieren

Algorithmus muss untern!vielen Anordnungsmöglichkeiten einer Folge (Ai)i=1,...,n die richtige identifizieren.

Zu Beginn weiss der Algorithmus nichts.

Betrachten den “Wissensgewinn” des Algorithmus als Entscheidungsbaum:

272

(6)

Vergleichsbasiertes Sortieren

272

(7)

Vergleichsbasiertes Sortieren

272

(8)

Vergleichsbasiertes Sortieren

Knoten enthalten verbleibende Möglichkeiten

272

(9)

Knoten enthalten verbleibende Möglichkeiten Kanten enthalten Entscheidungen

272

(10)

a < b

b < c

abc a < c

acb cab

b < c

a < c

bac bca

cba

Ja Nein

Ja Nein Ja Nein

abc acb cab bac bca cba

acb cab bac bca

273

(11)

log₂L. ⇒Höhe des Entscheidungsbaumes h ≥ logn! ∈ Ω(nlogn).¹¹

Somit auch die Länge des längsten Pfades im Entscheidungsbaum

∈ Ω(nlogn).

Bleibt zu zeigen: mittlere Länge M(n) eines Pfades M(n) ∈ Ω(nlogn).

11logn!∈Θ(nlogn):

logn! =Pn

k=1logk≤nlogn.

logn! =Pn

k=1logk≥Pn

k=n/2logk≥ⁿ₂ ·logⁿ₂.

274

(12)

T_b_l

T_b_r

← b_r →

←b_l →

EntscheidungsbaumT_nmitnBlättern, mittlere Tiefe eines Blattsm(T_n)

Annahme:m(T_n)≥lognnicht für allen.

Wähle kleinstesbmitm(Tb)<logn⇒b ≥2 b_l+b_r =b, oBdAb_l >0undb_r>0⇒ b_l < b, b_r < b⇒m(T_b_l)≥logb_l und m(T_b_r)≥logb_r

275

(13)

m(T_b) = b_l

b(m(T_b_l) + 1) +b_r

b(m(T_b_r) + 1)

≥ 1

b(b_l(logb_l+ 1) +b_r(logb_r+ 1)) = 1

b(b_llog 2b_l+b_rlog 2b_r)

≥ 1

b(blogb) = logb.

Widerspruch.

Die letzte Ungleichung gilt, daf(x) = xlogx konvex ist und für eine konvexe Funktion giltf((x+y)/2)≤1/2f(x) + 1/2f(y)(x= 2b_l,y= 2b_r einsetzen).¹² Einsetzen vonx= 2b_l,y= 2b_r, undb_l+b_r=b.

12allgemeinf(λx+ (1−λ)y)≤λf(x) + (1−λ)f(y)für0≤λ≤1.

276

(14)

277

(15)

Radix Sort

Vergleichsbasierte Sortierverfahren: Schlüssel vergleichbar (< oder

>, =). Ansonsten keine Voraussetzung.

278

(16)

Vergleichsbasierte Sortierverfahren: Schlüssel vergleichbar (< oder

>, =). Ansonsten keine Voraussetzung.

Andere Idee: nutze mehr Information über die Zusammensetzung der Schlüssel.

278

(17)

Annahmen

Annahme: Schlüssel darstellbar als Wörter aus einem Alphabet mit m Elementen.

Beispiele

m heisst die Wurzel (lateinisch Radix) der Darstellung.

279

(18)

Annahmen

Beispiele

279

(19)

Annahmen

Beispiele

m = 10 Dezimalzahlen 183 = 18310

279

(20)

Annahmen

Beispiele

m = 2 Dualzahlen 101₂ m = 16 Hexadezimalzahlen A0₁₆

279

(21)

m Elementen.

Beispiele

m = 2 Dualzahlen 101₂ m = 16 Hexadezimalzahlen A0₁₆

m = 26 Wörter “INFORMATIK”

279

(22)

Annahmen

Schlüssel =m-adische Zahlen mit gleicher Länge.

Verfahrenz zur Extraktion derk-ten Ziffer eines Schlüssels in O(1)Schritten.

z₁₀(2,85) = 0

280

(23)

Annahmen

z₁₀(2,85) = 0

280

(24)

Beispiel z10(0,85) = 5 z₁₀(1,85) = 8 z₁₀(2,85) = 0

280

(25)

Schlüssel mit Radix 2. Beobachtung: Wennk ≥ 0,

z2(i, x) = z2(i, y) für alle i > k und

z₂(k, x) < z₂(k, y), dann x < y.

281

(26)

Idee:

Starte mit maximalem k.

Binäres Aufteilen der Datensätze mit z₂(k,·) = 0 vs.z₂(k,·) = 1 wie bei Quicksort.

k ←k −1.

282

(27)

Radix-Exchange-Sort

0111 0110 1000 0011 0001

0001 0011 0110 0111 1000 0001 0011 0110 0111 1000

283

(28)

Radix-Exchange-Sort

0111 0110 1000 0011 0001

0001 0011 0110 0111 1000 0001 0011 0110 0111 1000

283

(29)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000

0001 0011 0110 0111 1000

283

(30)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000

0001 0011 0110 0111 1000

283

(31)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000 0011 0001 0110 0111 1000

283

(32)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000 0011 0001 0110 0111 1000

283

(33)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000 0011 0001 0110 0111 1000 0001 0011 0110 0111 1000

283

(34)

Radix-Exchange-Sort

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000 0011 0001 0110 0111 1000 0001 0011 0110 0111 1000

283

(35)

0111 0110 1000 0011 0001 0111 0110 0001 0011 1000 0011 0001 0110 0111 1000 0001 0011 0110 0111 1000 0001 0011 0110 0111 1000

283

(36)

Output : Array A, im Bereich [l, r] nach Bits [0, . . . , b] sortiert.

if l > r and b≥0 then i←l−1

j ←r+ 1 repeat

repeat i←i+ 1 untilz₂(b, A[i]) = 1 andi≥j repeat j ←j+ 1 until z₂(b, A[j]) = 0 and i≥j if i < j thenswap(A[i], A[j])

until i≥j

RadixExchangeSort(A, l, i−1, b−1) RadixExchangeSort(A, i, r, b−1)

284

(37)

RadixExchangeSort ist rekursiv mit maximaler Rekursionstiefe = maximaler Anzahl Ziffernp.

Laufzeit im schlechtesten FallO(p·n).

285

(38)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131 21 122 3 23 8 18 19 29

286

(39)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

3

121 131 21 122 3 23 8 18 19 29

286

(40)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

3 8

121 131 21 122 3 23 8 18 19 29

286

(41)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

3 8

18

121 131 21 122 3 23 8 18 19 29

286

(42)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

122 3 8

18

121 131 21 122 3 23 8 18 19 29

286

(43)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 122 3 8

18

121 131 21 122 3 23 8 18 19 29

286

(44)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131

122 3 8

18

121 131 21 122 3 23 8 18 19 29

286

(45)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131

122 3 23

8 18

121 131 21 122 3 23 8 18 19 29

286

(46)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131 21

122 3 23

8 18

121 131 21 122 3 23 8 18 19 29

286

(47)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131 21

122 3 23

8 18

19

121 131 21 122 3 23 8 18 19 29

286

(48)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 122 121 131 23 21 19 29

0 1 2 3 4 5 6 7 8 9

121 131 21

122 3 23

8 18

19 29

286

(49)

0 1 2 3 4 5 6 7 8 9

121 131 21

122 3 23

8 18

19 29

121 131 21 122 3 23 8 18 19 29

286

(50)

Bucket Sort (Sortieren durch Fachverteilen)

121 131 21 122 3 23 8 18 19 29

3 8

18 19

121 21 122

23 29

131

3 8 18 19 121 21 122 23 29

287

(51)

Bucket Sort (Sortieren durch Fachverteilen)

121 131 21 122 3 23 8 18 19 29

0 1 2 3 4 5 6 7 8 9

3 8

18 19

121 21 122

23 29

131

287

(52)

0 1 2 3 4 5 6 7 8 9

3 8

18 19

121 21 122

23 29

131

3 8 18 19 121 21 122 23 29

287

(53)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 19 121 21 122 23 29

3 8 18 19 21

121 122 131

3 8 18 19 21 23 29 121 122 131

288

(54)

Bucket Sort (Sortieren durch Fachverteilen)

3 8 18 19 121 21 122 23 29

0 1 2 3 4 5 6 7 8 9

3 8 18 19 21 23 29

121 122 131

288

(55)

0 1 2 3 4 5 6 7 8 9

3 8 18 19 21 23 29

121 122 131

3 8 18 19 21 23 29 121 122 131

288

(56)

Implementationsdetails

Bucketgrösse sehr unterschiedlich. Zwei Möglichkeiten

289

(57)

Implementationsdetails

Bucketgrösse sehr unterschiedlich. Zwei Möglichkeiten Verkettete Liste für jede Ziffer.

289

(58)

Bucketgrösse sehr unterschiedlich. Zwei Möglichkeiten Verkettete Liste für jede Ziffer.

Ein Array der Länge n, Offsets für jede Ziffer in erstem Durchlauf bestimmen.

289

(59)

Implementationsvarianten der verketteten Liste, amortisierte Analyse [Ottman/Widmayer, Kap. 1.5.1-1.5.2, Cormen et al, Kap.

10.1.-10.2,17.1-17.3]

290

(60)

Abstrakte Datentypen

Wir erinnern uns¹³ (Vorlesung Informatik I)

EinStackist ein abstrakter Datentyp (ADT) mit Operationen

isEmpty(S): Lieferttrue wenn Stack leer, sonst false. emptyStack(): Liefert einen leeren Stack.

13hoffentlich

291

(61)

Abstrakte Datentypen

EinStackist ein abstrakter Datentyp (ADT) mit Operationen push(x, S): Legt Element x auf den StapelS.

emptyStack(): Liefert einen leeren Stack.

13hoffentlich

291

(62)

Abstrakte Datentypen

pop(S): Entfernt und liefert oberstes Element vonS, oder null.

13hoffentlich

291

(63)

Abstrakte Datentypen

pop(S): Entfernt und liefert oberstes Element vonS, oder null. top(S): Liefert oberstes Element vonS, oder null.

13hoffentlich

291

(64)

Abstrakte Datentypen

isEmpty(S): Lieferttrue wenn Stack leer, sonst false.

13hoffentlich

291

(65)

Wir erinnern uns (Vorlesung Informatik I)

isEmpty(S): Lieferttrue wenn Stack leer, sonst false. emptyStack(): Liefert einen leeren Stack.

13hoffentlich

291

(66)

Implementation Push

top x_n x_n−1 x₁ null

push(x, S):

Erzeuge neues Listenelement mit und Zeiger auf den Wert von top.

2 Setze topauf den Knotem mit x.

292

(67)

Implementation Push

x push(x, S):

1 Erzeuge neues Listenelement mit xund Zeiger auf den Wert von top.

292

(68)

x push(x, S):

1 Erzeuge neues Listenelement mit xund Zeiger auf den Wert von top.

2 Setze topauf den Knotem mit x.

292

(69)

Implementation Pop

pop(S):

Isttop=null, dann gib null zurück

2 Andernfalls merke Zeiger pvon top inr.

3 Setze topauf p.next und gib r zurück

293

(70)

Implementation Pop

pop(S):

1 Isttop=null, dann gib null zurück

293

(71)

Implementation Pop

r pop(S):

293

(72)

r pop(S):

293

(73)

Jede der Operationenpush, pop, topund isEmpty auf dem Stack ist in O(1) Schritten ausführbar.

294

(74)

Queue (Schlange / Warteschlange / Fifo)

Queue ist ein ADT mit folgenden Operationen:

head(Q): liefert das Objekt am Beginn der Schlage zurück (null sonst.)

isEmpty(Q): liefert true wenn Queue leer, sonstfalse. emptyQueue(): liefert leere Queue zurück.

295

(75)

Queue (Schlange / Warteschlange / Fifo)

enqueue(x, Q): fügtx am Ende der Schlange an.

sonst.)

295

(76)

Queue (Schlange / Warteschlange / Fifo)

dequeue(Q): entfernt xvom Beginn der Schlange und gibt x zurück (null sonst.)

emptyQueue(): liefert leere Queue zurück.

295

(77)

Queue (Schlange / Warteschlange / Fifo)

295

(78)

Queue (Schlange / Warteschlange / Fifo)

isEmpty(Q): liefert true wenn Queue leer, sonstfalse.

295

(79)

295

(80)

Implementation Queue

x₁ x₂ x_n−1 x_n

head tail

null

enqueue(x, S):

1 Erzeuge neues Listenelement mit xund Zeiger auf null.

2 Wenntail 6= null , setzetail.next auf den Knoten mitx.

3 Setze tail auf den Knoten mitx.

4 Isthead = null, dann setze head auf tail.

296

(81)

Implementation Queue

head tail

null

x null

enqueue(x, S):

296

(82)

Implementation Queue

head tail

null

x null

enqueue(x, S):

296

(83)

Implementation Queue

head tail

x null

enqueue(x, S):

3 Setze tailauf den Knoten mit x.

296

(84)

Implementation Queue

head tail

x null

enqueue(x, S):

3 Setze tailauf den Knoten mit x.

296

(85)

Invarianten!

head tail

null

Mit dieser Implementation gilt

head.next 6= null.

297

(86)

Invarianten!

head tail

null

Mit dieser Implementation gilt entweder head = tail = null,

297

(87)

Invarianten!

head tail

null

Mit dieser Implementation gilt entweder head = tail = null,

oder head = tail 6= null undhead.next = null

297

(88)

head tail Mit dieser Implementation gilt

entweder head = tail = null,

oder head = tail 6= null undhead.next = null

oder head 6= null und tail 6= null und head 6= tailund head.next 6= null.

297

(89)

Implementation Queue

head tail

null

dequeue(S):

1 Merke Zeiger von head in r. Wennr = null, gib r zurück.

2 Setze den Zeiger von head auf head.next.

3 Ist nun head = null, dann setze tail aufnull.

4 Gib den Wert vonr zurück.

298

(90)

Implementation Queue

head tail

null

r

dequeue(S):

298

(91)

Implementation Queue

head tail

null

r

dequeue(S):

298

(92)

Implementation Queue

head tail

null

r

dequeue(S):

298

(93)

head tail r

dequeue(S):

4 Gib den Wert vonr zurück.

298

(94)

Jede der Operationenenqueue,dequeue,head und isEmptyauf der Queue ist in O(1)Schritten ausführbar.

299

(95)

Implementationsvarianten verketteter Listen

Liste mit Dummy-Elementen (Sentinels).

head tail

Vorteil: Weniger Spezialfälle!

300

(96)

head tail

Vorteil: Weniger Spezialfälle!

Variante davon: genauso, dabei Zeiger auf ein Element immer einfach indirekt gespeichert.

300

(97)

Doppelt verkettete Liste

null x₁ x₂ x_n−1 x_n null

head tail

301

(98)

enqueue insert delete search concat

(A) Θ(1) Θ(1) Θ(n) Θ(n) Θ(n)

(B) Θ(1) Θ(1) Θ(n) Θ(n) Θ(1)

(C) Θ(1) Θ(1) Θ(1) Θ(n) Θ(1)

(D) Θ(1) Θ(1) Θ(1) Θ(n) Θ(1)

(A) = Einfach verkettet

(B) = Einfach verkettet, mit Dummyelement

(C) = Einfach verkettet, mit einfach indirekter Elementaddressierung (D) = Doppelt verkettet

302

(99)

Priority Queue = Warteschlange mit Prioritäten.

Operationen

insert(x,p,Q): Füge Objekt xmit Priorität pein.

extractMax(Q): Entferne Objektx mit höchster Priorität und liefere es.

303

(100)

Mit einem Max-Heap!

Also

insertin Zeit O(?) und extractMax in ZeitO(?).

304

(101)

Mit einem Max-Heap!

Also

insertin Zeit O(logn) und extractMax in ZeitO(?).

304

(102)

Mit einem Max-Heap!

Also

insertin Zeit O(logn) und extractMax in ZeitO(logn).

304

(103)

Multistack unterstützt neben den oben genannten Stackoperationen noch

multipop(s,S): Entferne diemin(size(S), k) zuletzt eingefügten Objekte und liefere diese zurück.

Implementation wie beim Stack. Laufzeit vonmultipop ist O(k).

305

(104)

Akademische Frage

Führen wir auf einem Stack mit nElementenn malmultipop(k,S) aus, kostet das dannO(n²)?

306

(105)

Akademische Frage

Sicher richtig, denn jeder multipop kann Zeit O(n) haben.

306

(106)

Sicher richtig, denn jeder multipop kann Zeit O(n) haben.

Wie machen wir es besser?

306

(107)

Wir führen ein Kostenmodell ein:

Aufruf von push: kostet 1 CHF und zusätzlich 1 CHF kommt aufs Bankkonto

Aufruf von pop: kostet 1 CHF, wird durch Rückzahlung vom Bankkonto beglichen.

Kontostand wird niemals negativ. Also: maximale Kosten: Anzahl derpush Operationen mal zwei.

307

(108)

Amortisierte Kosten der i-ten Operation:

a_i := t_i + Φ_i −Φ_i−1.

Es gilt

n

X

i=1

a_i =

n

X

i=1

(t_i+ Φ_i −Φ_i−1) =

n

X

i=1

t_i

!

+ Φ_n −Φ₀ ≥

n

X

i=1

t_i.

Ziel: Suche Potentialfunktion, die teure Operationen ausgleicht.

308

(109)

push(x, S): Reale Kosten t_i = 1. Φ_i −Φ_i−1 = 1. Amortisierte Kosten a_i = 2.

pop(S): Reale Kostent_i = 1. Φ_i −Φ_i−1 = −1. Amortisierte Kosten ai = 0.

multipop(k, S): Reale Kostent_i = k. Φ_i −Φ_i−1 = −k. Amortisierte Kosten a_i = 0.

Alle Operationen habenkonstante amortisierte Kosten! Im Durchschnitt hat also Multipop konstanten Zeitbedarf.

309

(110)

maximal k Bitflips. Also O(n·k) Bitflips für Zählen von 1 bisn. Geht das besser?

Reale Kostent_i = Anzahl Bitwechsel von 0 nach 1 plus Anzahl Bitwechsel von 1 nach 0.

...0 1111111

| {z }

lEinsen

+1 = ...1 0000000

| {z }

lNullen

.

⇒ti = l + 1

310

(111)

...0 1111111

| {z }

lEinsen

+1 = ...1 0000000

| {z }

lNullen

Potentialfunktion Φ_i: Anzahl der 1-Bits von x_i.

⇒Φ_i −Φ_i−1 = 1−l,

⇒ a_i = t_i+ Φ_i−Φ_i−1 = l + 1 + (1−l) = 2.

Amortisiert konstante Kosten für eine Zähloperation.

311