Why am I getting segmentation fault and how to resolve it - c++

Question

#include<iostream>
using namespace std;
int BSearch(int array[],int key,int left,int right)
{
if(array[left+right/2]==key)
cout<<left+right/2;
else if(array[left+right/2]<key)
BSearch(array,key,left,right/2-1);
else
BSearch(array,key,right/2,right);
}
int main()
{
int list[]={1,2,3,4,5,6,7,8,9,11,15,21};
BSearch(list,5,0,sizeof(list)/sizeof(int)-1);
}
I wrote this program to perform binary search. I am getting Segmentation fault every time I run it.

Answer 1

Check here:
if(array[left+right/2]==key)
and focus on this left+right/2. Here, the precedence of the operators comes into play. You probably meant add left and right and then divide the sum by two.
However, it will first divide right by two and then add that to left.
So change:
left+right/2
to:
(left+right)/2
everywhere you need to.
Moreover, your logic is flawed. I have already wrote an example in Binary Search (C++), but even Wikipedia can help here. The code of yours works with this:
#include <iostream>
using namespace std;
void BSearch(int array[], int key, int left, int right) {
if (array[(left + right) / 2] == key) {
cout << "found at position " << (left + right) / 2;
return;
} else if (array[(left + right) / 2] > key) {
BSearch(array, key, left, (left + right)/ 2 - 1);
} else {
BSearch(array, key, (left + right)/ 2 + 1, right);
}
}
int main() {
int list[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 15, 21};
BSearch(list, 5, 0, sizeof(list) / sizeof(int) - 1);
}
Output:
found at position 4

Answer 2

Actually the correct way of doing this is not
(left+right)/2
but
left + (right - left)/2
The difference is when working with large lists, the first variant has an overflow problem (undefined behavior with signed ints, not working as expected with unsigned).
Lets illustrate on the char type with range 0..255 unsigned and -128..127 signed (int just has a wider range but the problem remains).
Suppose you want to find a middle of signed chars 40 and 100:
The result of the first expression [(left+right)/2] is: (40+100)/2 = (-116)/2 = -58 (technically undefined, 40+100 char would only be -116 with the standard two's complement implementation but that is not mandated by the C/C++ standard)
The result of the second [left + (right - left)/2] is 40 + (100-40)/2 = 40 + (60)/2 = 40 + 30 = 70
With unsigned char 100 and 250:
The first: (100 + 250)/2 = (94)/2 = 47
The second: 100 + (250 - 100)/2 = 100 + 150 / 2 = 175
For the recursive calls, you need to supply ranges along the "middle" point (again L + (R-L)/2 instead of R/2).
In particular, as also mentioned in the Wikipedia article:
Although the basic idea of binary search is comparatively
straightforward, the details can be surprisingly tricky… (Donald Knuth)

Answer 3

You must be change less than to greater than in second if statement: else if(array[(left+right)/2]>key) because you search reverse side.
And you must change right/2 to (left+right)/2 in third if statement because left may not 0 and right/2 will not corret. You must search from midle to riht side. Solution is
#include <iostream>
using namespace std;
int BSearch(int array[],int key,int left,int right)
{
if(array[(left+right)/2]==key)
cout<<(left+right)/2 << endl;
else if(array[(left+right)/2]>key)
BSearch(array,key,left,(left+right)/2-1);
else
BSearch(array,key,(left+right)/2+1,right);
}
int main()
{
int list[]={1,2,3,4,5,6,7,8,9,11,15,21};
BSearch(list,5,0,sizeof(list)/sizeof(int)-1);
}

Answer 4

The parenthesis issue discussed in the other answers is certainly a big issue, and must be fixed. However, I don't think that is causing the segfault.
The first time BSearch() is called, left and right are 0 and 11, respectively. 5 is the (mistakenly) computed index, pointing to the value of 6. As a result, the last line of BSearch() is called, passing 5 and 11 for left and right.
Following through the function again, the last line is called again, passing 5 and 11 again, ad infinitum.
You must correct how BSearch() computes the indexes to pass to itself.