Skip to content

4.5 Die Master-Methode ​

Die Master-Methode ist ein zentrales Werkzeug, um rekursive Laufzeitgleichungen der Form

T(n)=a⋅T(nb)+f(n)

abzuschätzen, wobei

  • a≥1 (Anzahl der rekursiven Aufrufe),
  • b>1 (Faktor, um den das Problem verkleinert wird),
  • f(n) eine nichtnegative Funktion, die den Aufwand pro Teilung beschreibt (z. B. das Zusammenführen bei Mergesort).

1. Beispiele rekursiver Algorithmen ​

1.1 Mergesort ​

  • Idee: Teile das zu sortierende Array der Länge n in zwei Hälften à n2, sortiere diese rekursiv, und füge sie in Θ(n) Zeit wieder zusammen.
  • Rekursionsgleichung:
T(n)=2T(n2)+cnfür n>1,T(1)=Θ(1).

1.2 Fakultät n!=n⋅(n−1)! ​

  • Rekursive Form (nicht Master-Methoden-tauglich, da sich das Problem nicht in gleich große Teile aufspaltet):
T(n)=T(n−1)+O(1),T(1)=O(1).
  • Lösung: T(n)=Θ(n). (In algorithmischer Praxis steht dahinter oft das direkte Produkt.)

1.3 Fibonacci-Zahlen ​

  • Definition:
F(n)=F(n−1)+F(n−2),F(1)=F(2)=1.
  • Exponential Laufzeit bei naiver Rekursion (keine Master-Form). Üblich ist jedoch eine dynamische Programmierung mit O(n)-Zeit.

1.4 (Erweiterter) euklidischer Algorithmus ​

  • Erweiterter euklidischer Algorithmus findet x,y derart, dass
gcd(a,b)=ax+by.
Beispielrechnung (mit kompletter Tabelle).

Wir rechnen gcd(78,30) und finden zusätzlich die Darstellung 78x+30y=d.
Der Algorithmus füllt typischerweise eine Tabelle folgender Art:

iabqrxy
078302182-5
13018112-12
21812161-1
31262001

Am Ende erhält man die Linearkombination 78∗2+30∗(−5)=6,
aus der gcd(78,30)=6 hervorgeht.

2. Beispiel: Rekursiver Algorithmus findeMax() ​

Wir wollen das Maximum eines Arrays der Länge n finden.

  1. Rekursions-Idee

    text
    (A) Wenn n = 1: return z1
    (B) mitte := n/2
    (C) maxLinks  = findeMax( z1..z_mitte   )
    (D) maxRechts = findeMax( z_{mitte+1}..z_n )
    (E) return max( maxLinks, maxRechts )
  2. Rekursionsgleichung

    • Falls n=1:   T(1)=1∈O(1)
    • Falls n>1:   Die Schritte (B) und (E) etc. sind konstant, plus 2 rekursive Aufrufe mit je n2 Elementen.
    T(n)={1,falls n = 12+2T(n/2),sonst

3. Die Master-Methode: Definition und drei Fälle ​

Für die Rekursion

T(n)=aT(nb)+f(n),

mit a≥1, b>1, unterscheidet man drei Fälle:

  1. Fall 1: f(n) wächst langsamer als nlogb⁡a.
    Formal: f(n)∈O(nlogb⁡a−ε) für ein ε>0.
    Dann
T(n)∈Θ(nlogb⁡a).
  1. Fall 2: f(n) wächst wie nlogb⁡a.
    Formal: f(n)∈Θ(nlogb⁡a).
    Dann
T(n)∈Θ(nlogb⁡alog⁡n).
  1. Fall 3: f(n) wächst schneller als nlogb⁡a.
    Formal: f(n)∈Ω(nlogb⁡a+ε) und eine Regularitätsbedingung ist erfüllt.
    Dann
T(n)∈Θ(f(n)).
Beispielrechnungen:
  1. Mergesort
    T(n)=2T(n2)+cn,a=2,b=2,f(n)=cn.

    • logb⁡a=log2⁡2=1.
    • f(n)=cn=Θ(n1).
    • Übereinstimmung mit Fall 2
      ⇒T(n)∈Θ(nlog⁡n).
  2. findeMax()
    T(n)=2T(n2)+O(1).

    • log2⁡2=1.
    • Hier ist f(n)=O(1)=Θ(n0). Das liegt unter nlog2⁡2=n1.
    • Fall 1 (mit ε=1).
      ⇒T(n)∈Θ(n).
  3. Vereinfachtes Bsp.:
    T(n)=8T(n2)+100n2.

    • a=8,b=2,logb⁡a=log2⁡8=3.
    • f(n)=100n2=Θ(n2).
    • Vergleiche n2 mit n3.
    • n2 wächst langsamer als n3. → Fall 1
      ⇒T(n)∈Θ(n3).
  4. Beispiel (Fall 3):
    T(n)=2T(n4)+10n⟶a=2,b=4,f(n)=10n.

    • logb⁡a=log4⁡(2)=12.
    • Somit ist nlogb⁡a=n1/2=n.
    • Da f(n)=10n schneller wächst als n, wählen wir ε=12. Zweite Bedingung (Regularitätsbedingung)
    • Für Fall 3 muss gelten:
    • a⋅f(nb)≤cf(n)für ein konstantes 0<c<1.

    Hier:

    • a⋅f(n4)=2⋅10n4=5n.
    • Wir vergleichen das mit f(n)=10n.\
    • 5n≤c⋅10n⇒c≥0.5.\
    • Also kann man z.,B. c=0.5 wählen, was die Bedingung erfüllt (c<1).
      Fazit (Fall 3):
      T(n)∈Θ(f(n))=Θ(n).