BinarySearch（二分查找，折半查找）

 

老是搞混了二分查找（BinarySearch）和快速排序（QuickSort ），今天在这里记录下，省得以后在忘记啦。

先记二分查找吧，

 

public   class  BinarySearch  ... {
    // copy from JDK's java.util.Arrays.binarySearch(int[], int)
    public static int binarySearch(int[] a, int key) ...{
        int low = 0;
        int high = a.length - 1;

        while (low <= high) ...{
            int mid = (low + high) >> 1;
            int midVal = a[mid];

            if (midVal < key)
                low = mid + 1;
            else if (midVal > key)
                high = mid - 1;
            else
                return mid; // key found
        }
        return -(low + 1); // key not found.
    }

    // to is included
    public static int recursiveBinarySearch(int[] a, int key, int from, int to) ...{

        int mid = (from + to) >> 1;
        int midVal = a[mid];
        // search left part
        if (midVal > key && from <= mid - 1) ...{
            return recursiveBinarySearch(a, key, from, mid - 1);
        }
        // search right part
        else if (midVal < key && mid + 1 <= to) ...{
            return recursiveBinarySearch(a, key, mid + 1, to);
        }
        // find key
        else if (midVal == key) ...{
            return mid;
        }
        // cannot find
        return -1;
    }

    public static void main(String[] args) ...{
        int[] a = ...{ 23, 35, 45, 56, 78, 79, 80, 90, 100 };
        int[] b = ...{ 23, 35, 45, 56, 78, 79, 80, 90, 100, 1000 };

        System.out.println(binarySearch(a, 80));
        System.out.println(binarySearch(b, 80));

        System.out.println(recursiveBinarySearch(a, 100, 0, a.length - 1));
        System.out.println(recursiveBinarySearch(b, 1000, 0, b.length - 1));
    }

}