Kette von P k ’s:

(1)

Kette von P _k ’s:

P _k P _k

P _k bottom

top

| {z }

t

Gesamtzahl der Elemente:

n

t(2k + 1) in den P _k ’s r = n − t(2k + 1) Rest

EADS 4 Sch¨onhage/Paterson/Pippenger-Median-Algorithmus 365/600

©Ernst W. Mayr

(2)

Wenn r < t − 1, dann wissen wir, dass top gr¨ oßer ist als k + (t − 1)(k + 1) > k + (k + 1)

n + 1 2k + 2 − 1

= n − 1 2

⇒ top > Median (Entsprechendes gilt f¨ ur das Element bottom)

Setze

k := j n

¹⁴

k

h sdg. 2 ^h ⁻ ¹ ≤ k < 2 ^h

©Ernst W. Mayr

(3)

Pool von Einzel- elementen

Pool von H

_i

1≤i≤2h

bilde

rekursiv H

2h

zerlege H

_2h

in P

_k

und H

_i

’s

i <2h

recycle H

_i

’s

f¨ uge P

k

in die Kette der P

k

’s ein (nach

Zentrum sortiert)

Kette von P

k

’s falls oben

nichts mehr geht

t−1> r t−1≤r

sortiere alle Elemente noch im System,

bestimme Median entferne die

2k+ 2

extremen Elemente, Rest der beiden

P

_k

’s in Pools

©Ernst W. Mayr

(4)

Definiere r := Anzahl der noch im H _2h -Produktionsprozess steckenden Elemente (f¨ ur jedes i < 2h h¨ ochstens ein H _i , daher r ≤ ^2h−1 P

i=0

2 ⁱ = 2 ^2h − 1).

R := Anzahl der im letzten Schritt zu sortierenden Elemente. Es gilt: t ≤ r + 1, und damit

R = t(2k + 1) + r ≤ 2 ^2h (2k + 1) + 2 ^2h − 1 . m := Gesamtzahl der im Algorithmus produzierten P _k ’s.

m = t + 2 n − R

2(k + 1) = t + n − R k + 1 . Also: r und t sind O (n

¹²

), R ist O (n

³⁴

).

©Ernst W. Mayr

(5)

Gesamtzahl der vom Algorithmus durchgef¨ uhrten Vergleiche =

1

Anzahl der Kanten in allen P _k ’s

2

+ Anzahl der Kanten, die gel¨ oscht werden, um die P _k ’s zu formen

3

+ Anzahl der Kanten, die zum Schluss in ¨ ubriggebliebenen H _i ’s, i < 2h, stecken

4

+ Anzahl der Vergleiche, um jedes Zentrum der P _k ’s in die (sortierte) Kette einzuf¨ ugen

5

+ Anzahl der Vergleiche, um die zum Schluss

¨ ubriggebliebenenen R Elemente zu sortieren

≤

n − R k + 1 + t



 

 |{z} 2k

1 + 3k | {z } + 2h

2 + log n 2k + 1

| {z }

4 

 

 + R log R

| {z }

5 + |{z} r

3 .

©Ernst W. Mayr

(6)

Mit k = j n

¹⁴

k

, h so, dass 2 ^h ⁻ ¹ ≤ k < 2 ^h , ergibt sich damit r = O (k ² )

t = O (k ² ) zum Schluss R = O (k ³ ), und damit die Anzahl der Vergleiche = T (n) ≤ 5n + o(n) . Verbesserte Version (besseres Zurechtschneiden, bessere Verwertung der Reste):

T (n) = 3n + o(n)

©Ernst W. Mayr

(7)

Bester bekannter Algorithmus (von Dor/Zwick):

2, 95n + o(n)

Literatur:

Arnold Sch¨ onhage, Michael Paterson, Nicholas Pippenger:

Finding the median

J. Comput. Syst. Sci. 13, pp. 184–199 (1976) Dorit Dor, Uri Zwick:

Selecting the median

SIAM J. Comput. 28(5), pp. 1722–1758 (1999)

©Ernst W. Mayr

(8)

5. Eine untere Schranke f¨ ur die Medianbestimmung

Satz 89

Jeder (vergleichsbasierte) Medianalgorithmus ben¨ otigt im worst-case mindestens _3n

2 − 2 Vergleiche.

Beweis:

Gegenspielerargument (adversary argument)

n Elemente, o.B.d.A. n ungerade, alle Elemente paarweise verschieden. Die Menge aller Elemente wird in drei Teilmengen partitioniert: U enth¨ alt die Kandidaten f¨ ur den Median, G enth¨ alt Elemente, die sicher gr¨ oßer als der Median sind, und L enth¨ alt Elemente, die sicher kleiner als der Median sind. Anfangs sind alle Elemente in U .

EADS 5 Eine untere Schranke f¨ur die Medianbestimmung 372/600

©Ernst W. Mayr

(9)

Beweis (Forts.):

Der Algorithmus stellt nun Fragen der Form a _i < a _j . Der Gegenspieler gibt konsistente Antworten, die den Algorithmus jedoch dazu zwingen, m¨ oglichst viele Fragen stellen zu m¨ ussen, bevor die Antwort feststehen kann (d.h. U soll m¨ oglichst ungeordnet bleiben).

Durch die (konsistenten!) Antworten des Gegenspielers auf die

“ < ^? “-Queries des Algorithmus entsteht ein DAG. Der Gegenspieler h¨ alt diesen DAG “einfach“, z.B. angenommen y > z und y > x, dann soll y

” sehr groß“ sein ⇒ y → G.

©Ernst W. Mayr

(10)

Strategie des Gegenspielers

Beweis (Forts.):

L U G

a

1

• • • • • ^a •

ⁿ

a _i < a _j

• •

a _i a _j

©Ernst W. Mayr

(11)

Strategie des Gegenspielers

Beweis (Forts.):

L U G

• • • • • • b % G

©Ernst W. Mayr

(12)

Strategie des Gegenspielers

Beweis (Forts.):

L U G

• • • • • • Solange ein Element unverglichen ist, ist nicht klar, welches der Median ist.

≤ n + 1 2 − 1

©Ernst W. Mayr

(13)

Beweis (Forts.):

Solange | L | , | G | < ⁿ⁺¹ ₂ , kann der Algorithmus annehmen, dass der Median in U ist. Solange U mindestens zwei unverglichene

Elemente und keine Zusammenhangskomponente mit > 2 Elementen enth¨ alt, kann der Algorithmus den Median nicht bestimmen.

©Ernst W. Mayr

(14)

Strategie des Gegenspielers

Beweis (Forts.):

Die Strategie des Gegenspielers hat zwei Phasen.

Erste Phase: Query sei x < y: ^?

i) x, y ∈ G bzw. x, y ∈ L: irgendeine konsistente Antwort ii) x ∈ G ∧ y ∈ L ∪ U (bzw. x ∈ L ∧ y ∈ G ∪ U ):

Antwort: y < x (bzw. x < y).

iii) Sei x, y ∈ U .

©Ernst W. Mayr

(15)

Query Antwort des Anzahl der |U | |L| |G|

Gegenspielers Paare in U

1. x y

x y

+1 — — —

2. x y y → G

x -1 -1 0 +1

3. x

y y → L

x

-1 -1 +1 0

4. x y y → G

x -1 -1 0 +1

5. x y y → L

x

-1 -1 +1 0

6. x

y x

&

L

y

-1 -1 +1 0

©Ernst W. Mayr

(16)

Die erste Phase endet, wenn | L | = ⁿ ⁻ ₂ ¹ oder | G | = ⁿ ⁻ ₂ ¹ . W¨ ahrend der Phase 1 enth¨ alt U mindestens zwei (in U ) maximale und mindestens zwei (in U ) minimale Elemente (bzgl. des DAGs). ⇒ W¨ ahrend Phase 1 kann der Algorithmus den Median mit Sicherheit nicht bestimmen.

Der Gegenspieler beginnt mit Phase 2, sobald

| L | wird n − 1

2 oder | G | wird n − 1 2 . O.B.d.A.:

| L | = n − 1 2

Der Gegenspieler zwingt nun den Algorithmus, das minimale Element in U bzgl. der gesamten totalen Ordnung zu bestimmen (da dieses unter den Vorgaben der Median ist).

©Ernst W. Mayr

Kette von P k ’s:

Kette von P k ’s:

P k P k

P k bottom

top

| {z }

t

Gesamtzahl der Elemente:

n

t(2k + 1) in den P k ’s r = n − t(2k + 1) Rest

Wenn r < t − 1, dann wissen wir, dass top gr¨ oßer ist als k + (t − 1)(k + 1) > k + (k + 1)

n + 1 2k + 2 − 1

= n − 1 2

⇒ top > Median (Entsprechendes gilt f¨ ur das Element bottom)

Setze

k := j n

k

h sdg. 2 h − 1 ≤ k < 2 h

Pool von Einzel- elementen

Pool von H

bilde

rekursiv H

zerlege H

in P

und H

’s

recycle H

’s

f¨ uge P

in die Kette der P

’s ein (nach

Zentrum sortiert)

Kette von P

’s falls oben

nichts mehr geht

sortiere alle Elemente noch im System,

bestimme Median entferne die

extremen Elemente, Rest der beiden

P

’s in Pools

Definiere r := Anzahl der noch im H 2h -Produktionsprozess steckenden Elemente (f¨ ur jedes i < 2h h¨ ochstens ein H i , daher r ≤ 2h−1 P

i=0

2 i = 2 2h − 1).

R := Anzahl der im letzten Schritt zu sortierenden Elemente. Es gilt: t ≤ r + 1, und damit

R = t(2k + 1) + r ≤ 2 2h (2k + 1) + 2 2h − 1 . m := Gesamtzahl der im Algorithmus produzierten P k ’s.

m = t + 2 n − R

2(k + 1) = t + n − R k + 1 . Also: r und t sind O (n

), R ist O (n

).

Gesamtzahl der vom Algorithmus durchgef¨ uhrten Vergleiche =

Anzahl der Kanten in allen P k ’s

+ Anzahl der Kanten, die gel¨ oscht werden, um die P k ’s zu formen

+ Anzahl der Kanten, die zum Schluss in ¨ ubriggebliebenen H i ’s, i < 2h, stecken

+ Anzahl der Vergleiche, um jedes Zentrum der P k ’s in die (sortierte) Kette einzuf¨ ugen

+ Anzahl der Vergleiche, um die zum Schluss

¨ ubriggebliebenenen R Elemente zu sortieren

≤

n − R k + 1 + t



 

 |{z} 2k

1

+ 3k | {z } + 2h

2

+ log n 2k + 1

| {z }

4



 

 + R log R

| {z }

5

+ |{z} r

3

.

Mit k = j n

k

, h so, dass 2 h − 1 ≤ k < 2 h , ergibt sich damit r = O (k 2 )

t = O (k 2 ) zum Schluss R = O (k 3 ), und damit die Anzahl der Vergleiche = T (n) ≤ 5n + o(n) . Verbesserte Version (besseres Zurechtschneiden, bessere Verwertung der Reste):

T (n) = 3n + o(n)

Kette von P _k ’s:

P _k P _k

P _k bottom

t(2k + 1) in den P _k ’s r = n − t(2k + 1) Rest

h sdg. 2 ^h ⁻ ¹ ≤ k < 2 ^h

Definiere r := Anzahl der noch im H _2h -Produktionsprozess steckenden Elemente (f¨ ur jedes i < 2h h¨ ochstens ein H _i , daher r ≤ ^2h−1 P

2 ⁱ = 2 ^2h − 1).

R = t(2k + 1) + r ≤ 2 ^2h (2k + 1) + 2 ^2h − 1 . m := Gesamtzahl der im Algorithmus produzierten P _k ’s.

Anzahl der Kanten in allen P _k ’s

+ Anzahl der Kanten, die gel¨ oscht werden, um die P _k ’s zu formen

+ Anzahl der Kanten, die zum Schluss in ¨ ubriggebliebenen H _i ’s, i < 2h, stecken

+ Anzahl der Vergleiche, um jedes Zentrum der P _k ’s in die (sortierte) Kette einzuf¨ ugen

, h so, dass 2 ^h ⁻ ¹ ≤ k < 2 ^h , ergibt sich damit r = O (k ² )

t = O (k ² ) zum Schluss R = O (k ³ ), und damit die Anzahl der Vergleiche = T (n) ≤ 5n + o(n) . Verbesserte Version (besseres Zurechtschneiden, bessere Verwertung der Reste):

Jeder (vergleichsbasierte) Medianalgorithmus ben¨ otigt im worst-case mindestens _3n

Der Algorithmus stellt nun Fragen der Form a _i < a _j . Der Gegenspieler gibt konsistente Antworten, die den Algorithmus jedoch dazu zwingen, m¨ oglichst viele Fragen stellen zu m¨ ussen, bevor die Antwort feststehen kann (d.h. U soll m¨ oglichst ungeordnet bleiben).

“ < ^? “-Queries des Algorithmus entsteht ein DAG. Der Gegenspieler h¨ alt diesen DAG “einfach“, z.B. angenommen y > z und y > x, dann soll y

• • • • • ^a •

a _i < a _j

a _i a _j

Solange | L | , | G | < ⁿ⁺¹ ₂ , kann der Algorithmus annehmen, dass der Median in U ist. Solange U mindestens zwei unverglichene

Erste Phase: Query sei x < y: ^?