冒泡排序和二分查找

　1. 冒泡排序

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

 1 import java.util.Comparator;
 2 
 3 /**
 4  * 排序器接口（策略模式：将算法封装到具有共同接口的独立的类中使得他们可以相互替换）
 5  */
 6 public interface Sorter {
 7 
 8     /**
 9      * 排序
10      * @param list 待排序的数组
11      * @param <T>
12      */
13     public <T extends Comparable<T>> void sort(T[] list);
14 
15     /**
16      * 排序
17      * @param list 待排序的数组
18      * @param comp 比较两个对象的比较器
19      * @param <T>
20      */
21     public <T> void sort(T[] list, Comparator<T> comp);
22 }

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

 1 import java.util.Comparator;
 2 
 3 /**
 4  * 排序器接口（策略模式：将算法封装到具有共同接口的独立的类中使得他们可以相互替换）
 5  */
 6 public interface Sorter {
 7 
 8     /**
 9      * 排序
10      * @param list 待排序的数组
11      * @param <T>
12      */
13     public <T extends Comparable<T>> void sort(T[] list);
14 
15     /**
16      * 排序
17      * @param list 待排序的数组
18      * @param comp 比较两个对象的比较器
19      * @param <T>
20      */
21     public <T> void sort(T[] list, Comparator<T> comp);
22 }

　2. 二分查找

 1 import java.util.Comparator;
 2 
 3 /**
 4  * 二分查找
 5  * Created by doudou on 2018/1/19.
 6  */
 7 public class BinarySearch {
 8 
 9     public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
10         return binarySearch(x, 0, x.length - 1, key);
11     }
12 
13     /**
14      * 使用循环实现的二分查找
15      * @param x
16      * @param key
17      * @param comp
18      * @param <T>
19      * @return
20      */
21     public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
22         int low = 0;
23         int high = x.length - 1;
24         while (low <= high) {
25             int mid = (low + high) >>> 1;
26             int cmp = comp.compare(x[mid], key);
27             if (cmp < 0) {
28                 low = mid + 1;
29             } else if (cmp > 0) {
30                 high = mid - 1;
31             } else {
32                 return mid;
33             }
34         }
35         return -1;
36     }
37 
38     /**
39      * 使用递归实现的二分查找
40      * @param x
41      * @param low
42      * @param high
43      * @param key
44      * @param <T>
45      * @return
46      */
47     private static <T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
48         if (low <= high) {
49             int mid = low + ((high - low) >> 1);
50             if (key.compareTo(x[mid]) == 0) {
51                 return mid;
52             } else if (key.compareTo(x[mid]) > 0) {
53                 return binarySearch(x, low, mid - 1, key);
54             } else {
55                 return binarySearch(x, mid + 1, high, key);
56             }
57         }
58         return -1;
59     }
60 }