0

I want to get all the position of (8) in a array like this: (3,5,6,7,8,8,9,33,34,45). But my code returns only one position and forget the second one:

This is my binary search code:

private static int BinarySearch(int[] array, int item)
{
    int left = 0;
    int right = array.Length - 1;

    while (left <= right)
    {
        var middle = (left + right) / 2;

        if (array[middle] == item)
            return middle;

        if (item < array[middle])
            right = middle - 1;
        else
            left = middle + 1;
    }

    return -1;
}
Brian Rogers
  • 125,747
  • 31
  • 299
  • 300
Aisha Alhrary
  • 17
  • 1
  • 1
    You're returning an `int`. That's only one position. You may need to change your code to return an array: `int[]` – ikerbera Nov 30 '18 at 11:42
  • Probably something fancy you can do with `Yield` –  Nov 30 '18 at 11:45
  • 1
    @ikerbera that would be unnecessary - since it is binarysearch, we can assume that the data is sorted... so all we really need is an index/count pair; note : the existing code is actually wrong anyway... when finding a match, it should do two things: walk backwards to find the *first* match, and walk forwards to find the last/count – Marc Gravell Nov 30 '18 at 11:51
  • Where you do `return middle;` you should do a search of ALL matching values *before* and *after* `middle`. This could be a linear search to keep it simple, or it could be binary-ish if you expect potentially lots of matching values. – Peter B Nov 30 '18 at 11:52
  • Why did the answers get removed? At least one of them worked. –  Nov 30 '18 at 11:55
  • No, it did not work for `{3, 5, 6, 7, 8, 8, 8, 8, 8, 8, 9, 33, 34, 45}` because it failed to search both ways. – Peter B Nov 30 '18 at 11:56
  • https://stackoverflow.com/questions/12144802/finding-multiple-entries-with-binary-search – fubo Nov 30 '18 at 12:22

3 Answers3

3

What you want is the same as the C++ "equal_range()" method.

If you look at the standard C++ implementations, they use "lower_bound()" to find the low value and "upper_bound" to find the high value. It does it like this rather than doing a "scan" from the index found from a normal binary search to ensure that it always works within an O(Log(N)) timescale. A linear search for the bounds could degenerate into an O(Log(N)) operation followed by an O(N) one.

Here's a C# implementation of C++'s lower_bound(), upper_bound() and equal_range():

public static class BoundedSearch
{
    /// <summary>Same as C++'s equal_range()</summary>

    public static Tuple<int, int> EqualRange<T>(IList<T> values, T target) where T : IComparable<T>
    {
        int lowerBound = LowerBound(values, target, 0, values.Count);
        int upperBound = UpperBound(values, target, lowerBound, values.Count);

        return new Tuple<int, int>(lowerBound, upperBound);
    }

    /// <summary>Same as C++'s lower_bound()</summary>

    public static int LowerBound<T>(IList<T> values, T target, int first, int last) where T : IComparable<T>
    {
        int left  = first;
        int right = last;

        while (left < right)
        {
            int mid = left + (right - left) / 2;
            var middle = values[mid];

            if (middle.CompareTo(target) < 0)
                left = mid + 1;
            else
                right = mid;
        }

        return left;
    }

    /// <summary>Same as C++'s upper_bound()</summary>

    public static int UpperBound<T>(IList<T> values, T target, int first, int last) where T : IComparable<T>
    {
        int left = first;
        int right = last;

        while (left < right)
        {
            int mid = left + (right - left) / 2;
            var middle = values[mid];

            if (middle.CompareTo(target) > 0)
                right = mid;
            else
                left = mid + 1;
        }

        return left;
    }
}

(Note: This code uses the old Tuple<> class to return the ranges. If you're using a recent version of C# and .Net, you could change this to return proper tuples like public static (int LowerBound, int UpperBound) EqualRange<T>(...)).

Matthew Watson
  • 104,400
  • 10
  • 158
  • 276
1

As Matt implied in the comments, you could return an IEnumerable<int>, yield returning the values:

private static IEnumerable<int> BinarySearch(int[] array, int item)
{
    int left = 0;
    int right = array.Length - 1;

    while (left <= right)
    {
        if (array[left] == item)
            yield return left;

        if (left == right)
            break;

        if (array[right] == item)
            yield return right;

        left++;
        right--;
    }
}

You would use this as follows:

static void Main(string[] args)
{
    var items = new int[] { 3, 5, 6, 7, 8, 8, 9, 33, 34, 45, 8 };

    foreach (var item in BinarySearch(items, 8))
    {
        Console.WriteLine(item);
    }
}

Or materialize an array or list if you want to do that up front:

static void Main(string[] args)
{
    var items = new int[] { 3, 5, 6, 7, 8, 8, 9, 33, 34, 45, 8 };

    var results = BinarySearch(items, 8).ToArray();
}
Creyke
  • 1,887
  • 2
  • 12
  • 16
0

You're returning an int. That's only one position. You may need to change your code to return an array: int[] also Where you do return middle; you should do a search of ALL matching values before and after middle. This could be a linear search to keep it simple, or it could be binary-ish if you expect potentially lots of matching values.

Reza Mousazadeh
  • 148
  • 1
  • 10