List<T>.BinarySearch Método

Definição

Namespace:

System.Collections.Generic

Assemblies:

netstandard.dll, System.Collections.dll

Usa um algoritmo de pesquisa binária para localizar um elemento específico na parte classificada List<T> ou em uma parte dele.

Sobrecargas

Nome	Description
BinarySearch(T)	Pesquisa todo o classificado List<T> por um elemento usando o comparador padrão e retorna o índice baseado em zero do elemento.
BinarySearch(T, IComparer<T>)	Pesquisa todo o classificado List<T> por um elemento usando o comparador especificado e retorna o índice baseado em zero do elemento.
BinarySearch(Int32, Int32, T, IComparer<T>)	Pesquisa um intervalo de elementos na classificação List<T> de um elemento usando o comparador especificado e retorna o índice baseado em zero do elemento.

BinarySearch(T)

Origem:

List.cs

Pesquisa todo o classificado List<T> por um elemento usando o comparador padrão e retorna o índice baseado em zero do elemento.

public:
 int BinarySearch(T item);

public int BinarySearch(T item);

member this.BinarySearch : 'T -> int

Public Function BinarySearch (item As T) As Integer

Parâmetros

item

T

O objeto a ser localizado. O valor pode ser null para tipos de referência.

Retornos

Int32

O índice item baseado em zero no classificado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento maior que item ou, se não houver nenhum elemento maior, o complemento bit a bit de Count.

Exceções

InvalidOperationException

O comparador Default padrão não pode encontrar uma implementação da IComparable<T> interface genérica ou da interface para o IComparable tipo T.

Exemplos

O exemplo a seguir demonstra a sobrecarga do Sort() método e a sobrecarga do BinarySearch(T) método. Uma List<T> das cadeias de caracteres é criada e preenchida com quatro cadeias de caracteres, em nenhuma ordem específica. A lista é exibida, classificada e exibida novamente.

A BinarySearch(T) sobrecarga do método é usada para pesquisar duas cadeias de caracteres que não estão na lista e o Insert método é usado para inseri-las. O valor retornado do BinarySearch(T) método é negativo em cada caso, porque as cadeias de caracteres não estão na lista. Usar o complemento bit a bit (o operador ~ em C#, Xor -1 no Visual Basic) desse número negativo produz o índice do primeiro elemento na lista que é maior que a cadeia de caracteres de pesquisa e inserir nesse local preserva a ordem de classificação. A segunda cadeia de caracteres de pesquisa é maior que qualquer elemento na lista, portanto, a posição de inserção está no final da lista.

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

Comentários

Esse método usa o comparador Comparer<T>.Default padrão para o tipo T para determinar a ordem dos elementos de lista. A Comparer<T>.Default propriedade verifica se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default gerará uma InvalidOperationException.

O List<T> valor já deve ser classificado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera uma exceção ao usar a IComparable<T> interface genérica. Ao classificar, null é considerado menor que qualquer outro objeto.

Se o List<T> elemento contiver mais de um com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> valor especificado não contiver, o método retornará um inteiro negativo. Você pode aplicar a operação de complemento bit a bit (~) a esse inteiro negativo para obter o índice do primeiro elemento maior que o valor de pesquisa. Ao inserir o valor no List<T>índice, esse índice deve ser usado como o ponto de inserção para manter a ordem de classificação.

Esse método é uma operação O(log n), em que n é o número de elementos no intervalo.

Confira também

• Executando operações de cadeia de caracteres Culture-Insensitive em coleções

BinarySearch(T, IComparer<T>)

Origem:

List.cs

Pesquisa todo o classificado List<T> por um elemento usando o comparador especificado e retorna o índice baseado em zero do elemento.

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

Parâmetros

item

T

O objeto a ser localizado. O valor pode ser null para tipos de referência.

comparer

IComparer<T>

A IComparer<T> implementação a ser usada ao comparar elementos.

- ou -

null para usar o comparador Defaultpadrão.

Retornos

Int32

O índice item baseado em zero no classificado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento maior que item ou, se não houver nenhum elemento maior, o complemento bit a bit de Count.

Exceções

InvalidOperationException

comparer é null, e o comparador Default padrão não consegue encontrar uma implementação da IComparable<T> interface genérica ou da interface para o IComparable tipo T.

Exemplos

O exemplo a seguir demonstra a sobrecarga do Sort(IComparer<T>) método e a sobrecarga do BinarySearch(T, IComparer<T>) método.

O exemplo define um comparador alternativo para cadeias de caracteres denominadas DinoCompare, que implementa a IComparer<string> interface genérica (IComparer(Of String) no Visual Basic). O comparador funciona da seguinte maneira: primeiro, os comparands são testados nulle uma referência nula é tratada como menor que um não nulo. Em segundo lugar, os comprimentos da cadeia de caracteres são comparados e a cadeia de caracteres mais longa é considerada maior. Terceiro, se os comprimentos forem iguais, será usada uma comparação de cadeia de caracteres comum.

Uma List<T> das cadeias de caracteres é criada e preenchida com quatro cadeias de caracteres, em nenhuma ordem específica. A lista é exibida, classificada usando o comparador alternativo e exibida novamente.

A BinarySearch(T, IComparer<T>) sobrecarga do método é usada para pesquisar várias cadeias de caracteres que não estão na lista, empregando o comparador alternativo. O Insert método é usado para inserir as cadeias de caracteres. Esses dois métodos estão localizados na função nomeada SearchAndInsert, juntamente com o código para usar o complemento bit a bit (o operador ~ em C#, Xor -1 no Visual Basic) do número negativo retornado e BinarySearch(T, IComparer<T>) usá-lo como um índice para inserir a nova cadeia de caracteres.

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

Comentários

O comparador personaliza como os elementos são comparados. Por exemplo, você pode usar uma CaseInsensitiveComparer instância como o comparador para executar pesquisas de cadeia de caracteres que não diferenciam maiúsculas de minúsculas.

Se comparer for fornecido, os elementos serão List<T> comparados com o valor especificado usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verificará se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default gerará InvalidOperationException.

O List<T> valor já deve ser classificado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera uma exceção ao usar a IComparable<T> interface genérica. Ao classificar, null é considerado menor que qualquer outro objeto.

Se o List<T> elemento contiver mais de um com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> valor especificado não contiver, o método retornará um inteiro negativo. Você pode aplicar a operação de complemento bit a bit (~) a esse inteiro negativo para obter o índice do primeiro elemento maior que o valor de pesquisa. Ao inserir o valor no List<T>índice, esse índice deve ser usado como o ponto de inserção para manter a ordem de classificação.

Esse método é uma operação O(log n), em que n é o número de elementos no intervalo.

Confira também

• Executando operações de cadeia de caracteres Culture-Insensitive em coleções

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

Origem:

List.cs

Pesquisa um intervalo de elementos na classificação List<T> de um elemento usando o comparador especificado e retorna o índice baseado em zero do elemento.

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

Parâmetros

index

Int32

O índice inicial baseado em zero do intervalo a ser pesquisado.

count

Int32

O comprimento do intervalo a ser pesquisado.

item

T

O objeto a ser localizado. O valor pode ser null para tipos de referência.

comparer

IComparer<T>

A IComparer<T> implementação a ser usada ao comparar elementos ou null usar o comparador Defaultpadrão.

Retornos

Int32

O índice item baseado em zero no classificado List<T>, se item for encontrado; caso contrário, um número negativo que é o complemento bit a bit do índice do próximo elemento maior que item ou, se não houver nenhum elemento maior, o complemento bit a bit de Count.

Exceções

ArgumentOutOfRangeException

index é menor que 0.

- ou -

count é menor que 0.

ArgumentException

index e count não denotar um intervalo válido no List<T>.

InvalidOperationException

comparer é null, e o comparador Default padrão não consegue encontrar uma implementação da IComparable<T> interface genérica ou da interface para o IComparable tipo T.

Exemplos

O exemplo a seguir demonstra a sobrecarga do Sort(Int32, Int32, IComparer<T>) método e a sobrecarga do BinarySearch(Int32, Int32, T, IComparer<T>) método.

O exemplo define um comparador alternativo para cadeias de caracteres denominadas DinoCompare, que implementa a IComparer<string> interface genérica (IComparer(Of String) no Visual Basic). O comparador funciona da seguinte maneira: primeiro, os comparands são testados nulle uma referência nula é tratada como menor que um não nulo. Em segundo lugar, os comprimentos da cadeia de caracteres são comparados e a cadeia de caracteres mais longa é considerada maior. Terceiro, se os comprimentos forem iguais, será usada uma comparação de cadeia de caracteres comum.

Uma List<T> das cadeias de caracteres é criada e populada com os nomes de cinco dinossauros herbívoros e três dinossauros carnívoros. Em cada um dos dois grupos, os nomes não estão em nenhuma ordem de classificação específica. A lista é exibida, o intervalo de herbívoros é classificado usando o comparador alternativo e a lista é exibida novamente.

Em BinarySearch(Int32, Int32, T, IComparer<T>) seguida, a sobrecarga do método é usada para pesquisar apenas o intervalo de herbívoros por "Brachiosaurus". A cadeia de caracteres não foi encontrada e o complemento bit a bit (o operador ~ em C#, Xor -1 no Visual Basic) do número negativo retornado pelo BinarySearch(Int32, Int32, T, IComparer<T>) método é usado como um índice para inserir a nova cadeia de caracteres.

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

Comentários

O comparador personaliza como os elementos são comparados. Por exemplo, você pode usar uma CaseInsensitiveComparer instância como o comparador para executar pesquisas de cadeia de caracteres que não diferenciam maiúsculas de minúsculas.

Se comparer for fornecido, os elementos serão List<T> comparados com o valor especificado usando a implementação especificada IComparer<T> .

Se comparer for null, o comparador Comparer<T>.Default padrão verificará se o tipo T implementa a IComparable<T> interface genérica e usa essa implementação, se disponível. Caso contrário, Comparer<T>.Default verifica se o tipo T implementa a IComparable interface. Se o tipo T não implementar nenhuma das interfaces, Comparer<T>.Default gerará InvalidOperationException.

O List<T> valor já deve ser classificado de acordo com a implementação do comparador; caso contrário, o resultado está incorreto.

A comparação null com qualquer tipo de referência é permitida e não gera uma exceção ao usar a IComparable<T> interface genérica. Ao classificar, null é considerado menor que qualquer outro objeto.

Se o List<T> elemento contiver mais de um com o mesmo valor, o método retornará apenas uma das ocorrências e poderá retornar qualquer uma das ocorrências, não necessariamente a primeira.

Se o List<T> valor especificado não contiver, o método retornará um inteiro negativo. Você pode aplicar a operação de complemento bit a bit (~) a esse inteiro negativo para obter o índice do primeiro elemento maior que o valor de pesquisa. Ao inserir o valor no List<T>índice, esse índice deve ser usado como o ponto de inserção para manter a ordem de classificação.

Esse método é uma operação O(log n), em que n é o número de elementos no intervalo.

Confira também

• IComparer<T>
• IComparable<T>
• Executando operações de cadeia de caracteres Culture-Insensitive em coleções