Mergesort: Unterschied zwischen den Versionen

Aus SibiWiki
Zur Navigation springen Zur Suche springen
 
(Eine dazwischenliegende Version desselben Benutzers wird nicht angezeigt)
Zeile 3: Zeile 3:
[[File:Mergesort.png|thumb|Mergesort für das Wort "informatik" |428px]]
[[File:Mergesort.png|thumb|Mergesort für das Wort "informatik" |428px]]
'''<font color='red'>nicht relevant fürs Zentralabitur!</font>'''
'''<font color='red'>nicht relevant fürs Zentralabitur!</font>'''
<font color='red'>'''Die Schnittstellenbeschreibung entspricht dem Abi 17 (und folgenden)'''</font>


= Funktionsweise =
= Funktionsweise =
Zeile 17: Zeile 15:


=Implementierung=  
=Implementierung=  
<code>
<code>
  private List<Person> teile(List<Person> pList){
  '''public List<String> mergesort(List<String> pList){'''
    '''//TODO'''  
  List<String> ergebnis = new List<>();
}
  List<String> links = new List<>();
 
  List<String> rechts = new List<>();
public List<Person> mergeSort(List<Person> pList){
  '''// Abbruchbedingung: nur 1 Element in pList'''
    List<Person> ergebnis = new List<>();
  pList.toFirst();
    List<Person> hintereListe = new List<>();
  pList.next();
  if(pList.hasAccess() == false) {
    // abbruchbedingung: nur 1 element in pList
      return pList;
    pList.toLast();
  }
    Person hinten = pList.getContent();
  '''// verteilen auf links und rechts'''
    pList.toFirst();
  boolean nachLinks = true;
    Person vorne = pList.getContent();
  for(pList.toFirst(); pList.hasAccess(); pList.next()) {
    if(vorne == hinten)
      String s = pList.getContent();
    {
      if(nachLinks == true) {
      // pList enthaelt nur ein Element!
        links.append(s);
      return pList;
        nachLinks = false;
    }
      }
      else {
    hintereListe = teile (pList);
        rechts.append(s);
        nachLinks = true;
    //sortieren der Teillisten durch rekursiven Aufruf
      }
    List<Person> pListSortiert = mergeSort(pList);
  }
    List<Person> hintersteListSortiert = mergeSort(hintereListe);
  '''//sortieren der Teillisten durch rekursive Aufrufe'''
   
  List<String> linksSortiert = '''mergesort(links);'''
    // verschmelzen
  List<String> rechtsSortiert = '''mergesort(rechts);'''  
    ergebnis = verschmelzen(pListSortiert, hintersteListSortiert);
  '''// die beiden sortierten Listen zu einer einzigen verschmelzen'''
    System.out.println("ende von mergesort:");
  ergebnis = merge(linksSortiert, rechtsSortiert);
    return ergebnis;
  return ergebnis;
  }
  }
</code>
</code>


mergeSort ruft die Methode verschmelzen auf:
'''Die folgende Hilfs-Methode verschmilzt zwei sortierte Listen zu einer einzigen.'''


<code>
<code>   
  /**
  '''private List<String> merge(List<String> l1, List<String> l2) {'''
  * verschmilzt zwei sortierte Listen
  List<String> ergebnis = new List<>();
  * zu einer sortierten Liste
  l1.toFirst();
  */
  l2.toFirst();
  private List<Person> verschmelzen(List<Person> l1, List<Person> l2) {
  // beide Listen parallel durchlaufen
    List<Person> ergebnis = new List<>();
  while(l1.hasAccess() && l2.hasAccess()){
    l1.toFirst();
      // jeweils die erste String auslesen
    l2.toFirst();
      String s1 = l1.getContent();
    // beide Listen parallel durchlaufen
      String s2 = l2.getContent();
    while(l1.hasAccess() && l2.hasAccess()){
      // die alphabetisch kleinere der beiden Strings
      // jeweils die erste Person auslesen
      // in die Liste ergebnis uebertragen
      Person p1 = l1.getContent();
      // und in der Herkunftsliste eins weiter gehen
      Person p2 = l2.getContent();
      if(s1.compareTo(s2) < 0){
      // die alphabetisch kleinere der beiden Personen
        ergebnis.append(s1);
      // in die Liste ergebnis uebertragen
        l1.next();
      // und aus der Herkunftsliste loeschen
      }
      if(p1.getName().compareTo(p2.getName()) < 0){
      else{
    ergebnis.append(p1);
        ergebnis.append(s2);
    l1.remove();
        l2.next();
      }
      }
      else{
  }
    ergebnis.append(p2);
  // den Rest der ersten Liste (wenn es einen gibt)
    l2.remove();
  // in ergebnis uebertragen
      }
  while(l1.hasAccess()){
    }
      ergebnis.append(l1.getContent());
    // den Rest der ersten Liste (wenn es einen gibt)
      l1.next();
    // in ergebnis uebertragen
  }
    while(l1.hasAccess()){
  // den Rest der zweiten Liste (wenn es einen gibt)
      ergebnis.append(l1.getContent());
  // in ergebnis uebertragen
      l1.remove();
  while(l2.hasAccess()){
    }
      ergebnis.append(l2.getContent());
    // den Rest der zweiten Liste (wenn es einen gibt)
      l2.next();
    // in ergebnis uebertragen
  }
    while(l2.hasAccess()){
  return ergebnis;
      ergebnis.append(l2.getContent());
      l2.remove();
    }
    return ergebnis;
  }
  }
</code>
</code>

Aktuelle Version vom 15. Dezember 2022, 17:09 Uhr


Mergesort für das Wort "informatik"

nicht relevant fürs Zentralabitur!

Funktionsweise

Mergesort ist ein Divide&Conquer-Verfahren.

Im Divide wird die Liste in zwei gleich große Teile aufgeteilt (wenn die Anzahl der Elemente ungerade ist, dann natürlich nicht ganz gleich groß...).

Beim Conquer werden die sortierten Teillisten zusammengefügt. Durch geschickte Implementierung kann man das in O(n) Zeit bewerkstelligen.

Laufzeit

Mergesort hat auch im Worst Case eine Laufzeit von O(n*log(n)).
Für Arrays ist allerdings Quicksort schneller, weil man bei Mergesort ständig neue Arrays erzeugen muss - bei Quicksort dagegen kann man in situ (bzw. in place) arbeiten.

Implementierung

public List<String> mergesort(List<String> pList){
  List<String> ergebnis = new List<>();
  List<String> links = new List<>();
  List<String> rechts = new List<>();
  // Abbruchbedingung: nur 1 Element in pList
  pList.toFirst();
  pList.next();
  if(pList.hasAccess() == false) {
     return pList;
  }
  // verteilen auf links und rechts
  boolean nachLinks = true;
  for(pList.toFirst(); pList.hasAccess(); pList.next()) {
     String s = pList.getContent();
     if(nachLinks == true) {
        links.append(s);
        nachLinks = false;
     }
     else {
        rechts.append(s);
        nachLinks = true;
     }
  }
  //sortieren der Teillisten durch rekursive Aufrufe
  List<String> linksSortiert = mergesort(links);
  List<String> rechtsSortiert = mergesort(rechts);  
  // die beiden sortierten Listen zu einer einzigen verschmelzen
  ergebnis = merge(linksSortiert, rechtsSortiert);
  return ergebnis;
}	

Die folgende Hilfs-Methode verschmilzt zwei sortierte Listen zu einer einzigen.

private List<String> merge(List<String> l1, List<String> l2) {
  List<String> ergebnis = new List<>();
  l1.toFirst();
  l2.toFirst();
  // beide Listen parallel durchlaufen
  while(l1.hasAccess() && l2.hasAccess()){
     // jeweils die erste String auslesen
     String s1 = l1.getContent();
     String s2 = l2.getContent();
     // die alphabetisch kleinere der beiden Strings
     // in die Liste ergebnis uebertragen
     // und in der Herkunftsliste eins weiter gehen
     if(s1.compareTo(s2) < 0){
        ergebnis.append(s1);
        l1.next();
     }
     else{
        ergebnis.append(s2);
        l2.next();
     }
  }
  // den Rest der ersten Liste (wenn es einen gibt)
  // in ergebnis uebertragen
  while(l1.hasAccess()){
     ergebnis.append(l1.getContent());
     l1.next();
  }
  // den Rest der zweiten Liste (wenn es einen gibt)
  // in ergebnis uebertragen
  while(l2.hasAccess()){
     ergebnis.append(l2.getContent());
     l2.next();
  }
  return ergebnis;
}