Array.BinarySearch Metod

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
 static int BinarySearch(Array ^ array, System::Object ^ value);

public static int BinarySearch(Array array, object value);

public static int BinarySearch(Array array, object? value);

static member BinarySearch : Array * obj -> int

Public Shared Function BinarySearch (array As Array, value As Object) As Integer

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Exempel

I följande kodexempel visas hur du använder BinarySearch för att hitta ett specifikt objekt i en Array.

open System

let printValues (myArray: Array) =
    let mutable i = 0
    let cols = myArray.GetLength(myArray.Rank - 1)
    for item in myArray do
        if i < cols then
            i <- i + 1
        else
            printfn ""
            i <- 1;
        printf $"\t{item}"
    printfn ""

let findMyObject (myArr: Array) (myObject: obj) =
    let myIndex = Array.BinarySearch(myArr, myObject)
    if myIndex < 0 then
        printfn $"The object to search for ({myObject}) is not found. The next larger object is at index {~~~myIndex}."
    else
        printfn $"The object to search for ({myObject}) is at index {myIndex}."

// Creates and initializes a new Array.
let myIntArray = [| 8; 2; 6; 3; 7 |]

// Do the required sort first
Array.Sort myIntArray

// Displays the values of the Array.
printfn "The int array contains the following:"
printValues myIntArray

// Locates a specific object that does not exist in the Array.
let myObjectOdd: obj = 1
findMyObject myIntArray myObjectOdd 

// Locates an object that exists in the Array.
let myObjectEven: obj = 6
findMyObject myIntArray myObjectEven
       
// This code produces the following output:
//     The int array contains the following:
//             2       3       6       7       8
//     The object to search for (1) is not found. The next larger object is at index 0.
//     The object to search for (6) is at index 2.

using System;

public class SamplesArray
{
    public static void Main()
    {
        // Creates and initializes a new Array.
        Array myIntArray = Array.CreateInstance(typeof(int), 5);

        myIntArray.SetValue(8, 0);
        myIntArray.SetValue(2, 1);
        myIntArray.SetValue(6, 2);
        myIntArray.SetValue(3, 3);
        myIntArray.SetValue(7, 4);

        // Do the required sort first
        Array.Sort(myIntArray);

        // Displays the values of the Array.
        Console.WriteLine( "The int array contains the following:" );
        PrintValues(myIntArray);

        // Locates a specific object that does not exist in the Array.
        object myObjectOdd = 1;
        FindMyObject( myIntArray, myObjectOdd );

        // Locates an object that exists in the Array.
        object myObjectEven = 6;
        FindMyObject(myIntArray, myObjectEven);
    }

    public static void FindMyObject(Array myArr, object myObject)
    {
        int myIndex=Array.BinarySearch(myArr, myObject);
        if (myIndex < 0)
        {
            Console.WriteLine("The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, ~myIndex );
        }
        else
        {
            Console.WriteLine("The object to search for ({0}) is at index {1}.", myObject, myIndex );
        }
    }

    public static void PrintValues(Array myArr)
    {
        int i = 0;
        int cols = myArr.GetLength(myArr.Rank - 1);
        foreach (object o in myArr)
        {
            if ( i < cols )
            {
                i++;
            }
            else
            {
                Console.WriteLine();
                i = 1;
            }
            Console.Write( "\t{0}", o);
        }
        Console.WriteLine();
    }
}
// This code produces the following output.
//
//The int array contains the following:
//        2       3       6       7       8
//The object to search for (1) is not found. The next larger object is at index 0
//
//The object to search for (6) is at index 2.

Public Class SamplesArray
    Public Shared Sub Main()
        ' Creates and initializes a new Array.
        Dim myIntArray As Array = Array.CreateInstance( GetType(Int32), 5 )

        myIntArray.SetValue( 8, 0 )
        myIntArray.SetValue( 2, 1 )
        myIntArray.SetValue( 6, 2 )
        myIntArray.SetValue( 3, 3 )
        myIntArray.SetValue( 7, 4 )

        ' Do the required sort first
        Array.Sort(myIntArray)

        ' Displays the values of the Array.
        Console.WriteLine("The Int32 array contains the following:")
        PrintValues(myIntArray)

        ' Locates a specific object that does not exist in the Array.
        Dim myObjectOdd As Object = 1
        FindMyObject(myIntArray, myObjectOdd)

        ' Locates an object that exists in the Array.
        Dim myObjectEven As Object = 6
        FindMyObject(myIntArray, myObjectEven)
    End Sub

    Public Shared Sub FindMyObject(myArr As Array, myObject As Object)
        Dim myIndex As Integer = Array.BinarySearch(myArr, myObject)
        If  myIndex < 0 Then
            Console.WriteLine("The object to search for ({0}) is not found. The next larger object is at index {1}.", myObject, Not(myIndex))
        Else
            Console.WriteLine("The object to search for ({0}) is at index {1}.", myObject, myIndex)
        End If
    End Sub

    Public Shared Sub PrintValues(myArr As Array)
        Dim i As Integer = 0
        Dim cols As Integer = myArr.GetLength( myArr.Rank - 1 )
        For Each o As Object In myArr
            If i < cols Then
                i += 1
            Else
                Console.WriteLine()
                i = 1
            End If
            Console.Write( vbTab + "{0}", o)
        Next o
        Console.WriteLine()
    End Sub
End Class
' This code produces the following output.
'
' The Int32 array contains the following:
'         2       3       6       7       8
' The object to search for (1) is not found. The next larger object is at index 0
'
' The object to search for (6) is at index 2.

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om inte Array innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är ett större än matrisens övre gräns finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Antingen value eller varje element array i måste implementera IComparable gränssnittet, som används för jämförelser. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är för Lengtharray.

Se även

• IComparable
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
 static int BinarySearch(Array ^ array, System::Object ^ value, System::Collections::IComparer ^ comparer);

public static int BinarySearch(Array array, object value, System.Collections.IComparer comparer);

public static int BinarySearch(Array array, object? value, System.Collections.IComparer? comparer);

static member BinarySearch : Array * obj * System.Collections.IComparer -> int

Public Shared Function BinarySearch (array As Array, value As Object, comparer As IComparer) As Integer

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om inte Array innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är ett större än matrisens övre gräns finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en System.Collections.CaseInsensitiveComparer som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer inte nulljämförs elementen array i med det angivna värdet med den angivna IComparer implementeringen. Elementen array i måste redan sorteras i ökande värde enligt sorteringsordningen som definieras av comparer. Annars kan resultatet vara felaktigt.

Omcomparer är nullgörs jämförelsen med hjälp av implementeringen IComparable som tillhandahålls av själva elementet eller av det angivna värdet. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är för Lengtharray.

Se även

• IComparer
• IComparable
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
 static int BinarySearch(Array ^ array, int index, int length, System::Object ^ value);

public static int BinarySearch(Array array, int index, int length, object value);

public static int BinarySearch(Array array, int index, int length, object? value);

static member BinarySearch : Array * int * int * obj -> int

Public Shared Function BinarySearch (array As Array, index As Integer, length As Integer, value As Object) As Integer

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om inte Array innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är ett större än matrisens övre gräns finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Antingen value eller varje element array i måste implementera IComparable gränssnittet, som används för jämförelser. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är length.

Se även

• IComparable
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
 static int BinarySearch(Array ^ array, int index, int length, System::Object ^ value, System::Collections::IComparer ^ comparer);

public static int BinarySearch(Array array, int index, int length, object value, System.Collections.IComparer comparer);

public static int BinarySearch(Array array, int index, int length, object? value, System.Collections.IComparer? comparer);

static member BinarySearch : Array * int * int * obj * System.Collections.IComparer -> int

Public Shared Function BinarySearch (array As Array, index As Integer, length As Integer, value As Object, comparer As IComparer) As Integer

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om inte Array innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är ett större än matrisens övre gräns finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en System.Collections.CaseInsensitiveComparer som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer inte nulljämförs elementen array i med det angivna värdet med den angivna IComparer implementeringen. Elementen array i måste redan sorteras i ökande värde enligt sorteringsordningen som definieras av comparer. Annars kan resultatet vara felaktigt.

Om comparer är nullgörs jämförelsen med hjälp av implementeringen IComparable som tillhandahålls av själva elementet eller av det angivna värdet. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag när du använder IComparable.

Den här metoden är en O(log n)-åtgärd, där n är length.

Se även

• IComparer
• IComparable
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, T value);

public static int BinarySearch<T>(T[] array, T value);

static member BinarySearch : 'T[] * 'T -> int

Public Shared Function BinarySearch(Of T) (array As T(), value As T) As Integer

Typparametrar

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Exempel

I följande kodexempel visas den Sort<T>(T[]) generiska metodöverlagringen och den generiska metodöverlagringen BinarySearch<T>(T[], T) . En matris med strängar skapas, utan någon särskild ordning.

Matrisen visas, sorteras och visas igen. Matriser måste sorteras för att kunna använda BinarySearch metoden.

Den BinarySearch<T>(T[], T) generiska metodöverlagringen används sedan för att söka efter två strängar, en som inte finns i matrisen och en som är. Matrisen och returvärdet BinarySearch för metoden skickas till den ShowWhere generiska metoden ( showWhere funktionen i F#-exemplet), som visar indexvärdet om strängen hittas, och annars skulle elementen söksträngen falla mellan om den fanns i matrisen. Indexet är negativt om strängen inte finns i matrisen, så metoden ShowWhere tar bitvis komplementet (~-operatorn i C#, ~~~-operatorn i F#, Xor-1 i Visual Basic) för att hämta indexet för det första elementet i listan som är större än söksträngen.

using System;
using System.Collections.Generic;

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus",
                              "Amargasaurus",
                              "Tyrannosaurus",
                              "Mamenchisaurus",
                              "Deinonychus",
                              "Edmontosaurus"};

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

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

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis");
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus");
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Amargasaurus
Deinonychus
Edmontosaurus
Mamenchisaurus
Pachycephalosaurus
Tyrannosaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Amargasaurus and Deinonychus.

BinarySearch for 'Tyrannosaurus':
Found at index 5.
 */

open System

let showWhere (array: 'a []) index =
    if index < 0 then
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        let index = ~~~index

        printf "Not found. Sorts between: "

        if index = 0 then
            printf "beginning of array and "
        else
            printf $"{array[index - 1]} and "

        if index = array.Length then
            printfn "end of array."
        else
            printfn $"{array[index]}."
    else
        printfn $"Found at index {index}."

let dinosaurs =
    [| "Pachycephalosaurus"
       "Amargasaurus"
       "Tyrannosaurus"
       "Mamenchisaurus"
       "Deinonychus"
       "Edmontosaurus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nSort"
Array.Sort dinosaurs

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nBinarySearch for 'Coelophysis':"
let index = Array.BinarySearch(dinosaurs, "Coelophysis")
showWhere dinosaurs index

printfn "\nBinarySearch for 'Tyrannosaurus':"
Array.BinarySearch(dinosaurs, "Tyrannosaurus")
|> showWhere dinosaurs


// This code example produces the following output:
//
//     Pachycephalosaurus
//     Amargasaurus
//     Tyrannosaurus
//     Mamenchisaurus
//     Deinonychus
//     Edmontosaurus
//
//     Sort
//
//     Amargasaurus
//     Deinonychus
//     Edmontosaurus
//     Mamenchisaurus
//     Pachycephalosaurus
//     Tyrannosaurus
//
//     BinarySearch for 'Coelophysis':
//     Not found. Sorts between: Amargasaurus and Deinonychus.
//
//     BinarySearch for 'Tyrannosaurus':
//     Found at index 5.

Imports System.Collections.Generic

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

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

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

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

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis")
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus")
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Amargasaurus
'Deinonychus
'Edmontosaurus
'Mamenchisaurus
'Pachycephalosaurus
'Tyrannosaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Amargasaurus and Deinonychus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 5.

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om array inte innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är lika med matrisens storlek finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

T måste implementera det IComparable<T> allmänna gränssnittet, som används för jämförelser. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable<T> . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är för Lengtharray.

Se även

• IComparable<T>
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, T value, System::Collections::Generic::IComparer<T> ^ comparer);

public static int BinarySearch<T>(T[] array, T value, System.Collections.Generic.IComparer<T> comparer);

public static int BinarySearch<T>(T[] array, T value, System.Collections.Generic.IComparer<T>? comparer);

static member BinarySearch : 'T[] * 'T * System.Collections.Generic.IComparer<'T> -> int

Public Shared Function BinarySearch(Of T) (array As T(), value As T, comparer As IComparer(Of T)) As Integer

Typparametrar

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Exempel

I följande exempel visas den Sort<T>(T[], IComparer<T>) generiska metodöverlagringen och den generiska metodöverlagringen BinarySearch<T>(T[], T, IComparer<T>) .

Kodexemplet definierar en alternativ jämförelse för strängar med namnet ReverseCompare, som implementerar det allmänna gränssnittet IComparer<string> (IComparer(Of String) i Visual Basic). Jämförelsen anropar CompareTo(String) metoden och återställer ordningen på comparands så att strängarna sorteras högt till lågt i stället för låg till hög.

Matrisen visas, sorteras och visas igen. Matriser måste sorteras för att kunna använda BinarySearch metoden.

Den BinarySearch<T>(T[], T, IComparer<T>) generiska metodöverlagringen används sedan för att söka efter två strängar, en som inte finns i matrisen och en som är. Matrisen och returvärdet BinarySearch<T>(T[], T, IComparer<T>) för metoden skickas till den ShowWhere generiska metoden ( showWhere funktionen i F#-exemplet), som visar indexvärdet om strängen hittas, och annars skulle elementen söksträngen falla mellan om den fanns i matrisen. Indexet är negativt om strängen inte är n matrisen, så metoden ShowWhere tar bitvis komplement (~-operatorn i C#, ~~~-operatorn i F#, Xor -1 i Visual Basic) för att hämta indexet för det första elementet i listan som är större än söksträngen.

using System;
using System.Collections.Generic;

public class ReverseComparer: IComparer<string>
{
    public int Compare(string x, string y)
    {
        // Compare y and x in reverse order.
        return y.CompareTo(x);
    }
}

public class Example
{
    public static void Main()
    {
        string[] dinosaurs = {"Pachycephalosaurus",
                              "Amargasaurus",
                              "Tyrannosaurus",
                              "Mamenchisaurus",
                              "Deinonychus",
                              "Edmontosaurus"};

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

        ReverseComparer rc = new ReverseComparer();

        Console.WriteLine("\nSort");
        Array.Sort(dinosaurs, rc);

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

        Console.WriteLine("\nBinarySearch for 'Coelophysis':");
        int index = Array.BinarySearch(dinosaurs, "Coelophysis", rc);
        ShowWhere(dinosaurs, index);

        Console.WriteLine("\nBinarySearch for 'Tyrannosaurus':");
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc);
        ShowWhere(dinosaurs, index);
    }

    private static void ShowWhere<T>(T[] array, int index)
    {
        if (index<0)
        {
            // If the index is negative, it represents the bitwise
            // complement of the next larger element in the array.
            //
            index = ~index;

            Console.Write("Not found. Sorts between: ");

            if (index == 0)
                Console.Write("beginning of array and ");
            else
                Console.Write("{0} and ", array[index-1]);

            if (index == array.Length)
                Console.WriteLine("end of array.");
            else
                Console.WriteLine("{0}.", array[index]);
        }
        else
        {
            Console.WriteLine("Found at index {0}.", index);
        }
    }
}

/* This code example produces the following output:

Pachycephalosaurus
Amargasaurus
Tyrannosaurus
Mamenchisaurus
Deinonychus
Edmontosaurus

Sort

Tyrannosaurus
Pachycephalosaurus
Mamenchisaurus
Edmontosaurus
Deinonychus
Amargasaurus

BinarySearch for 'Coelophysis':
Not found. Sorts between: Deinonychus and Amargasaurus.

BinarySearch for 'Tyrannosaurus':
Found at index 0.
 */

open System
open System.Collections.Generic

type ReverseComparer() =
    interface IComparer<string> with
        member _.Compare(x, y) =
            // Compare y and x in reverse order.
            y.CompareTo x

let showWhere (array: 'a []) index =
    if index < 0 then
        // If the index is negative, it represents the bitwise
        // complement of the next larger element in the array.
        let index = ~~~index

        printf "Not found. Sorts between: "

        if index = 0 then
            printf "beginning of array and "
        else
            printf $"{array[index - 1]} and "

        if index = array.Length then
            printfn "end of array."
        else
            printfn $"{array[index]}."
    else
        printfn $"Found at index {index}."

let dinosaurs =
    [| "Pachycephalosaurus"
       "Amargasaurus"
       "Tyrannosaurus"
       "Mamenchisaurus"
       "Deinonychus"
       "Edmontosaurus" |]

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

let rc = ReverseComparer()

printfn "\nSort"
Array.Sort(dinosaurs, rc)

printfn ""
for dino in dinosaurs do
    printfn $"{dino}"

printfn "\nBinarySearch for 'Coelophysis':"
Array.BinarySearch(dinosaurs, "Coelophysis", rc)
|> showWhere dinosaurs

printfn "\nBinarySearch for 'Tyrannosaurus':"
Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
|> showWhere dinosaurs


// This code example produces the following output:
//     Pachycephalosaurus
//     Amargasaurus
//     Tyrannosaurus
//     Mamenchisaurus
//     Deinonychus
//     Edmontosaurus
//
//     Sort
//
//     Tyrannosaurus
//     Pachycephalosaurus
//     Mamenchisaurus
//     Edmontosaurus
//     Deinonychus
//     Amargasaurus
//
//     BinarySearch for 'Coelophysis':
//     Not found. Sorts between: Deinonychus and Amargasaurus.
//
//     BinarySearch for 'Tyrannosaurus':
//     Found at index 0.

Imports System.Collections.Generic

Public Class ReverseComparer
    Implements IComparer(Of String)

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

        ' Compare y and x in reverse order.
        Return y.CompareTo(x)

    End Function
End Class

Public Class Example

    Public Shared Sub Main()

        Dim dinosaurs() As String = { _
            "Pachycephalosaurus", _
            "Amargasaurus", _
            "Tyrannosaurus", _
            "Mamenchisaurus", _
            "Deinonychus", _
            "Edmontosaurus"  }

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

        Dim rc As New ReverseComparer()

        Console.WriteLine(vbLf & "Sort")
        Array.Sort(dinosaurs, rc)

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

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Coelophysis':")
        Dim index As Integer = _
            Array.BinarySearch(dinosaurs, "Coelophysis", rc)
        ShowWhere(dinosaurs, index)

        Console.WriteLine(vbLf & _
            "BinarySearch for 'Tyrannosaurus':")
        index = Array.BinarySearch(dinosaurs, "Tyrannosaurus", rc)
        ShowWhere(dinosaurs, index)

    End Sub

    Private Shared Sub ShowWhere(Of T) _
        (ByVal array() As T, ByVal index As Integer) 

        If index < 0 Then
            ' If the index is negative, it represents the bitwise
            ' complement of the next larger element in the array.
            '
            index = index Xor -1

            Console.Write("Not found. Sorts between: ")

            If index = 0 Then
                Console.Write("beginning of array and ")
            Else
                Console.Write("{0} and ", array(index - 1))
            End If 

            If index = array.Length Then
                Console.WriteLine("end of array.")
            Else
                Console.WriteLine("{0}.", array(index))
            End If 
        Else
            Console.WriteLine("Found at index {0}.", index)
        End If

    End Sub

End Class

' This code example produces the following output:
'
'Pachycephalosaurus
'Amargasaurus
'Tyrannosaurus
'Mamenchisaurus
'Deinonychus
'Edmontosaurus
'
'Sort
'
'Tyrannosaurus
'Pachycephalosaurus
'Mamenchisaurus
'Edmontosaurus
'Deinonychus
'Amargasaurus
'
'BinarySearch for 'Coelophysis':
'Not found. Sorts between: Deinonychus and Amargasaurus.
'
'BinarySearch for 'Tyrannosaurus':
'Found at index 0.

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om inte Array innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är lika med matrisens storlek finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en System.Collections.CaseInsensitiveComparer som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer inte nulljämförs elementen array i med det angivna värdet med den angivna IComparer<T> allmänna gränssnittsimplementeringen. Elementen array i måste redan sorteras i ökande värde enligt sorteringsordningen som definieras av comparer. Annars kan resultatet vara felaktigt.

Om comparer är nullgörs jämförelsen med den IComparable<T> allmänna gränssnittsimplementeringen som tillhandahålls av T. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable<T> . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är för Lengtharray.

Se även

• IComparer<T>
• IComparable<T>
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, int index, int length, T value);

public static int BinarySearch<T>(T[] array, int index, int length, T value);

static member BinarySearch : 'T[] * int * int * 'T -> int

Public Shared Function BinarySearch(Of T) (array As T(), index As Integer, length As Integer, value As T) As Integer

Typparametrar

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om matrisen inte innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är lika med matrisens storlek finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

T måste implementera det IComparable<T> allmänna gränssnittet, som används för jämförelser. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable<T> . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag.

Den här metoden är en O(log n)-åtgärd, där n är length.

Se även

• IComparable<T>
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

Källa:

Array.cs

public:
generic <typename T>
 static int BinarySearch(cli::array <T> ^ array, int index, int length, T value, System::Collections::Generic::IComparer<T> ^ comparer);

public static int BinarySearch<T>(T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T> comparer);

public static int BinarySearch<T>(T[] array, int index, int length, T value, System.Collections.Generic.IComparer<T>? comparer);

static member BinarySearch : 'T[] * int * int * 'T * System.Collections.Generic.IComparer<'T> -> int

Public Shared Function BinarySearch(Of T) (array As T(), index As Integer, length As Integer, value As T, comparer As IComparer(Of T)) As Integer

Typparametrar

Parametrar

Returer

Indexet för angivet value i angivet array, om value hittas, annars ett negativt tal. Om value inte hittas och value är mindre än ett eller flera element i arrayär det negativa talet som returneras bitvis komplementet till indexet för det första elementet som är större än value. Om value inte hittas och value är större än alla element i arrayär det negativa talet som returneras bitvis komplement (indexet för det sista elementet plus 1). Om den här metoden anropas med en icke-sorterad arraykan returvärdet vara felaktigt och ett negativt tal kan returneras, även om value det finns i array.

Undantag

Kommentarer

Den här metoden stöder inte sökning i matriser som innehåller negativa index. array måste sorteras innan den här metoden anropas.

Om matrisen inte innehåller det angivna värdet returnerar metoden ett negativt heltal. Du kan använda bitvis komplementoperator (~ i C#, Not i Visual Basic) på det negativa resultatet för att skapa ett index. Om det här indexet är lika med matrisens storlek finns det inga element som är större än value i matrisen. Annars är det indexet för det första elementet som är större än value.

Jämförelsen anpassar hur elementen jämförs. Du kan till exempel använda en System.Collections.CaseInsensitiveComparer som jämförelse för att utföra skiftlägesokänsliga strängsökningar.

Om comparer inte nulljämförs elementen array i med det angivna värdet med den angivna IComparer<T> allmänna gränssnittsimplementeringen. Elementen array i måste redan sorteras i ökande värde enligt sorteringsordningen som definieras av comparer. Annars kan resultatet vara felaktigt.

Om comparer är nullgörs jämförelsen med den IComparable<T> allmänna gränssnittsimplementeringen som tillhandahålls för typen T. Elementen array i måste redan sorteras i ökande värde enligt den sorteringsordning som definieras av implementeringen IComparable<T> . Annars kan resultatet vara felaktigt.

Duplicerade element tillåts. Array Om innehåller mer än ett element som är lika med valuereturnerar metoden indexet för endast en av förekomsterna och inte nödvändigtvis den första.

null kan alltid jämföras med andra referenstyper. Därför genererar jämförelser med null inte ett undantag när du använder IComparable<T>.

Den här metoden är en O(log n)-åtgärd, där n är length.

Se även

• IComparer<T>
• IComparable<T>
• Sort
• Utföra Culture-Insensitive strängåtgärder i matriser