Binary search is a searching algorithm that works by repeatedly dividing the search space in half until the target value is found. The algorithm starts by comparing the target value to the middle element of the search space. If the target value is equal to the middle element, the algorithm returns the index of the middle element. If the target value is less than the middle element, the algorithm searches the lower half of the search space. If the target value is greater than the middle element, the algorithm searches the upper half of the search space. This process continues until the target value is found or until the search space is empty.

Here is the pseudocode for binary search:

```
procedure binary_search(array, target)
low = 0
high = size - 1
while (low <= high) {
mid = (low + high) / 2
if (array[mid] == target) {
return mid
} else if (array[mid] < target) {
low = mid + 1
} else {
high = mid - 1
}
}
return -1
```

Here is the C code for binary search:

```
int binary_search(int array[], int size, int target) {
int low = 0;
int high = size - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (array[mid] == target) {
return mid;
} else if (array[mid] < target) {
low = mid + 1;
} else {
high = mid - 1;
}
}
return -1;
}
```

To use the binary search algorithm, you would first need to create an array of integers. Then, you would call the binary_search function, passing in the array, the size of the array, and the target value as parameters. The function will return the index of the element in the array if the target value is found, or -1 if the target value is not found.

Here is an example of how to use the binary search algorithm in C:

```
int main() {
int array[] = {10, 5, 2, 7, 1, 8};
int size = sizeof(array) / sizeof(array[0]);
int target = 7;
int index = binary_search(array, size, target);
if (index == -1) {
printf("The target value was not found.");
} else {
printf("The target value was found at index %d.", index);
}
return 0;
}
```

This code will print the following output:

`The target value was found at index 3.`

As you can see, the binary search algorithm has found the target value at index 3 in the array.

Binary search is a very efficient searching algorithm. It has a worst-case time complexity of O(log n), where n is the size of the array. This means that the time it takes to find the target value grows logarithmically with the size of the array.

Binary search is a good algorithm to use when the search space is sorted. It is also a good algorithm to use when the search space is large.