List<T>.BinarySearch Methode

Definitie

Naamruimte:
System.Collections.Generic
Assembly's:
mscorlib.dll, System.Collections.dll
Assembly:
mscorlib.dll
Assembly:
System.Collections.dll
Assembly:
netstandard.dll

Hiermee wordt een binair zoekalgoritmen gebruikt om een specifiek element in de gesorteerde List<T> of een deel ervan te zoeken.

Overloads

Name Description
BinarySearch(T)

Hiermee wordt gezocht naar het hele element dat is gesorteerd List<T> op een element met behulp van de standaardvergelijker en wordt de op nul gebaseerde index van het element geretourneerd.
BinarySearch(T, IComparer<T>)

Hiermee wordt gezocht naar het hele element dat is gesorteerd List<T> op basis van de opgegeven vergelijkingsfunctie en wordt de op nul gebaseerde index van het element geretourneerd.
BinarySearch(Int32, Int32, T, IComparer<T>)

Zoekt in een bereik van elementen in de gesorteerde List<T> op een element met behulp van de opgegeven vergelijkingsfunctie en retourneert de op nul gebaseerde index van het element.

BinarySearch(T)

Hiermee wordt gezocht naar het hele element dat is gesorteerd List<T> op een element met behulp van de standaardvergelijker en wordt de op nul gebaseerde index van het element geretourneerd.

public:
 int BinarySearch(T item);
public int BinarySearch(T item);
member this.BinarySearch : 'T -> int
Public Function BinarySearch (item As T) As Integer

Parameters

item
T

Het object dat moet worden gevonden. De waarde kan voor referentietypen zijn null .

Retouren

Int32

De op nul gebaseerde index van item in de gesorteerde List<T>, indien item gevonden; anders een negatief getal dat het bitsgewijze complement is van de index van het volgende element dat groter is dan item of, als er geen groter element is, het bitsgewijze complement van Count.

Uitzonderingen

InvalidOperationException

De standaard comparer Default kan geen implementatie van de IComparable<T> algemene interface of de IComparable interface voor het type Tvinden.

Voorbeelden

In het volgende voorbeeld ziet u de overbelasting van de Sort() methode en de overbelasting van de BinarySearch(T) methode. Er wordt een List<T> tekenreeks gemaakt en gevuld met vier tekenreeksen, in geen bepaalde volgorde. De lijst wordt weergegeven, gesorteerd en opnieuw weergegeven.

De BinarySearch(T) overbelasting van de methode wordt vervolgens gebruikt om te zoeken naar twee tekenreeksen die zich niet in de lijst bevinden en de Insert methode wordt gebruikt om deze in te voegen. De retourwaarde van de BinarySearch(T) methode is in elk geval negatief, omdat de tekenreeksen zich niet in de lijst bevinden. Het nemen van de bitsgewijze complement (de ~-operator in C#, Xor -1 in Visual Basic) van dit negatieve getal produceert de index van het eerste element in de lijst die groter is dan de zoekreeks en als u op deze locatie invoegt, blijft de sorteervolgorde behouden. De tweede zoekreeks is groter dan een element in de lijst, dus de invoegpositie bevindt zich aan het einde van de lijst.

List<string> dinosaurs = new List<string>();

dinosaurs.Add("Pachycephalosaurus");
dinosaurs.Add("Amargasaurus");
dinosaurs.Add("Mamenchisaurus");
dinosaurs.Add("Deinonychus");

Console.WriteLine("Initial list:");
Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nSort:");
dinosaurs.Sort();

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Coelophysis\":");
int index = dinosaurs.BinarySearch("Coelophysis");
if (index < 0)
{
    dinosaurs.Insert(~index, "Coelophysis");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}

Console.WriteLine("\nBinarySearch and Insert \"Tyrannosaurus\":");
index = dinosaurs.BinarySearch("Tyrannosaurus");
if (index < 0)
{
    dinosaurs.Insert(~index, "Tyrannosaurus");
}

Console.WriteLine();
foreach(string dinosaur in dinosaurs)
{
    Console.WriteLine(dinosaur);
}
/* This code example produces the following output:

Initial list:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort:

Amargasaurus
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaurus":

Amargasaurus
Coelophysis
Deinonychus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus
*/

Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & "Sort")
        dinosaurs.Sort

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Coelophysis"":")
        Dim index As Integer = dinosaurs.BinarySearch("Coelophysis")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Coelophysis")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""Tyrannosaurus"":")
        index = dinosaurs.BinarySearch("Tyrannosaurus")
        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Tyrannosaurus")
        End If

        Console.WriteLine()
        For Each dinosaur As String In dinosaurs
            Console.WriteLine(dinosaur)
        Next

    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Coelophysis":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Tyrannosaurus":
'
'Amargasaurus
'Coelophysis
'Deinonychus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus

Opmerkingen

Deze methode gebruikt de standaard comparer Comparer<T>.Default voor het type T om de volgorde van lijstelementen te bepalen. De Comparer<T>.Default eigenschap controleert of het type T de IComparable<T> algemene interface implementeert en deze implementatie gebruikt, indien beschikbaar. Zo niet, Comparer<T>.Default controleert u of het type T de IComparable interface implementeert. Als het type T geen van beide interfaces implementeert, Comparer<T>.Default genereert u een InvalidOperationException.

De List<T> moet al worden gesorteerd op basis van de vergelijkings-implementatie; anders is het resultaat onjuist.

Vergelijking null met een verwijzingstype is toegestaan en genereert geen uitzondering bij het gebruik van de IComparable<T> algemene interface. Bij het sorteren null wordt beschouwd als kleiner dan elk ander object.

Als het List<T> meer dan één element met dezelfde waarde bevat, retourneert de methode slechts één van de exemplaren en kan een van de exemplaren worden geretourneerd, niet noodzakelijkerwijs de eerste.

Als de List<T> opgegeven waarde niet bevat, retourneert de methode een negatief geheel getal. U kunt de bitsgewijze complementbewerking (~) toepassen op dit negatieve gehele getal om de index op te halen van het eerste element dat groter is dan de zoekwaarde. Bij het invoegen van de waarde in de List<T>index moet deze index worden gebruikt als de invoegpositie om de sorteervolgorde te behouden.

Deze methode is een O(log n)-bewerking, waarbij n het aantal elementen in het bereik is.

Zie ook

Van toepassing op

BinarySearch(T, IComparer<T>)

Hiermee wordt gezocht naar het hele element dat is gesorteerd List<T> op basis van de opgegeven vergelijkingsfunctie en wordt de op nul gebaseerde index van het element geretourneerd.

public:
 int BinarySearch(T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch(T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (item As T, comparer As IComparer(Of T)) As Integer

Parameters

item
T

Het object dat moet worden gevonden. De waarde kan voor referentietypen zijn null .

comparer
IComparer<T>

De IComparer<T> implementatie die moet worden gebruikt bij het vergelijken van elementen.

– of –

null om de standaard comparer Defaultte gebruiken.

Retouren

Int32

De op nul gebaseerde index van item in de gesorteerde List<T>, indien item gevonden; anders een negatief getal dat het bitsgewijze complement is van de index van het volgende element dat groter is dan item of, als er geen groter element is, het bitsgewijze complement van Count.

Uitzonderingen

InvalidOperationException

comparer is null, en de standaard comparer Default kan geen implementatie van de IComparable<T> algemene interface of de IComparable interface voor het type Tvinden.

Voorbeelden

In het volgende voorbeeld ziet u de overbelasting van de Sort(IComparer<T>) methode en de overbelasting van de BinarySearch(T, IComparer<T>) methode.

In het voorbeeld wordt een alternatieve vergelijking gedefinieerd voor tekenreeksen met de naam DinoCompare, waarmee de algemene interface IComparer<string> (IComparer(Of String) in Visual Basic) wordt geïmplementeerd. De vergelijking werkt als volgt: Eerst worden de comparands getest nullen wordt een null-verwijzing behandeld als minder dan een niet-null. Ten tweede worden de tekenreekslengten vergeleken en wordt de langere tekenreeks als groter beschouwd. Ten derde, als de lengten gelijk zijn, wordt gewone tekenreeksvergelijking gebruikt.

Er wordt een List<T> tekenreeks gemaakt en gevuld met vier tekenreeksen, in geen bepaalde volgorde. De lijst wordt weergegeven, gesorteerd met behulp van de alternatieve vergelijking en opnieuw weergegeven.

De BinarySearch(T, IComparer<T>) overbelasting van de methode wordt vervolgens gebruikt om te zoeken naar verschillende tekenreeksen die zich niet in de lijst bevinden, waarbij de alternatieve vergelijking wordt gebruikt. De Insert methode wordt gebruikt om de tekenreeksen in te voegen. Deze twee methoden bevinden zich in de functie met de naam SearchAndInsert, samen met code voor het nemen van de bitwise complement (de ~-operator in C#, Xor -1 in Visual Basic) van het negatieve getal dat wordt geretourneerd door BinarySearch(T, IComparer<T>) en gebruiken als index voor het invoegen van de nieuwe tekenreeks.

using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal.
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater.
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();
        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort with alternate comparer:");
        dinosaurs.Sort(dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Coelophysis", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Oviraptor", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc);
        Display(dinosaurs);

        SearchAndInsert(dinosaurs, null, dc);
        Display(dinosaurs);
    }

    private static void SearchAndInsert(List<string> list,
        string insert, DinoComparer dc)
    {
        Console.WriteLine("\nBinarySearch and Insert \"{0}\":", insert);

        int index = list.BinarySearch(insert, dc);

        if (index < 0)
        {
            list.Insert(~index, insert);
        }
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Mamenchisaurus
Deinonychus

Sort with alternate comparer:

Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Coelophysis":

Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Oviraptor":

Oviraptor
Coelophysis
Deinonychus
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "Tyrannosaur":

Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus

BinarySearch and Insert "":


Oviraptor
Coelophysis
Deinonychus
Tyrannosaur
Amargasaurus
Mamenchisaurus
Pachycephalosaurus
 */

Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' If the strings are not of equal length,
                    ' the longer string is greater.
                    '
                    Return retval
                Else
                    ' If the strings are of equal length,
                    ' sort them with ordinary string comparison.
                    '
                    Return x.CompareTo(y)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)
        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & "Sort with alternate comparer:")
        dinosaurs.Sort(dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Coelophysis", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Oviraptor", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, "Tyrannosaur", dc)
        Display(dinosaurs)

        SearchAndInsert(dinosaurs, Nothing, dc)
        Display(dinosaurs)
    End Sub

    Private Shared Sub SearchAndInsert( _
        ByVal lis As List(Of String), _
        ByVal insert As String, ByVal dc As DinoComparer)

        Console.WriteLine(vbLf & _
            "BinarySearch and Insert ""{0}"":", insert)

        Dim index As Integer = lis.BinarySearch(insert, dc)

        If index < 0 Then
            index = index Xor -1
            lis.Insert(index, insert)
        End If
    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Mamenchisaurus
'Deinonychus
'
'Sort with alternate comparer:
'
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Coelophysis":
'
'Coelophysis
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Oviraptor":
'
'Oviraptor
'Coelophysis
'Deinonychus
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "Tyrannosaur":
'
'Oviraptor
'Coelophysis
'Deinonychus
'Tyrannosaur
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus
'
'BinarySearch and Insert "":
'
'
'Oviraptor
'Coelophysis
'Deinonychus
'Tyrannosaur
'Amargasaurus
'Mamenchisaurus
'Pachycephalosaurus

Opmerkingen

De vergelijkingsfunctie past aan hoe de elementen worden vergeleken. U kunt bijvoorbeeld een CaseInsensitiveComparer exemplaar als vergelijkingsfunctie gebruiken om hoofdlettergevoelige tekenreekszoekopdrachten uit te voeren.

Indien comparer opgegeven, worden de elementen van de elementen List<T> vergeleken met de opgegeven waarde met behulp van de opgegeven IComparer<T> implementatie.

Als comparer dat het is null, controleert de standaard comparer Comparer<T>.Default of het type T de IComparable<T> algemene interface implementeert en die implementatie gebruikt, indien beschikbaar. Zo niet, Comparer<T>.Default controleert u of het type T de IComparable interface implementeert. Als het type T geen van beide interfaces implementeert, Comparer<T>.Default genereert InvalidOperationExceptionu .

De List<T> moet al worden gesorteerd op basis van de vergelijkings-implementatie; anders is het resultaat onjuist.

Vergelijking null met een verwijzingstype is toegestaan en genereert geen uitzondering bij het gebruik van de IComparable<T> algemene interface. Bij het sorteren null wordt beschouwd als kleiner dan elk ander object.

Als het List<T> meer dan één element met dezelfde waarde bevat, retourneert de methode slechts één van de exemplaren en kan een van de exemplaren worden geretourneerd, niet noodzakelijkerwijs de eerste.

Als de List<T> opgegeven waarde niet bevat, retourneert de methode een negatief geheel getal. U kunt de bitsgewijze complementbewerking (~) toepassen op dit negatieve gehele getal om de index op te halen van het eerste element dat groter is dan de zoekwaarde. Bij het invoegen van de waarde in de List<T>index moet deze index worden gebruikt als de invoegpositie om de sorteervolgorde te behouden.

Deze methode is een O(log n)-bewerking, waarbij n het aantal elementen in het bereik is.

Zie ook

Van toepassing op

BinarySearch(Int32, Int32, T, IComparer<T>)

Zoekt in een bereik van elementen in de gesorteerde List<T> op een element met behulp van de opgegeven vergelijkingsfunctie en retourneert de op nul gebaseerde index van het element.

public:
 int BinarySearch(int index, int count, T item, System::Collections::Generic::IComparer<T> ^ comparer);
public int BinarySearch(int index, int count, T item, System.Collections.Generic.IComparer<T> comparer);
member this.BinarySearch : int * int * 'T * System.Collections.Generic.IComparer<'T> -> int
Public Function BinarySearch (index As Integer, count As Integer, item As T, comparer As IComparer(Of T)) As Integer

Parameters

index
Int32

De op nul gebaseerde beginindex van het bereik om te zoeken.

count
Int32

De lengte van het bereik om te zoeken.

item
T

Het object dat moet worden gevonden. De waarde kan voor referentietypen zijn null .

comparer
IComparer<T>

De IComparer<T> implementatie die moet worden gebruikt bij het vergelijken van elementen of null het gebruik van de standaard comparer Default.

Retouren

Int32

De op nul gebaseerde index van item in de gesorteerde List<T>, indien item gevonden; anders een negatief getal dat het bitsgewijze complement is van de index van het volgende element dat groter is dan item of, als er geen groter element is, het bitsgewijze complement van Count.

Uitzonderingen

ArgumentOutOfRangeException

index is kleiner dan 0.

– of –

count is kleiner dan 0.

ArgumentException

index en count geen geldig bereik in de List<T>.

InvalidOperationException

comparer is null, en de standaard comparer Default kan geen implementatie van de IComparable<T> algemene interface of de IComparable interface voor het type Tvinden.

Voorbeelden

In het volgende voorbeeld ziet u de overbelasting van de Sort(Int32, Int32, IComparer<T>) methode en de overbelasting van de BinarySearch(Int32, Int32, T, IComparer<T>) methode.

In het voorbeeld wordt een alternatieve vergelijking gedefinieerd voor tekenreeksen met de naam DinoCompare, waarmee de algemene interface IComparer<string> (IComparer(Of String) in Visual Basic) wordt geïmplementeerd. De vergelijking werkt als volgt: Eerst worden de comparands getest nullen wordt een null-verwijzing behandeld als minder dan een niet-null. Ten tweede worden de tekenreekslengten vergeleken en wordt de langere tekenreeks als groter beschouwd. Ten derde, als de lengten gelijk zijn, wordt gewone tekenreeksvergelijking gebruikt.

Een List<T> reeks tekenreeksen wordt gemaakt en gevuld met de namen van vijf herbivorous dinosaurussen en drie carnivoreuze dinosaurussen. Binnen elk van de twee groepen bevinden de namen zich niet in een bepaalde sorteervolgorde. De lijst wordt weergegeven, het bereik van herbivoren wordt gesorteerd met behulp van de alternatieve vergelijking en de lijst wordt opnieuw weergegeven.

De BinarySearch(Int32, Int32, T, IComparer<T>) overbelasting van de methode wordt vervolgens gebruikt om alleen het bereik van herbivoren voor "Brachiosaurus" te doorzoeken. De tekenreeks is niet gevonden en de bitwise complement (de ~-operator in C#, Xor -1 in Visual Basic) van het negatieve getal dat wordt geretourneerd door de methode BinarySearch(Int32, Int32, T, IComparer<T>) wordt gebruikt als index voor het invoegen van de nieuwe tekenreeks.

using System;
using System.Collections.Generic;

public class DinoComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        if (x == null)
        {
            if (y == null)
            {
                // If x is null and y is null, they're
                // equal.
                return 0;
            }
            else
            {
                // If x is null and y is not null, y
                // is greater.
                return -1;
            }
        }
        else
        {
            // If x is not null...
            //
            if (y == null)
                // ...and y is null, x is greater.
            {
                return 1;
            }
            else
            {
                // ...and y is not null, compare the
                // lengths of the two strings.
                //
                int retval = x.Length.CompareTo(y.Length);

                if (retval != 0)
                {
                    // If the strings are not of equal length,
                    // the longer string is greater.
                    //
                    return retval;
                }
                else
                {
                    // If the strings are of equal length,
                    // sort them with ordinary string comparison.
                    //
                    return x.CompareTo(y);
                }
            }
        }
    }
}

public class Example
{
    public static void Main()
    {
        List<string> dinosaurs = new List<string>();

        dinosaurs.Add("Pachycephalosaurus");
        dinosaurs.Add("Parasauralophus");
        dinosaurs.Add("Amargasaurus");
        dinosaurs.Add("Galimimus");
        dinosaurs.Add("Mamenchisaurus");
        dinosaurs.Add("Deinonychus");
        dinosaurs.Add("Oviraptor");
        dinosaurs.Add("Tyrannosaurus");

        int herbivores = 5;
        Display(dinosaurs);

        DinoComparer dc = new DinoComparer();

        Console.WriteLine("\nSort a range with the alternate comparer:");
        dinosaurs.Sort(0, herbivores, dc);
        Display(dinosaurs);

        Console.WriteLine("\nBinarySearch a range and Insert \"{0}\":",
            "Brachiosaurus");

        int index = dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc);

        if (index < 0)
        {
            dinosaurs.Insert(~index, "Brachiosaurus");
            herbivores++;
        }

        Display(dinosaurs);
    }

    private static void Display(List<string> list)
    {
        Console.WriteLine();
        foreach( string s in list )
        {
            Console.WriteLine(s);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Parasauralophus
Amargasaurus
Galimimus
Mamenchisaurus
Deinonychus
Oviraptor
Tyrannosaurus

Sort a range with the alternate comparer:

Galimimus
Amargasaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus

BinarySearch a range and Insert "Brachiosaurus":

Galimimus
Amargasaurus
Brachiosaurus
Mamenchisaurus
Parasauralophus
Pachycephalosaurus
Deinonychus
Oviraptor
Tyrannosaurus
 */

Imports System.Collections.Generic

Public Class DinoComparer
    Implements IComparer(Of String)

    Public Function Compare(ByVal x As String, _
        ByVal y As String) As Integer _
        Implements IComparer(Of String).Compare

        If x Is Nothing Then
            If y Is Nothing Then 
                ' If x is Nothing and y is Nothing, they're
                ' equal. 
                Return 0
            Else
                ' If x is Nothing and y is not Nothing, y
                ' is greater. 
                Return -1
            End If
        Else
            ' If x is not Nothing...
            '
            If y Is Nothing Then
                ' ...and y is Nothing, x is greater.
                Return 1
            Else
                ' ...and y is not Nothing, compare the 
                ' lengths of the two strings.
                '
                Dim retval As Integer = _
                    x.Length.CompareTo(y.Length)

                If retval <> 0 Then 
                    ' If the strings are not of equal length,
                    ' the longer string is greater.
                    '
                    Return retval
                Else
                    ' If the strings are of equal length,
                    ' sort them with ordinary string comparison.
                    '
                    Return x.CompareTo(y)
                End If
            End If
        End If
    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs As New List(Of String)

        dinosaurs.Add("Pachycephalosaurus")
        dinosaurs.Add("Parasauralophus")
        dinosaurs.Add("Amargasaurus")
        dinosaurs.Add("Galimimus")
        dinosaurs.Add("Mamenchisaurus")
        dinosaurs.Add("Deinonychus")
        dinosaurs.Add("Oviraptor")
        dinosaurs.Add("Tyrannosaurus")

        Dim herbivores As Integer = 5
        Display(dinosaurs)

        Dim dc As New DinoComparer

        Console.WriteLine(vbLf & _
            "Sort a range with the alternate comparer:")
        dinosaurs.Sort(0, herbivores, dc)
        Display(dinosaurs)

        Console.WriteLine(vbLf & _
            "BinarySearch a range and Insert ""{0}"":", _
            "Brachiosaurus")

        Dim index As Integer = _
            dinosaurs.BinarySearch(0, herbivores, "Brachiosaurus", dc)

        If index < 0 Then
            index = index Xor -1
            dinosaurs.Insert(index, "Brachiosaurus")
            herbivores += 1
        End If

        Display(dinosaurs)

    End Sub

    Private Shared Sub Display(ByVal lis As List(Of String))
        Console.WriteLine()
        For Each s As String In lis
            Console.WriteLine(s)
        Next
    End Sub
End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Parasauralophus
'Amargasaurus
'Galimimus
'Mamenchisaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus
'
'Sort a range with the alternate comparer:
'
'Galimimus
'Amargasaurus
'Mamenchisaurus
'Parasauralophus
'Pachycephalosaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus
'
'BinarySearch a range and Insert "Brachiosaurus":
'
'Galimimus
'Amargasaurus
'Brachiosaurus
'Mamenchisaurus
'Parasauralophus
'Pachycephalosaurus
'Deinonychus
'Oviraptor
'Tyrannosaurus

Opmerkingen

De vergelijkingsfunctie past aan hoe de elementen worden vergeleken. U kunt bijvoorbeeld een CaseInsensitiveComparer exemplaar als vergelijkingsfunctie gebruiken om hoofdlettergevoelige tekenreekszoekopdrachten uit te voeren.

Indien comparer opgegeven, worden de elementen van de elementen List<T> vergeleken met de opgegeven waarde met behulp van de opgegeven IComparer<T> implementatie.

Als comparer dat het is null, controleert de standaard comparer Comparer<T>.Default of het type T de IComparable<T> algemene interface implementeert en die implementatie gebruikt, indien beschikbaar. Zo niet, Comparer<T>.Default controleert u of het type T de IComparable interface implementeert. Als het type T geen van beide interfaces implementeert, Comparer<T>.Default genereert InvalidOperationExceptionu .

De List<T> moet al worden gesorteerd op basis van de vergelijkings-implementatie; anders is het resultaat onjuist.

Vergelijking null met een verwijzingstype is toegestaan en genereert geen uitzondering bij het gebruik van de IComparable<T> algemene interface. Bij het sorteren null wordt beschouwd als kleiner dan elk ander object.

Als het List<T> meer dan één element met dezelfde waarde bevat, retourneert de methode slechts één van de exemplaren en kan een van de exemplaren worden geretourneerd, niet noodzakelijkerwijs de eerste.

Als de List<T> opgegeven waarde niet bevat, retourneert de methode een negatief geheel getal. U kunt de bitsgewijze complementbewerking (~) toepassen op dit negatieve gehele getal om de index op te halen van het eerste element dat groter is dan de zoekwaarde. Bij het invoegen van de waarde in de List<T>index moet deze index worden gebruikt als de invoegpositie om de sorteervolgorde te behouden.

Deze methode is een O(log n)-bewerking, waarbij n het aantal elementen in het bereik is.

Zie ook

Van toepassing op