How to use Array.BinarySearch() Method in C# | Set -2
Last Updated : 14 Mar, 2022
Array.BinarySearch() method is used to search a value in a sorted one dimensional array. The binary search algorithm is used by this method. This algorithm searches a sorted array by repeatedly dividing the search interval in half. Begin with an interval covering the whole array. If the value of the search key is less than the item in the middle of the interval, narrow the interval to the lower half. Otherwise, narrow it to the upper half. Repeatedly check until the value is found or the interval is empty.
There are total 8 methods in the overload list of this method as follows:
- BinarySearch(Array, Object) Method
- BinarySearch(Array, Object, IComparer) Method
- BinarySearch(Array, Int32, Int32, Object) Method
- BinarySearch(Array, Int32, Int32, Object, IComparer) Method
- BinarySearch<T>(T[], T) Method
- BinarySearch<T>(T[], T, IComparer<T>) Method
- BinarySearch<T>(T[], Int32, Int32, T) Method
- BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) Method
Here, the first 4 methods are already discussed in Set-1. Last 4 methods will be discussed in this set
BinarySearch<T>(T[], T) Method
This method searches for a specific element in a sorted one-dimensional array. It will search the entire array. The search uses an IComparable<T> generic interface which is implemented by each element of the array or by a specific object.
Syntax: public static int BinarySearch<T>(T[] arr, T val);
Here, “T” is the type of the elements of the array.
Parameters:
arr: It is the one-dimensional sorted array to search for.
val: It is the object to search for.
Return Value: It returns the index of the specified valin the specified arr if the val is found otherwise it returns a negative number. There are different cases of return values as follows:
- If the val is not found and valis less than one or more elements in the arr, the negative number returned is the bitwise complement of the index of the first element that is larger than val.
- If the val is not found and val is greater than all elements in the arr, the negative number returned is the bitwise complement of (the index of the last element plus 1).
- If this method is called with a non-sorted array, the return value can be incorrect and a negative number could be returned, even if the val is present in the arr.
Exceptions:
- ArgumentNullException: If the arr is null.
- InvalidOperationException: If the T does not implement the IComparable<T> generic interface.
Example 1:
using System;
using System.Collections.Generic;
class GFG {
public static void Main()
{
string[] arr = {"ABC", "XYZ",
"JKL", "DEF", "MNO"};
Console.WriteLine("Original array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
Array.Sort(arr);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
int index = Array.BinarySearch(arr, "GHI");
sort(arr, index);
}
private static void sort<T>(T[] array, int index)
{
if (index < 0)
{
index = ~index;
Console.Write("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);
}
}
}
|
Output: Original array ABC XYZ JKL DEF MNO After Sort ABC DEF JKL MNO XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL.
Example 2:
using System;
using System.Collections.Generic;
class GFG {
public static void Main()
{
int[] arr = {5, 7, 1, 3, 4, 2};
Console.WriteLine("Original array");
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
Array.Sort(arr);
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for '6':");
int index = Array.BinarySearch(arr, 6);
sort(arr, index);
}
private static void sort<T>(T[] array, int index)
{
if (index < 0)
{
index = ~index;
Console.Write("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);
}
}
}
|
Output: Original array 5 7 1 3 4 2 After Sort 1 2 3 4 5 7 BinarySearch for '6': Sorts between: 5 and 7.
BinarySearch<T>(T[], T, IComparer<T>) Method
This method searches for a specific value in a one-dimensional sorted array specified using IComparer<T> generic interface.
Syntax: public static int BinarySearch<T> (T[] arr, T val, IComparer comparer);
Here, “T” is the type of the elements of the array.
Parameters:
arr: It is the one-dimensional sorted array to search for.
val: It is the object to search for.
comparer: It is theIComparer<T> implementation to use when comparing elements.
Return Value: It returns the index of the specified valin the specified arr if the val is found otherwise it returns a negative number. There are different cases of return values as follows:
- If the val is not found and valis less than one or more elements in the arr, the negative number returned is the bitwise complement of the index of the first element that is larger than val.
- If the val is not found and val is greater than all elements in the arr, the negative number returned is the bitwise complement of (the index of the last element plus 1).
- If this method is called with a non-sorted array, the return value can be incorrect and a negative number could be returned, even if the val is present in the arr.
Exceptions:
- ArgumentNullException: If the array is null.
- InvalidOperationException: If the comparer is null and T does not implement the IComparable<T> generic interface.
- ArgumentException: If the comparer is null, and value is of a type that is not compatible with the elements of array.
Example:
using System;
using System.Collections.Generic;
class comparer : IComparer<string> {
public int Compare(string x, string y)
{
return x.CompareTo(y);
}
}
class GFG {
public static void Main()
{
string[] arr = {"ABC", "XYZ",
"JKL", "DEF", "MNO"};
Console.WriteLine("Original Array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
comparer gg = new comparer();
Console.WriteLine("\nAfter Sort");
Array.Sort(arr, gg);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
int index = Array.BinarySearch(arr, "GHI", gg);
sort(arr, index);
}
private static void sort<T>(T[] array, int index)
{
if (index < 0) {
index = ~index;
Console.Write("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);
}
}
}
|
Output: Original Array ABC XYZ JKL DEF MNO After Sort ABC DEF JKL MNO XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL
BinarySearch<T>(T[], Int32, Int32, T)
This method searches a range of elements in a one-dimensional sorted array for a value, using the IComparable<T> generic interface implemented by each element of the Array or a specified value.
Syntax: public static int BinarySearch<T> (T[] arr, int start, int len, T val);
Here, “T” is the type of the elements of the array.
Parameters:
arr: It is the one-dimensional sorted array to search for.
start: It is the starting index of the range to search.
len: It is the length of the range to search.
val: It is the object to search for.
Return Value: It returns the index of the specified valin the specified arr if the val is found otherwise it returns a negative number. There are different cases of return values as follows:
- If the val is not found and valis less than one or more elements in the arr, the negative number returned is the bitwise complement of the index of the first element that is larger than val.
- If the val is not found and val is greater than all elements in the arr, the negative number returned is the bitwise complement of (the index of the last element plus 1).
- If this method is called with a non-sorted array, the return value can be incorrect and a negative number could be returned, even if the val is present in the arr.
Exceptions:
- ArgumentNullException: If array is null.
- InvalidOperationException: If T does not implement the IComparable<T> generic interface.
- ArgumentException: If start and len do not specify a valid range in array or value is of a type that is not compatible with the elements of array.
- ArgumentOutOfRangeException: If start is less than the lower bound of array.
Example:
using System;
using System.Collections.Generic;
class GFG {
public static void Main()
{
int[] arr = { 1, 5, 3, 4, 2, 7 };
Console.WriteLine("Original Array");
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nAfter Sort");
Array.Sort(arr);
foreach(int g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for '6':");
int index = Array.BinarySearch(arr, 0, 4, 6);
sort(arr, index);
}
private static void sort<T>(T[] array, int index)
{
if (index < 0) {
index = ~index;
Console.Write("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);
}
}
}
|
Output: Original Array 1 5 3 4 2 7 After Sort 1 2 3 4 5 7 BinarySearch for '6': Sorts between: 4 and 5
BinarySearch<T>(T[], Int32, Int32, T, IComparer<T>) Method
This method searches a range of elements in a one-dimensional sorted array for a value, using the specified IComparer<T> generic interface.
Syntax: public static int BinarySearch<T> (T[] array, int start, int len, T val, IComparer<T> comparer);
Here, “T” is the type of the elements of the array.
Parameters:
arr: It is the one-dimensional sorted array to search for.
start: It is the starting index of the range to search.
len: It is the length of the range to search.
value: It is the object to search for.
comparer: It is the IComparer<T> implementation to use when comparing elements.
Return Value: It returns the index of the specified valin the specified arr if the val is found otherwise it returns a negative number. There are different cases of return values as follows:
- If the val is not found and valis less than one or more elements in the arr, the negative number returned is the bitwise complement of the index of the first element that is larger than val.
- If the val is not found and val is greater than all elements in the arr, the negative number returned is the bitwise complement of (the index of the last element plus 1).
- If this method is called with a non-sorted array, the return value can be incorrect and a negative number could be returned, even if the val is present in the arr.
Exceptions:
- ArgumentNullException: If array is null.
- InvalidOperationException: If T does not implement the IComparable<T> generic interface.
- ArgumentException: If start and len do not specify a valid range in array or comparer is null and val is of a type that is not compatible with the elements of array.
- ArgumentOutOfRangeException: If start is less than the lower bound of array or len is less than zero.
Example:
using System;
using System.Collections.Generic;
class comparer : IComparer<string> {
public int Compare(string x, string y)
{
return x.CompareTo(y);
}
}
class GFG {
public static void Main()
{
string[] arr = {"ABC", "UVW", "JKL",
"DEF", "MNO", "XYZ"};
Console.WriteLine("Original Array");
foreach(string g in arr)
{
Console.WriteLine(g);
}
comparer gg = new comparer();
Console.WriteLine("\nAfter Sort");
Array.Sort(arr, gg);
foreach(string g in arr)
{
Console.WriteLine(g);
}
Console.WriteLine("\nBinarySearch for 'GHI':");
int index = Array.BinarySearch(arr, 1, 4, "GHI", gg);
sort(arr, index);
}
private static void sort<T>(T[] array, int index)
{
if (index < 0) {
index = ~index;
Console.Write("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);
}
}
}
|
Output: Original Array ABC UVW JKL DEF MNO XYZ After Sort ABC DEF JKL MNO UVW XYZ BinarySearch for 'GHI': Sorts between: DEF and JKL
Reference:
Similar Reads
How to sort an Array in C# | Array.Sort() Method Set – 2
Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method. Here we will discuss the following methods: Sort(Array, Int32, Int32, IComparer) Method Sort(Array, Array, Int32, Int32, IComparer) Method Sort(Array, Int32, Int32) Method
9 min read
Array.BinarySearch(Array, Object) Method with examples in C#
This method is used to search a specific element in the entire one-dimensional sorted array by using the IComparable interface which is implemented by each element of the array and by the specified object. Syntax: public static int BinarySearch (Array array, object value); Parameters: array: It is t
4 min read
How to sort an Array in C# | Array.Sort() Method | Set – 4
Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method. Here we will discuss the following methods: Sort(Array) Method This method sorts the elements in an entire one-dimensional array using the IComparable implementation of ea
5 min read
How to Sort an Array in C# | Array.Sort() Method Set - 1
Array.Sort Method in C# is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method as follows: Sort<T>(T[]) MethodSort<T>(T[], IComparer<T>) MethodSort<T>(T[], Int32, Int32) MethodSort<T>(T[], Comparison<T>) Metho
8 min read
How to sort an Array in C# | Array.Sort() Method Set – 3
Array.Sort Method is used to sort elements in a one-dimensional array. There are 17 methods in the overload list of this method. Here we will discuss the following methods: Sort(Array, IComparer) Method Sort(Array, Array, IComparer) Method Sort(Array, Array) Method Sort(Array, IComparer) Method This
6 min read
C# | Array.BinarySearch(Array, Object, IComparer) Method
This method searches for a value in a one-dimensional sorted array using a specified IComparer interface. Syntax: public static int BinarySearch(Array arr, Object val, IComparer comparer) Parameters: arr : The one-dimensional sorted array in which the search will happen. val : The object value which
4 min read
C# | Array.BinarySearch(Array, Int32, Int32, Object, IComparer) Method
This method searches for an element which is in a one-dimensional sorted array within a range of elements using a specified IComparer interface. Syntax: public static int BinarySearch(Array arr, int index, int length, Object value, IComparer comparer) Parameters: arr : The sorted one-dimensional Arr
4 min read
Array.BinarySearch(Array, Int32, Int32, Object) Method with examples in C#
Array.BinarySearch(Array, int32, int32, Object) Method is used to search a range of elements in a one-dimensional sorted array for a value, using the IComparable interface implemented by each element of the array and by the specified value. It searches only in a specified boundary that the user defi
4 min read
List BinarySearch() Method in C#
List<T>.BinarySearch(T) Method uses a binary search algorithm to locate a specific element in the sorted List<T> or a portion of it. There are 3 methods in the overload list of this method as follows: BinarySearch(T)BinarySearch(T, IComparer<T>)BinarySearch(Int32, Int32, T, ICompar
9 min read
Array.LastIndexOf Method in C# | Set – 2
Array.LastIndexOf method is used to find the index of the last occurrence of a value in a one-dimensional Array or in a portion of the Array. It starts the search from the last element of an array. It returns the index of the element that contains the specified value. There are 6 methods in the over
4 min read