Question

Suppose you have a sorted array of positive and negative integers and would like to determine if there exist some value of x such that both x and -x are in the array. Consider the following three algorithms:

Algorithm #1: For each element in the array, do a sequential search to see if its negative is also in the array.

Algorithm #2:For each element in the array, do a binary search to see if its negative is also in the array.

Algorithm #3: Maintain two indices i and j, initialized to the first and last element in the array, respectively. If the two elements being indexed sum to 0, then x has been found. Otherwise, if the sum is smaller then 0, advance i; if the sum is larger then 0 retreat j, and repeatedly test the sum until either x is found, or i and j meet.

Determine the running times of each algorithm, and implement all three obtaining actual timing data for various values of N. Confirm your analysis with the timing data.

Answer 1

The worst case for this question will be when there exists no x for which -x exists.

In Algorithm 1, for the worst case the time complexity will become , where N is the size of the array because for each element the array will be searched by the linear search algorithm.

In Algorithm 2, it will be because, for each element the array will be searched by the binary search algorithm.

In Algorithm 3, it will take because we are visiting an index only once.

Following code can be used to verify these. (Assuming language C++)

#include <bits/stdc++.h>
using namespace std;

int N;
int arr[1000005];
int ans;
void generateRandomArray(){
for(int i = 0; i < N; i++){
arr[i] = 1 + rand()%10001; // creating worst case array
}
sort(arr, arr+N);
}

int algorithm1(){
for(int i = 0; i < N; i++){
for(int j = i; j < N; j++){
if(arr[i] == -1*arr[j]){
ans = arr[i];
return 1;
}
}
}
return 0;
}

int algorithm2(){
for(int i = 0; i < N; i++){
int x = -1*arr[i];
int low = 0;
int high = N-1;
while(low <= high){
int mid = (low+high)/2;
if(arr[mid] == x){
ans = x;
return 1;
}
if(arr[mid] > x){
high = mid-1;
}
else{
low = mid+1;
}   
}
}
return 0;
}

int algorithm3(){
int i = 0;
int j = N-1;
while(i <= j){
if(arr[i] + arr[j] == 0){
ans = arr[i];
return 1;
}
if(arr[i] + arr[j] < 0){
i++;
}
else{
j--;
}
}
return 0;
}

int main(){
N = 100000;
generateRandomArray();
clock_t start, stop;
start = clock();
int a = algorithm1();
stop = clock();
double time1 = (stop-start)/double(CLOCKS_PER_SEC);

start = clock();
int b = algorithm2();
stop = clock();
double time2 = (stop-start)/double(CLOCKS_PER_SEC);

start = clock();
int c = algorithm3();
stop = clock();
double time3 = (stop-start)/double(CLOCKS_PER_SEC);

cout << "N = " << N << endl;
cout << "Algorithm 1: " << time1 << setprecision(15) << " s" << endl;
cout << "Algorithm 2: " << time2 << setprecision(15) << " s" << endl;
cout << "Algorithm 3: " << time3 << setprecision(15) << " s" << endl;

}

Output:

N = 100000
Algorithm 1: 2.60012 s
Algorithm 2: 0.002045 s
Algorithm 3: 8e-05 s