冒泡排序和二分查找

　1. 冒泡排序

　冒泡排序的接口，代码清单如下：

import java.util.Comparator;

/**
 * 排序器接口（策略模式：将算法封装到具有共同接口的独立的类中使得他们可以相互替换）
 */
public interface Sorter {

    /**
     * 排序
     * @param list 待排序的数组
     * @param <T>
     */
    public <T extends Comparable<T>> void sort(T[] list);

    /**
     * 排序
     * @param list 待排序的数组
     * @param comp 比较两个对象的比较器
     * @param <T>
     */
    public <T> void sort(T[] list, Comparator<T> comp);
}

　　冒泡排序的具体实现，代码清单如下：

import java.util.Comparator;

/**
 * 排序器接口（策略模式：将算法封装到具有共同接口的独立的类中使得他们可以相互替换）
 */
public interface Sorter {

    /**
     * 排序
     * @param list 待排序的数组
     * @param <T>
     */
    public <T extends Comparable<T>> void sort(T[] list);

    /**
     * 排序
     * @param list 待排序的数组
     * @param comp 比较两个对象的比较器
     * @param <T>
     */
    public <T> void sort(T[] list, Comparator<T> comp);
}

　2. 二分查找

import java.util.Comparator;

/**
 * 二分查找
 * Created by doudou on 2018/1/19.
 */
public class BinarySearch {

    public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
        return binarySearch(x, 0, x.length - 1, key);
    }

    /**
     * 使用循环实现的二分查找
     * @param x
     * @param key
     * @param comp
     * @param <T>
     * @return
     */
    public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
        int low = 0;
        int high = x.length - 1;
        while (low <= high) {
            int mid = (low + high) >>> 1;
            int cmp = comp.compare(x[mid], key);
            if (cmp < 0) {
                low = mid + 1;
            } else if (cmp > 0) {
                high = mid - 1;
            } else {
                return mid;
            }
        }
        return -1;
    }

    /**
     * 使用递归实现的二分查找
     * @param x
     * @param low
     * @param high
     * @param key
     * @param <T>
     * @return
     */
    private static <T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
        if (low <= high) {
            int mid = low + ((high - low) >> 1);
            if (key.compareTo(x[mid]) == 0) {
                return mid;
            } else if (key.compareTo(x[mid]) > 0) {
                return binarySearch(x, low, mid - 1, key);
            } else {
                return binarySearch(x, mid + 1, high, key);
            }
        }
        return -1;
    }
}