Binary Search in an Array

Input is an sorted array and an element which need to be searched in the array. The module will return the possition of the element in the given array.

public class BinarySearchArray {
    private final static int Default = -999; //default value
   
    public int BinarySearch(ArrayList<Integer> input, int element)    {
        if(input.size() == 0)
            return Default;
        return BinarySearchRecursive(input, element, 0, input.size());
    }
   
    private int BinarySearchRecursive(ArrayList<Integer> input, int element, int min, int max)    {
        int possition = Default;
        int check_possition = min+((max-min)/2);
        if(input.get(check_possition) == element)
            possition = check_possition;
        else if(max <= min)
            return Default;    //element not found
        else if(element > input.get(check_possition))    {
            int difference = (max-min)/2;
            if(difference == 0) difference = 1;
            min = min + (difference);
            possition = BinarySearchRecursive(input, element, min, max);
        }    else    {
            max = check_possition-1;
            possition = BinarySearchRecursive(input, element, min, max);
        }
        return possition;
    }
}
-----------------------------------------------------------------------------------------------------------
Recursion costs more memory. To be more memory efficient we can use a loop instead of recursion.

public class BinarySearchInLoop {
    private final static int Default = -999; //default value
    public int BinarySearch(ArrayList<Integer> input, int element)    {
        if(input.size() == 0)
            return Default;
        else {
        int min = 0;
        int max = input.size();
        while(min <= max) {
            int check_possition = min+((max-min)/2);
            if(input.get(check_possition) == element) {
            return check_possition;
            } else if(element > input.get(check_possition))    {
            int difference = (max-min)/2;
                    if(difference == 0) difference = 1;
                    min = min + (difference);
            } else {
            max = check_possition-1;
            }
            }
        return Default;
        }
    }
}

Simulation: Comparison between Classical Computer and Quantum Computer using C

This is a program which gives you an idea about what a Quantum Computer is and how is it different from a Classical Computer. It can be compiled using CC or GCC compilers.

#include<stdio.h>
#include<stdlib.h>
#include<curses.h>
#include<time.h> 
void classic();
void quantum();
void delay_sec( int seconds );
int main() {
int c;
while(1) {
printf("\n\n1. Classical\n2. Quantum\n3. Exit\n(Please do not enter non-integer here)\nEnter the case: ");
scanf("%d",&c);
switch (c) {
case 1: {
classic();
break;
}
case 2: {
quantum();
break;
}
case 3: {
exit(0);
}
default: {
printf("Wrong Case!\nTry again");
break;
}
}
}
}
void delay_sec( int seconds ) {
    clock_t endwait;
    endwait = clock () + seconds * CLOCKS_PER_SEC;
    while (clock() < endwait) {}
}
void classic() {
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\n");
printf("Data1 -> \nData2 -> \nData3 -> \nData4 -> \nData5 -> \nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> \nData3 -> \nData4 -> \nData5 -> \nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> \nData4 -> \nData5 -> \nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> \nData5 -> \nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> Schema4\nData5 -> \nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> Schema4\nData5 -> Schema5\nData6 -> \nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> Schema4\nData5 -> Schema5\nData6 -> Schema6\nData7 ->\n");
delay_sec(1);
system("clear");
printf("ONLY ONE SCHEMA AT A TIME\n");
printf("Classical\nData1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> Schema4\nData5 -> Schema5\nData6 -> Schema6\nData7 -> Schema7\n");
delay_sec(1);
printf("\nTOTAL TIME TAKEN = 7 Units (1 Unit per schema)");
}
void quantum() {
system("clear");
printf("MULTIPLE OR EVERY POSSIBLE SCHEMA AT THE SAME TIME\n");
printf("Quantum\n");
printf("Data1 -> Schema1\nData2 -> Schema2\nData3 -> Schema3");
printf("\nData4 -> Schema4\nData5 -> Schema5\nData6 -> Schema6\nData7 -> Schema7\n");
printf("\nTOTAL TIME TAKEN = 1 Units (1 Unit per schema)");
}