List<T>.BinarySearch Метод

Определение

Пространство имен:

System.Collections.Generic

Сборка:

System.Collections.dll

Использует алгоритм двоичного поиска для нахождения определенного элемента в отсортированном списке List<T> или в его части.

Перегрузки

BinarySearch(T)	Выполняет поиск элемента по всему отсортированному списку List<T>, используя компаратор по умолчанию, и возвращает индекс элемента, отсчитываемый от нуля.
BinarySearch(T, IComparer<T>)	Выполняет поиск элемента по всему отсортированному списку List<T>, используя указанный компаратор, и возвращает индекс элемента, отсчитываемый от нуля.
BinarySearch(Int32, Int32, T, IComparer<T>)	Выполняет поиск элемента в диапазоне элементов отсортированного списка List<T>, используя указанную функцию сравнения, и возвращает индекс элемента, отсчитываемый от нуля.

BinarySearch(T)

Исходный код:

List.cs

Выполняет поиск элемента по всему отсортированному списку List<T>, используя компаратор по умолчанию, и возвращает индекс элемента, отсчитываемый от нуля.

C#

public int BinarySearch (T item);

Параметры

item

T

Искомый объект. Для ссылочных типов допускается значение null.

Возвращаемое значение

Int32

Отсчитываемый от нуля индекс элемента item в отсортированном списке List<T>, если элемент item найден; в противном случае — отрицательное число, которое является поразрядным дополнением индекса следующего элемента, большего, чем item, или, если большего элемента не существует, поразрядным дополнением значения Count.

Исключения

InvalidOperationException

Функция сравнения по умолчанию Default не может найти реализацию универсального интерфейса IComparable<T> или интерфейса IComparable для типа T.

Примеры

В следующем примере показана перегрузка Sort() метода и перегрузка BinarySearch(T) метода . Строка List<T> из строк создается и заполняется четырьмя строками без определенного порядка. Список отображается, сортируется и отображается снова.

Перегрузка BinarySearch(T) метода затем используется для поиска двух строк, которых нет в списке Insert , и метод используется для их вставки. Возвращаемое значение метода является отрицательным BinarySearch(T) в каждом случае, так как строки отсутствуют в списке. При побитовом дополнении (оператор ~в C# и Visual C++, Xor -1 в Visual Basic) этого отрицательного числа создается индекс первого элемента в списке, который больше строки поиска, и при вставке в этом расположении сохраняется порядок сортировки. Вторая строка поиска больше, чем любой элемент в списке, поэтому позиция вставки находится в конце списка.

C#

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
*/

Комментарии

Этот метод использует средство сравнения Comparer<T>.Default по умолчанию для типа T для определения порядка элементов списка. Свойство Comparer<T>.Default проверяет, реализует ли тип T универсальный IComparable<T> интерфейс, и использует ли он, если он доступен. В противном случае проверяет, Comparer<T>.Default реализует IComparable ли тип T интерфейс . Если тип T не реализует ни один из интерфейсов, Comparer<T>.Default вызывает исключение InvalidOperationException.

Объект List<T> уже должен быть отсортирован в соответствии с реализацией средства сравнения; в противном случае результат будет неверным.

Сравнение null с любым ссылочным типом разрешено и не создает исключение при использовании универсального IComparable<T> интерфейса. При сортировке считается меньше, null чем любой другой объект.

List<T> Если содержит несколько элементов с одинаковым значением, метод возвращает только одно из вхождений и может возвращать любое из вхождений, не обязательно первое.

List<T> Если не содержит указанного значения, метод возвращает отрицательное целое число. Операцию побитового дополнения (~) можно применить к этому отрицательному целому значению, чтобы получить индекс первого элемента, который больше значения поиска. При вставке значения в List<T>этот индекс следует использовать в качестве точки вставки для поддержания порядка сортировки.

Этот метод представляет собой операцию O(log n), где n — количество элементов в диапазоне.

См. также раздел

• Выполнение строковых операций без учета языка и региональных параметров в коллекциях

BinarySearch(T, IComparer<T>)

Исходный код:

List.cs

Выполняет поиск элемента по всему отсортированному списку List<T>, используя указанный компаратор, и возвращает индекс элемента, отсчитываемый от нуля.

C#

public int BinarySearch (T item, System.Collections.Generic.IComparer<T>? comparer);

Параметры

item

T

Искомый объект. Для ссылочных типов допускается значение null.

comparer

IComparer<T>

Реализация интерфейса IComparer<T>, которая используется при сравнении элементов.

-или-

null, если необходимо использовать функцию сравнения по умолчанию Default.

Возвращаемое значение

Int32

Отсчитываемый от нуля индекс элемента item в отсортированном списке List<T>, если элемент item найден; в противном случае — отрицательное число, которое является поразрядным дополнением индекса следующего элемента, большего, чем item, или, если большего элемента не существует, поразрядным дополнением значения Count.

Исключения

InvalidOperationException

comparer имеет значение null, а функция сравнения по умолчанию Default не может найти реализацию универсального интерфейса IComparable<T> или интерфейса IComparable для типа T.

Примеры

В следующем примере показана перегрузка Sort(IComparer<T>) метода и перегрузка BinarySearch(T, IComparer<T>) метода .

В примере определяется альтернативный компаратор для строк с именем DinoCompare, который реализует универсальный IComparer<string> интерфейс (IComparer(Of String) в Visual Basic IComparer<String^> в Visual C++). Функция сравнения работает следующим образом: во-первых, методы сравнения проверяются для null, а пустая ссылка обрабатывается как меньше, чем значение, отличное от NULL. Во-вторых, сравниваются длины строк, а длинная строка считается большей. В-третьих, если длина равна, используется обычное сравнение строк.

Строка List<T> из строк создается и заполняется четырьмя строками без определенного порядка. Список отображается, сортируется с помощью альтернативного компаратора и отображается снова.

Перегрузка BinarySearch(T, IComparer<T>) метода затем используется для поиска нескольких строк, которых нет в списке, используя альтернативный компаратор. Метод Insert используется для вставки строк. Эти два метода находятся в функции с именем SearchAndInsert, а также в коде для получения побитового дополнения (оператор ~ в C# и Visual C++, Xor -1 в Visual Basic) отрицательного числа, возвращаемого BinarySearch(T, IComparer<T>) , и использования его в качестве индекса для вставки новой строки.

C#

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
 */

Комментарии

Средство сравнения настраивает способ сравнения элементов. Например, можно использовать CaseInsensitiveComparer экземпляр в качестве компаратора для поиска строк без учета регистра.

Если comparer задано значение , элементы List<T> объекта сравниваются с указанным значением с использованием указанной IComparer<T> реализации.

Если comparer имеет значение null, средство сравнения Comparer<T>.Default по умолчанию проверяет, реализует ли тип T универсальный IComparable<T> интерфейс, и использует ли он, если он доступен. В противном случае проверяет, Comparer<T>.Default реализует IComparable ли тип T интерфейс . Если тип T не реализует ни один из интерфейсов, Comparer<T>.Default вызывает исключение InvalidOperationException.

Объект List<T> уже должен быть отсортирован в соответствии с реализацией средства сравнения; в противном случае результат будет неверным.

Сравнение null с любым ссылочным типом разрешено и не создает исключение при использовании универсального IComparable<T> интерфейса. При сортировке считается меньше, null чем любой другой объект.

List<T> Если содержит несколько элементов с одинаковым значением, метод возвращает только одно из вхождений и может возвращать любое из вхождений, не обязательно первое.

List<T> Если не содержит указанного значения, метод возвращает отрицательное целое число. Операцию побитового дополнения (~) можно применить к этому отрицательному целому значению, чтобы получить индекс первого элемента, который больше значения поиска. При вставке значения в List<T>этот индекс следует использовать в качестве точки вставки для поддержания порядка сортировки.

Этот метод представляет собой операцию O(log n), где n — количество элементов в диапазоне.

См. также раздел

• Выполнение строковых операций без учета языка и региональных параметров в коллекциях

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

Исходный код:

List.cs

Выполняет поиск элемента в диапазоне элементов отсортированного списка List<T>, используя указанную функцию сравнения, и возвращает индекс элемента, отсчитываемый от нуля.

C#

public int BinarySearch (int index, int count, T item, System.Collections.Generic.IComparer<T>? comparer);

Параметры

index

Int32

Отсчитываемый от нуля индекс начала диапазона поиска.

count

Int32

Длина диапазона поиска.

item

T

Искомый объект. Для ссылочных типов допускается значение null.

comparer

IComparer<T>

Реализация IComparer<T>, которую следует использовать при сравнении элементов, или null, если должна использоваться функция сравнения по умолчанию Default.

Возвращаемое значение

Int32

Отсчитываемый от нуля индекс элемента item в отсортированном списке List<T>, если элемент item найден; в противном случае — отрицательное число, которое является поразрядным дополнением индекса следующего элемента, большего, чем item, или, если большего элемента не существует, поразрядным дополнением значения Count.

Исключения

ArgumentOutOfRangeException

Значение параметраindex меньше 0.

-или-

Значение параметраcount меньше 0.

ArgumentException

Параметры index и count не указывают допустимый диапазон в List<T>.

InvalidOperationException

comparer имеет значение null, а функция сравнения по умолчанию Default не может найти реализацию универсального интерфейса IComparable<T> или интерфейса IComparable для типа T.

Примеры

В следующем примере показана перегрузка Sort(Int32, Int32, IComparer<T>) метода и перегрузка BinarySearch(Int32, Int32, T, IComparer<T>) метода .

В примере определяется альтернативный компаратор для строк с именем DinoCompare, который реализует универсальный IComparer<string> интерфейс (IComparer(Of String) в Visual Basic IComparer<String^> в Visual C++). Функция сравнения работает следующим образом: во-первых, методы сравнения проверяются для null, а пустая ссылка обрабатывается как меньше, чем значение, отличное от NULL. Во-вторых, сравниваются длины строк, а длинная строка считается большей. В-третьих, если длина равна, используется обычное сравнение строк.

Строка List<T> создается и заполняется именами пяти травоядных динозавров и трех плотоядных динозавров. В каждой из двух групп имена не находятся в определенном порядке сортировки. Отображается список, диапазон травоядных сортируется с помощью альтернативного компаратора, и список отображается снова.

Затем перегрузка BinarySearch(Int32, Int32, T, IComparer<T>) метода используется для поиска "Brachiosaurus" только в диапазоне травоядных животных. Строка не найдена, а побитовое дополнение (оператор ~ в C# и Visual C++, Xor -1 в Visual Basic) отрицательного числа, возвращаемого методом BinarySearch(Int32, Int32, T, IComparer<T>) , используется в качестве индекса для вставки новой строки.

C#

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
 */

Комментарии

Средство сравнения настраивает способ сравнения элементов. Например, можно использовать CaseInsensitiveComparer экземпляр в качестве компаратора для поиска строк без учета регистра.

Если comparer задано значение , элементы List<T> объекта сравниваются с указанным значением с использованием указанной IComparer<T> реализации.

Если comparer имеет значение null, средство сравнения Comparer<T>.Default по умолчанию проверяет, реализует ли тип T универсальный IComparable<T> интерфейс, и использует ли он, если он доступен. В противном случае проверяет, Comparer<T>.Default реализует IComparable ли тип T интерфейс . Если тип T не реализует ни один из интерфейсов, Comparer<T>.Default вызывает исключение InvalidOperationException.

Объект List<T> уже должен быть отсортирован в соответствии с реализацией средства сравнения; в противном случае результат будет неверным.

Сравнение null с любым ссылочным типом разрешено и не создает исключение при использовании универсального IComparable<T> интерфейса. При сортировке считается меньше, null чем любой другой объект.

List<T> Если содержит несколько элементов с одинаковым значением, метод возвращает только одно из вхождений и может возвращать любое из вхождений, не обязательно первое.

List<T> Если не содержит указанного значения, метод возвращает отрицательное целое число. Операцию побитового дополнения (~) можно применить к этому отрицательному целому значению, чтобы получить индекс первого элемента, который больше значения поиска. При вставке значения в List<T>этот индекс следует использовать в качестве точки вставки для поддержания порядка сортировки.

Этот метод представляет собой операцию O(log n), где n — количество элементов в диапазоне.

См. также раздел

• IComparer<T>
• IComparable<T>
• Выполнение строковых операций без учета языка и региональных параметров в коллекциях