Array.BinarySearch Metódus

Definíció

Névtér:: System

Szerelvények:: mscorlib.dll, System.Runtime.dll

Szerelvények:: netstandard.dll, System.Runtime.dll

Szerelvény:: System.Runtime.dll

Szerelvény:: mscorlib.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Egy egydimenziós keresés egy értékre rendezve Array bináris keresési algoritmus használatával.

Túlterhelések

Name	Description
BinarySearch(Array, Object)	Egy teljes egydimenziós rendezett tömbben keres egy adott elemet a IComparable tömb egyes elemei és a megadott objektum által implementált felület használatával.
BinarySearch(Array, Object, IComparer)	Egy teljes egydimenziós rendezett tömbben keres egy értéket a megadott IComparer felületen.
BinarySearch(Array, Int32, Int32, Object)	Egy egydimenziós rendezett tömb elemeinek tartományában keres értékeket a IComparable tömb egyes elemei és a megadott érték által implementált felület használatával.
BinarySearch(Array, Int32, Int32, Object, IComparer)	Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a megadott IComparer felülettel.
BinarySearch<T>(T[], T)	Egy teljes egydimenziós rendezett tömbben keres egy adott elemet a IComparable<T> megadott objektum egyes elemei Array által implementált általános felület használatával.
BinarySearch<T>(T[], T, IComparer<T>)	Egy teljes egydimenziós rendezett tömbben keres egy értéket a megadott IComparer<T> általános felülettel.
BinarySearch<T>(T[], Int32, Int32, T)	Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a IComparable<T> megadott érték minden eleme Array által implementált általános felülettel.
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>)	Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a megadott IComparer<T> általános felület használatával.

BinarySearch(Array, Object)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy teljes egydimenziós rendezett tömbben keres egy adott elemet a IComparable tömb egyes elemei és a megadott objektum által implementált felület használatával.

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

Paraméterek

array: Array

A keresendő egydimenziós Array rendezés.

value: Object

A keresendő objektum.

Válaszok

Int32

A megadott valuearrayérték indexe , ha value megtalálható, ellenkező esetben negatív szám. Ha value nem található, és value egy vagy több elemnél arraykisebb, akkor a visszaadott negatív szám az első elem indexének bitenkénti kiegészítése, amely nagyobb, mint value. Ha value nem található, és value nagyobb, mint az összes elem, arrayakkor a visszaadott negatív szám a bitenkénti kiegészítés (az utolsó elem indexe plusz 1). Ha ezt a metódust nem rendezéssel arrayhívjuk meg, akkor a visszatérési érték helytelen lehet, és negatív szám is visszaadható, még akkor is, ha value a függvényben arrayszerepel.

Kivételek

ArgumentNullException

array az null.

RankException

array többdimenziós.

ArgumentException

value olyan típusú, amely nem kompatibilis a következő elemekkel array: .

InvalidOperationException

value nem implementálja a IComparable felületet, és a keresés olyan elemet talál, amely nem implementálja az interfészt IComparable .

Példák

Az alábbi példakód bemutatja, BinarySearch hogyan kereshet meg egy adott objektumot egy Arrayadott helyen.

Note

A tömb az elemeivel növekvő rendezési sorrendben jön létre. A BinarySearch metódus megköveteli, hogy a tömb növekvő sorrendben legyen rendezve.

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.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha a Array metódus nem tartalmazza a megadott értéket, a metódus negatív egész számot ad vissza. A negatív eredményre alkalmazhatja a bitenkénti komplementer operátort (~ C#-ban, Not Visual Basic) a negatív eredményre, hogy indexet állítson elő. Ha ez az index nagyobb, mint a tömb felső határa, nincsenek nagyobb elemek, mint value a tömbben. Ellenkező esetben az első elem indexe nagyobb, mint value.

Vagy value az összes elemnek implementálnia array kell az IComparable illesztőt, amelyet összehasonlításhoz használnak. Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Note

Havalue nem implementálja az IComparable interfészt, a rendszer nem teszteli arrayIComparable az elemeket a keresés megkezdése előtt. Kivétel akkor történik, ha a keresés olyan elemet talál, amely nem implementálható IComparable.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Minden tesztelt value elem esetében a rendszer átadja a megfelelő IComparable implementációnak, még akkor is, ha value az .null Vagyis az IComparable implementáció határozza meg, hogy egy adott elem hogyan viszonyul hozzá null.

Ez a metódus egy O(log n) művelet, ahol n a Length következő array: .

Lásd még

A következőre érvényes:

BinarySearch(Array, Object, IComparer)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy teljes egydimenziós rendezett tömbben keres egy értéket a megadott IComparer felületen.

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

Paraméterek

array: Array

A keresendő egydimenziós Array rendezés.

value: Object

A keresendő objektum.

comparer: IComparer

Az IComparer elemek összehasonlítása során használandó implementáció.

-vagy-

null az egyes elemek implementálásának használatához IComparable .

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

RankException

array többdimenziós.

ArgumentException

comparer az null, és value olyan típusú, amely nem kompatibilis a következő arrayelemeivel: .

InvalidOperationException

comparer is null, value nem implementálja az IComparable interfészt, és a keresés olyan elemet talál, amely nem implementálja a IComparable felületet.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

A összehasonlító testre szabja az elemek összehasonlításának módját. A kis- és nagybetűket érzéketlen sztringkeresésekhez például összehasonlítóként is használhatja System.Collections.CaseInsensitiveComparer .

Ha comparer nem null, akkor a rendszer a megadott értékhez hasonlítja az elemeket array a megadott IComparer implementációval. Az elemeket array már növekvő értékben kell rendezni a megadott comparerrendezési sorrend szerint; ellenkező esetben az eredmény helytelen lehet.

Hacomparer igen null, az összehasonlítás az IComparable elem vagy a megadott érték által biztosított implementációval történik. Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Note

Ha comparer van, null és value nem implementálja az IComparable interfészt, a rendszer nem teszteli arrayIComparable az elemeket a keresés megkezdése előtt. Kivétel akkor történik, ha a keresés olyan elemet talál, amely nem implementálható IComparable.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Ez a metódus egy O(log n) művelet, ahol n a Length következő array: .

Lásd még

A következőre érvényes:

BinarySearch(Array, Int32, Int32, Object)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy egydimenziós rendezett tömb elemeinek tartományában keres értékeket a IComparable tömb egyes elemei és a megadott érték által implementált felület használatával.

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

Paraméterek

array: Array

A keresendő egydimenziós Array rendezés.

index: Int32

A keresendő tartomány kezdő indexe.

length: Int32

A keresendő tartomány hossza.

value: Object

A keresendő objektum.

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

RankException

array többdimenziós.

ArgumentOutOfRangeException

index kisebb, mint a array.

-vagy-

length kisebb, mint nulla.

ArgumentException

index és length ne adjon meg érvényes tartományt a következőben: array.

-vagy-

value olyan típusú, amely nem kompatibilis a következő elemekkel array: .

InvalidOperationException

value nem implementálja a IComparable felületet, és a keresés olyan elemet talál, amely nem implementálja az interfészt IComparable .

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Note

Ha value nem implementálja az IComparable interfészt, a rendszer nem teszteli arrayIComparable az elemeket a keresés megkezdése előtt. Kivétel akkor történik, ha a keresés olyan elemet talál, amely nem implementálható IComparable.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Ez a metódus egy O(log n) művelet, ahol n van length.

Lásd még

A következőre érvényes:

BinarySearch(Array, Int32, Int32, Object, IComparer)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a megadott IComparer felülettel.

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

Paraméterek

array: Array

A keresendő egydimenziós Array rendezés.

index: Int32

A keresendő tartomány kezdő indexe.

length: Int32

A keresendő tartomány hossza.

value: Object

A keresendő objektum.

comparer: IComparer

Az IComparer elemek összehasonlítása során használandó implementáció.

-vagy-

null az egyes elemek implementálásának használatához IComparable .

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

RankException

array többdimenziós.

ArgumentOutOfRangeException

index kisebb, mint a array.

-vagy-

length kisebb, mint nulla.

ArgumentException

index és length ne adjon meg érvényes tartományt a következőben: array.

-vagy-

comparer az null, és value olyan típusú, amely nem kompatibilis a következő arrayelemeivel: .

InvalidOperationException

comparer is null, value nem implementálja az IComparable interfészt, és a keresés olyan elemet talál, amely nem implementálja a IComparable felületet.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha comparer igen null, az összehasonlítás az IComparable elem vagy a megadott érték által biztosított implementációval történik. Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Note

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért az összehasonlítások null nem okoznak kivételt a használat IComparablesorán.

Note

Ez a metódus egy O(log n) művelet, ahol n van length.

Lásd még

A következőre érvényes:

BinarySearch<T>(T[], T)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy teljes egydimenziós rendezett tömbben keres egy adott elemet a IComparable<T> megadott objektum egyes elemei Array által implementált általános felület használatával.

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

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

A kereséshez egydimenziós, nulla alapú Array rendezés.

value: T

A keresendő objektum.

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

InvalidOperationException

T nem implementálja az IComparable<T> általános felületet.

Példák

Az alábbi példakód bemutatja az Sort<T>(T[]) általános metódus túlterhelését és az általános metódus túlterhelését BinarySearch<T>(T[], T) . Sztringek tömbje jön létre, nem meghatározott sorrendben.

A tömb ismét megjelenik, rendezve és megjelenítve lesz. A tömböket a metódus használatához BinarySearch rendezni kell.

Note

A Sort és BinarySearch általános metódusok hívásai nem különböznek a nemgenerikus társaikhoz intézett hívásoktól, mivel Visual Basic, F#, C# és C++ az általános típusparaméter típusát az első argumentum típusából következtetik. Ha a Ildasm.exe (IL Disassembler) használatával vizsgálja meg a Microsoft köztes nyelvet (MSIL), láthatja, hogy az általános metódusok meghívása folyamatban van.

Az BinarySearch<T>(T[], T) általános metódus túlterhelése ezután két sztring keresésére szolgál, az egyik nem szerepel a tömbben, a másik pedig az. A tömb és a BinarySearch metódus visszatérési értéke az általános metódusnak ShowWhere (az showWhere F#-példában szereplő függvénynek) lesz átadva, amely megjeleníti az index értékét, ha a sztring megtalálható, ellenkező esetben a keresési sztring elemei a tömbben lévő elemek közé esnek. Az index negatív, ha a sztring nincs a tömbben, ezért a ShowWhere metódus bitenkénti kiegészítést alkalmaz (a ~ operátor a C#-ban, a ~~~ operátor az F#-ban, Xor-1 a Visual Basic) a lista első elemének indexének lekéréséhez, amely nagyobb, mint a keresési sztring.

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.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha array nem tartalmazza a megadott értéket, a metódus negatív egész számot ad vissza. A negatív eredményre alkalmazhatja a bitenkénti komplementer operátort (~ C#-ban, Not Visual Basic) a negatív eredményre, hogy indexet állítson elő. Ha ez az index megegyezik a tömb méretével, nincsenek nagyobb elemek, mint value a tömbben. Ellenkező esetben az első elem indexe nagyobb, mint value.

T az összehasonlításhoz használt általános felületet kell implementálnia IComparable<T> . Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable<T> meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Minden tesztelt value elem esetében a rendszer átadja a megfelelő IComparable<T> implementációnak, még akkor is, ha value az .null Vagyis az IComparable<T> implementáció határozza meg, hogy egy adott elem hogyan viszonyul hozzá null.

Ez a metódus egy O(log n) művelet, ahol n a Length következő array: .

Lásd még

A következőre érvényes:

BinarySearch<T>(T[], T, IComparer<T>)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy teljes egydimenziós rendezett tömbben keres egy értéket a megadott IComparer<T> általános felülettel.

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

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

A kereséshez egydimenziós, nulla alapú Array rendezés.

value: T

A keresendő objektum.

comparer: IComparer<T>

Az IComparer<T> elemek összehasonlítása során használandó implementáció.

-vagy-

null az egyes elemek implementálásának használatához IComparable<T> .

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

ArgumentException

comparer az null, és value olyan típusú, amely nem kompatibilis a következő arrayelemeivel: .

InvalidOperationException

comparer az , nullés T nem implementálja az IComparable<T> általános felületet

Példák

Az alábbi példa az általános metódus túlterhelését Sort<T>(T[], IComparer<T>) és az általános metódus túlterhelését BinarySearch<T>(T[], T, IComparer<T>) mutatja be.

A példakód egy alternatív összehasonlítót határoz meg a ReverseCompare nevű sztringekhez, amely implementálja a IComparer<string> (IComparer(Of String) az Visual Basic) általános felületét. A összehasonlító meghívja a CompareTo(String) metódust, és megfordítja az összehasonlítási és a sztringek sorrendjét, hogy a sztringek az alacsonyról a magasra rendeződjenek.

A tömb ismét megjelenik, rendezve és megjelenítve lesz. A tömböket a metódus használatához BinarySearch rendezni kell.

Note

A Sort<T>(T[], IComparer<T>) és BinarySearch<T>(T[], T, IComparer<T>) általános metódusok hívásai nem különböznek a nemgenerikus társaikhoz intézett hívásoktól, mivel Visual Basic, C# és C++ az általános típusparaméter típusát az első argumentum típusából következtetik. Ha a Ildasm.exe (IL Disassembler) használatával vizsgálja meg a Microsoft köztes nyelvet (MSIL), láthatja, hogy az általános metódusok meghívása folyamatban van.

Az BinarySearch<T>(T[], T, IComparer<T>) általános metódus túlterhelése ezután két sztring keresésére szolgál, az egyik nem szerepel a tömbben, a másik pedig az. A tömb és a BinarySearch<T>(T[], T, IComparer<T>) metódus visszatérési értéke az általános metódusnak ShowWhere (az showWhere F#-példában szereplő függvénynek) lesz átadva, amely megjeleníti az index értékét, ha a sztring megtalálható, ellenkező esetben a keresési sztring elemei a tömbben lévő elemek közé esnek. Az index negatív, ha a sztring nem a tömb, így a ShowWhere metódus bitenkénti kiegészítést alkalmaz (a ~ operátor a C#-ban, a ~~~ operátor az F#-ban, Xor -1 Visual Basic) a lista első elemének indexének lekéréséhez, amely nagyobb, mint a keresési sztring.

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.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha a Array metódus nem tartalmazza a megadott értéket, a metódus negatív egész számot ad vissza. A negatív eredményre alkalmazhatja a bitenkénti komplementer operátort (~ C#-ban, Not Visual Basic) a negatív eredményre, hogy indexet állítson elő. Ha ez az index megegyezik a tömb méretével, nincsenek nagyobb elemek, mint value a tömbben. Ellenkező esetben az első elem indexe nagyobb, mint value.

Ha comparer nem null, akkor a rendszer a megadott értékhez hasonlítja az elemeket array a megadott IComparer<T> általános felület implementálásával. Az elemeket array már növekvő értékben kell rendezni a megadott comparerrendezési sorrend szerint; ellenkező esetben az eredmény helytelen lehet.

Ha comparer igen null, az összehasonlítás a IComparable<T> megadott általános felületi implementációval Ttörténik. Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable<T> meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Note

Ha comparer az null általános felületet használja, és value nem implementálja IComparable<T> , a rendszer nem teszteli arrayIComparable<T> az elemeket a keresés megkezdése előtt. Kivétel akkor történik, ha a keresés olyan elemet talál, amely nem implementálható IComparable<T>.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Ez a metódus egy O(log n) művelet, ahol n a Length következő array: .

Lásd még

A következőre érvényes:

BinarySearch<T>(T[], Int32, Int32, T)

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a IComparable<T> megadott érték minden eleme Array által implementált általános felülettel.

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

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

A kereséshez egydimenziós, nulla alapú Array rendezés.

index: Int32

A keresendő tartomány kezdő indexe.

length: Int32

A keresendő tartomány hossza.

value: T

A keresendő objektum.

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

ArgumentOutOfRangeException

index kisebb, mint a array.

-vagy-

length kisebb, mint nulla.

ArgumentException

index és length ne adjon meg érvényes tartományt a következőben: array.

-vagy-

value olyan típusú, amely nem kompatibilis a következő elemekkel array: .

InvalidOperationException

T nem implementálja az IComparable<T> általános felületet.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha a tömb nem tartalmazza a megadott értéket, a metódus negatív egész számot ad vissza. A negatív eredményre alkalmazhatja a bitenkénti komplementer operátort (~ C#-ban, Not Visual Basic) a negatív eredményre, hogy indexet állítson elő. Ha ez az index megegyezik a tömb méretével, nincsenek nagyobb elemek, mint value a tömbben. Ellenkező esetben az első elem indexe nagyobb, mint value.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért a nem kivételt null eredményező összehasonlítások.

Note

Ez a metódus egy O(log n) művelet, ahol n van length.

Lásd még

A következőre érvényes:

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

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Forrás:: Array.cs

Egy egydimenziós rendezett tömb elemeinek tartományában keres egy értéket a megadott IComparer<T> általános felület használatával.

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

Típusparaméterek

T

A tömb elemeinek típusa.

Paraméterek

array: T[]

A kereséshez egydimenziós, nulla alapú Array rendezés.

index: Int32

A keresendő tartomány kezdő indexe.

length: Int32

A keresendő tartomány hossza.

value: T

A keresendő objektum.

comparer: IComparer<T>

Az IComparer<T> elemek összehasonlítása során használandó implementáció.

-vagy-

null az egyes elemek implementálásának használatához IComparable<T> .

Válaszok

Int32

Kivételek

ArgumentNullException

array az null.

ArgumentOutOfRangeException

index kisebb, mint a array.

-vagy-

length kisebb, mint nulla.

ArgumentException

index és length ne adjon meg érvényes tartományt a következőben: array.

-vagy-

comparer az null, és value olyan típusú, amely nem kompatibilis a következő arrayelemeivel: .

InvalidOperationException

comparer az , nullés T nem implementálja az IComparable<T> általános felületet.

Megjegyzések

Ez a módszer nem támogatja a negatív indexeket tartalmazó tömbök keresését. array A metódus meghívása előtt rendezni kell a rendezést.

Ha comparer igen null, az összehasonlítás a IComparable<T> típushoz Tmegadott általános felületi implementációval történik. Az elemeket array már növekvő értékben kell rendezni a végrehajtás által IComparable<T> meghatározott rendezési sorrend szerint, ellenkező esetben az eredmény helytelen lehet.

Ismétlődő elemek engedélyezettek. Ha a Array metódus egynél több elemet valuetartalmaz, akkor a metódus csak az egyik előfordulás indexét adja vissza, és nem feltétlenül az elsőt.

null mindig összehasonlítható bármely más referenciatípussal; ezért az összehasonlítások null nem okoznak kivételt a használat IComparable<T>során.

Note

Ez a metódus egy O(log n) művelet, ahol n van length.

Lásd még

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?