import java.util.Random;

public class Searcher {
    
    int[] data;
    
    public Searcher() {
        fill(200);
    }
    
    public Searcher(int dataSize) {
        fill(dataSize);
     }

     public void fill(int size) {
        data = new int[size];
        for (int i=0; i<data.length; i++) {
            data[i]=i;
        }

     }

    public void shuffle() {
        Random r = new Random();
        for (int i=0; i<(data.length-2); i++)
        {
            int loc = i + r.nextInt(data.length-i);
            int tmp = data[i];
            data[i]=data[loc];
            data[loc]=tmp;
        }
    }
    
    /**
    * Implement Binary search, recursively on internal array of ints
    * @param target the item to be found
    * @param lo the bottom of the range being searched
    * @param hi the top of the range being searched
    * @param steps the number of steps the search has taken
    * @return true if the target was found
    */
    private boolean iBinarySearch(int target, int lo, int hi, int steps) {
        if (lo>hi) return false;
        int mid = (lo+hi)/2;
        System.out.println(target + " " + data[mid] + " " + lo + " " + hi + " " + steps);
        if (data[mid]==target) return true;
        if (data[mid]<target)
        return iBinarySearch(target, mid+1, hi, steps+1);
        else
        return iBinarySearch(target, lo, mid-1, steps+1);
    }
    int steps;

    /** Binary-like search, but will work on sorted or unsorted lists
     * because it does backtracking.
    * @param target the item to be found
    * @param lo the bottom of the range being searched
    * @param hi the top of the range being searched
    * @param depth the depth of the recursion.  Counting steps with
    * backtracking really requires an external variable.
    * @return true if the target was found
    */
    private boolean iBacktrackingSearch(int target, int lo, int hi, int depth)
    {
        steps++;
        System.out.print(steps);
        if (lo>hi) { System.out.println(); return false; }
        int mid = (lo+hi)/2;
        System.out.println(" " + target + " " + data[mid] + " " + lo + " " + hi + " " + depth);
        if (data[mid]==target) 
            return true;
        if (iBacktrackingSearch(target, mid+1, hi, depth+1))
            return true;
        return iBacktrackingSearch(target, lo, mid-1, depth+1);
    }

    /**
    * The public facing call to binarySearch
    * @param target the value being searched for
    * @param useBinarySearch true if should use standard binary search.
    * @return true is the value is in known in the class, false otherwise
    */
    public boolean contains(int target, boolean useBinarySearch) {
        steps=0;
        if (data==null)
            return false;
        if (useBinarySearch)
            return iBinarySearch(target, 0, data.length-1, 0);
        return iBacktrackingSearch(target, 0, data.length-1, 0);
    }

    
    public String toString() {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i<data.length; i++) {
            sb.append(data[i]);
            sb.append(" ");
        }
        return sb.toString();
    }
    
    public static void main(String[] args) {
        Searcher l6 = new Searcher(1000);
        System.out.println(l6.contains(17, true));
        l6.shuffle();    
        System.out.println(l6.contains(17, true));
        System.out.println(l6.contains(17, false));
    }
    
}