Sinnvolle Modalwertberechnung

[alzaimar]

Du kannst es mit einer Hashmap lösen. Mit der Klasse 'TIntegerDictionary' aus dieser Unit geht das so:

Delphi-Quellcode:

Procedure ErmittleModalwert (Const anArray : TIntegerArray; Var Modus, Haeufigkeit : Integer);
Var
  Map : TIntegerDictionary;
  i : Integer;
  pCnt : ^Integer;
  iKey : Integer;

Begin
  Map := TIntegerDictionary.Create;
// Wir verwenden eine HaspMap, die Key/Value-Paare (hier: Value=Pointer) speichert. Da wir die 'Key' zählen wollen,
// definieren wir einen Zähler (Pointer to Integer), den wir als Nutzdatum (Value) zu jedem Schlüssel in der Map
// ablegen.
  Try
//
// 1.Schritt: Alle Elemente zählen
//
    For i:= Low (anArray) To High (anArray) Do Begin
      iKey := anArray[i];                           // Das Element des Arrays ist unser Schlüssel
      If Map.Find (iKey, Pointer (pCnt)) Then       // Wenn dieser Wert schon aufgetreten ist ...
        inc (pCnt^)                                 // den Zähler erhöhen...
      Else Begin
        new(pCnt);                                  // ...ansonsten einen neuen Zähler erstellen
        pCnt^:= 1;                                  // mit 1 initialisieren 
        Map.Add(iKey, Pointer (pCnt));              // und in der Integer-Map ablegen
      End
    End;
//
// 2.Schritt: Den Wertt mit dem höchsten Zähler ermitteln
//  
    Haeufigkeit := 0;
    Modus := -1;
  
    Map.First;          
    While Map.Next (iKey, Pointer (pCnt)) Do Begin  // Hohle nächsten Eintrag aus der Map
      If pCnt^>Haeufigkeit Then Begin               // Höchster Zähler? Wenn ja ...
        Haeufigkeit := pCnt^;                       // Wert merken
        Modus := iKey;
      End;
      Dispose (pCnt);                               // aber in jedem Fall den Speicher aufräumen
    End;
  Finally
    Map.Free;
  End;
End;

Der Aufwand ist O(N). Besser geht es nicht (Aufwandstechnisch)
Das triviale Verfahren, das Array zunächst zu sortieren und dann die längste Sequenz zu ermitteln ist mit O(N log N) vom Aufwand schlechter.