import java.util.*;

public class TernarySearch {

    public static void main (String[] argv)
    {
        // Fill an array with some random values - for testing.
        int[] testData = {24, 32, 41, 42, 51, 63, 71, 73, 85, 87};

        // Create a test value to search for.
        int searchTerm = 32;

	compare (testData, searchTerm);

	// Some random tests.
	int size = 100;
	for (int n=0; n<10; n++) {
	    int[] data = new int [size];
	    for (int i=0; i<size; i++) {
		data[i] = UniformRandom.uniform (1, size);
	    }
	    Arrays.sort (data);
	    int value = UniformRandom.uniform (1, size);
	    compare (data, value);
	}

	// Speed comparison.
	size = 10000000;
	int[] data = new int [size];
	for (int i=0; i<size; i++) {
	    data[i] = i;
	}
	int numSearches = 10000;
	int[] values = new int[numSearches];
	for (int i=0; i<numSearches; i++) {
	    values[i] = UniformRandom.uniform (1, size);
	}

	long startTime = System.currentTimeMillis();
	for (int i=0; i<numSearches; i++) {
	    boolean found = binarySearch (data, values[i], 0, data.length-1);
	}
	double timeTaken = System.currentTimeMillis() - startTime;
	double avg = timeTaken / numSearches;
	System.out.println ("Avg for binary: " + avg);

	startTime = System.currentTimeMillis();
	for (int i=0; i<numSearches; i++) {
	    boolean found = ternarySearch (data, values[i], 0, data.length-1);
	}
	timeTaken = System.currentTimeMillis() - startTime;
	avg = timeTaken / numSearches;
	System.out.println ("Avg for ternary: " + avg);
    }


    static void compare (int[] A, int value)
    {
        boolean binFound = binarySearch (A, value, 0, A.length-1);
	boolean terFound = ternarySearch (A, value, 0, A.length-1);
	if (binFound != terFound) {
	    System.out.println ("Mismatch: value=" + value + " binF=" + binFound + " terF=" + terFound);
	}
    }


    static boolean binarySearch (int[] A, int value, int start, int end)
    {
        // Only need to check if the interval got inverted.
        if (start > end) {
            return false;
        }
        
        // Find the middle:
        int mid = (start + end) / 2;

        if (A[mid] == value) {
            return true;
        }
        else if (value < A[mid]) {
            // Search the left half: A[start],...,A[mid-1]
            return binarySearch (A, value, start, mid-1);
        }
        else {
            // Search the right half: A[mid+1],...,A[end]
            return binarySearch (A, value, mid+1, end);
        }
    }


    static boolean ternarySearch (int[] A, int value, int start, int end)
    {
        if (start > end) {
            return false;
        }

        // First boundary: add 1/3 of length to start.
	int mid1 = start + (end-start) / 3;
        
        // Second boundary: add 2/3 of length to start.
	int mid2 = start + 2*(end-start) / 3;

	if (A[mid1] == value) {
	    return true;
	}
	else if (A[mid2] == value) {
	    return true;
	}
	else if (value < A[mid1]) {
	    // Search 1st third.
	    return ternarySearch (A, value, start, mid1-1);
	}
	else if (value > A[mid2]) {
	    // Search 3rd third.
	    return ternarySearch (A, value, mid2+1, end);
	}
	else {
	    // Middle third.
	    return ternarySearch (A, value, mid1,mid2);
	}
    }

}