Arraysortierungen mit Visual Basic .NET

Veröffentlicht: 06. Dez 2002 | Aktualisiert: 09. Nov 2004
Von Mathias Schiffer

Dieser Artikel zeigt Ihnen, wie Sie mit Visual Basic .NET Elemente in Arrays sortieren. Des Weiteren erhalten Sie Informationen, über die Möglichkeit Ihre eigenen Objekte sortierbar zumachen und Sortierregeln zu definieren.

Auf dieser Seite

 Eigene Datentypen sortierbar gestalten
 Eigene Sortierregeln definieren

Wie Sie Arrays mit Visual Basic 6 sortieren können, haben Sie im MSDN Quickie "Arrays sortieren mit BubbleSort und QuickSort" erfahren. Das .NET Framework macht Ihnen die Sache unter Visual Basic .NET noch einfacher. Hier sortieren Sie ein Array arrArray einfach durch folgende Anweisung:

Array.Sort(arrArray)

Auch Teile eines Arrays können Sie mithilfe von Array.Sort sortieren. Hierfür geben Sie das erste Element und die Anzahl der darauf folgenden Elemente des zu sortierenden Teilarrays als zusätzliche Integer-Parameter an:

Array.Sort(arrArray, 5, 20)

Möchten Sie ein Array rückwärts sortieren, so führen Sie zuerst eine Vorwärtssortierung durch und kehren die Reihenfolge der Array-Inhalte dann mittels Array.Reverse um:

Array.Sort(arrArray)
Array.Reverse(arrArray)

Für die Rückwärtssortierung eines Teilarrays können Sie analog vorgehen:

Array.Sort(arrArray, 5, 20)
Array.Reverse(arrArray, 5, 20)

Voraussetzung für dieses Vorgehen ist, dass die Datentypen, die sich als Werte im Array befinden, die Schnittstelle System.IComparable implementieren. Dies ist bei den vordefinierten Typen des .NET Frameworks der Fall.

Eigene Datentypen sortierbar gestalten

Ihre eigenen Typen müssen die Schnittstelle System.IComparable ebenfalls implementieren, wenn sie auf diese einfache Weise sortierbar sein sollen.

Die IComparable-Funktion CompareTo wird bei Sortierungen jeweils aufgerufen, wenn ein anderes Element mit dem aktuellen Element verglichen werden soll. Liefert sie einen negativen Wert zurück, gilt das andere Objekt als größer als das aktuelle Objekt. 0 ist der vorgesehene Rückgabewert für Elementgleichheit und ein positiver Wert signalisiert, dass das andere Objekt kleiner ist als das aktuelle Objekt.

Im folgenden Beispielcode finden Sie eine Implementation in einer einfach gehaltenen Klasse:

Class MeinTyp : Implements System.IComparable
  Private m_Wert As Long
  Private m_Gewichtung As Double
  ' Konstruktor
  Public Sub New(ByVal Wert As Integer, _
                 ByVal Gewichtung As Integer)
    m_Wert = Wert
    m_Gewichtung = Gewichtung
  End Sub
  ' Beispieleigenschaft Wert
  Public Property Wert() As Integer
    Get
      Return m_Wert
    End Get
    Set(ByVal Value As Integer)
      m_Wert = Value
    End Set
  End Property
  ' Beispieleigenschaft Gewichtung
  Public Property Gewichtung() As Double
    Get
      Return m_Gewichtung
    End Get
    Set(ByVal Value As Double)
      m_Gewichtung = Value
    End Set
  End Property
  ' Implementation CompareTo: Sortierung nach Eigenschaft Wert
  Public Function CompareTo(ByVal o As Object) As Integer _
                  Implements System.IComparable.CompareTo
    ' Typüberprüfung des Parameters
    If Not (TypeOf o Is MeinTyp) Then
      Throw New ArgumentException("o muss vom Typ 'MeinTyp'" & _
                                  "sein, ist aber vom Typ '" & _
                                  TypeName(o).ToString & "'.")
    End If
    ' Entscheidung über Größer-/Kleiner-/Gleich-Status
    Dim Vergleichsobjekt As MeinTyp = CType(o, MeinTyp)
    If Vergleichsobjekt.Wert = m_Wert Then
      Return 0
    ElseIf Vergleichsobjekt.Wert < m_Wert Then
      Return 1
    Else
      Return -1
    End If
  End Function
  ' ToString
  Public Overrides Function ToString() As String
    Return m_Wert.ToString
  End Function
End Class

Eigene Sortierregeln definieren

Die Methode Array.Sort sortiert ein Array nach den vorgegebenen Regeln der CompareTo-Funktion. Sie können die Elemente eines Arrays mithilfe dieser Methode aber auch nach eigenen Regeln sortieren lassen.

Ein Beispiel: Im Fall der obigen Klasse MeinTyp wird Array.Sort ein Array dieses Typs standardmäßig nach der Eigenschaft Wert sortieren. Sie können jedoch auch nach der Eigenschaft Gewichtung sortieren, ohne auf die Dienste von Array.Sort verzichten zu müssen.

Hierfür benötigen Sie eine Klasse, die Ihre eigenen Sortierregeln definiert (einen "Comparer"). Sie implementiert die Funktion Compare der Schnittstelle System.Collections.IComparer, deren Rückgabewert den Regeln für die oben erläuterte Funktion CompareTo entspricht. Die beiden zu vergleichenden Objekte werden dabei als Parameter übergeben (wobei das erste Objekt dem aktuellen Objekt in der Funktion CompareTo entspricht).

Für den Beispielfall, ein Array mit Elementen des Typs MeinTyp nach der Eigenschaft Gewichtung statt der Eigenschaft Wert zu sortieren, kann ein Comparer so implementiert werden:

Class MeinTypGewichtungsSortierung : _
      Implements System.Collections.IComparer
  ' Implementation von IComparer.Compare:
  Public Function Compare(ByVal x As Object, _
                          ByVal y As Object) As Integer _
                  Implements System.Collections.IComparer.Compare
    ' Typüberprüfung:
    If Not (TypeOf x Is MeinTyp And TypeOf y Is MeinTyp) Then
      Throw New ArgumentException("Die zu vergleichenden " & _
                                  "Objekte müssen vom Typ" & _
                                  "'MeinTyp' sein.")
    End If
    ' Entscheidung über Größer-/Kleiner-/Gleich-Status
    Dim Gewichtung1 As Double = CType(x, MeinTyp).Gewichtung
    Dim Gewichtung2 As Double = CType(y, MeinTyp).Gewichtung
    Return Gewichtung1.CompareTo(Gewichtung2)
  End Function
End Class

Um Ihren eigenen Comparer bei der Sortierung mittels Array.Sort zum Einsatz zu bringen, übergeben Sie der Methode eine Instanz Ihrer Comparer-Klasse als letzten Parameter:

Array.Sort(arrMeinTyp, New MeinTypGewichtungsSortierung())

Für Teilarrays erfolgt der Aufruf analog:

Array.Sort(arrMeinTyp, 5, 20, New MeinTypGewichtungsSortierung())

Anzeigen: