折半查找，也称二分查找、二分搜索，是一种在有序数组中查找某一特定元素的搜索算法。

import java.util.Comparator;

/**
 * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)
 * @author骆昊
 *
 */
public interface Sorter {

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

   /**
    * 排序
    * @param list 待排序的数组
    * @param comp 比较两个对象的比较器
    */
   public <T> void sort(T[] list, Comparator<T> comp);
}
  
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
  
  

   
   
  
  
  
  
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.Comparator;

/**
 * 冒泡排序
 * 
 * @author骆昊
 *
 */
public class BubbleSorter implements Sorter {

    @Override
    public <T extends Comparable<T>> void sort(T[] list) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (list[j].compareTo(list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }

    @Override
    public <T> void sort(T[] list, Comparator<T> comp) {
        boolean swapped = true;
        for (int i = 1, len = list.length; i < len && swapped; ++i) {
            swapped = false;
            for (int j = 0; j < len - i; ++j) {
                if (comp.compare(list[j], list[j + 1]) > 0) {
                    T temp = list[j];
                    list[j] = list[j + 1];
                    list[j + 1] = temp;
                    swapped = true;
                }
            }
        }
    }
}





import java.util.Comparator;public 
class MyUtil { public 
static <T extends Comparable<T>> int 
binarySearch(T[] x, T key) { return binarySearch(x,
0, x.length- 1, key); }
// 使用循环实现的二分查找 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; } 
// 使用递归实现的二分查找 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; }}