排序与二分查找

    public static int binarySearch(int[] a, int key) {
		int lo = 0, hi = a.length - 1;
		while (lo <= hi) {
			int mid = lo + (hi - lo) / 2;
			if      (key < a[mid]) hi = mid - 1;
			else if (key > a[mid]) lo = mid + 1;
			else                   return mid;
		}
		return -1;
	}
	
	public static void insertSort(int[] a) {
		int n = a.length;
		for (int i = 1; i < n; i++)
			for (int j = i; j > 0; j--) {
				if (a[j] < a[j-1])
					exch(a, j-1, j);
			}
	}
	
	public static void selectSort(int[] a) {
		int n = a.length;
		for (int i = 0; i < n-1; i++) {
			int min = i;
			for (int j = i+1; j < n; j++) 
				if (a[j] < a[min]) min = j;
			exch(a, i, min);
		}
	}
	
	public static void bubbleSort(int[] a) {
		int n = a.length;
		for (int i = 0; i < n-1; i++) {
			boolean flag = true;
			for (int j = 0; j < n-1-i; j++)
				if (a[j] > a[j+1]) {
					exch(a, j, j+1);
					flag = false;
				}
			if (flag == true) break;
		}
	}
	
	public static void heapSort(int[] a) {
		int n = a.length;
		for(int i = (n-2)/2; i >= 0; i--)
			sink(a, i, n-1);
		
		while (n > 1) {
			exch(a, 0, n-1);
			n--;
			sink(a, 0, n-1);
		}
	}
	
	private static void sink(int[] a, int k, int n) {
		while (2 * k + 1 <= n) {
			int j = 2 * k + 1;
			if (j < n && a[j] < a[j+1]) j++;
			if (a[k] > a[j]) break;
			exch(a, k, j);
			k = j;
		}
	}

	public static void mergeSort(int[] a) {
		int[] aux = new int[a.length];
		sort(a, aux, 0, a.length-1);
	}
		
	private static void sort(int[] a, int[] aux, int lo, int hi) {
		if (hi <= lo) return;
		int mid = lo + (hi - lo) / 2;
		sort(a, aux, lo, mid);
		sort(a, aux, mid+1, hi);
		merge(a, aux, lo, mid, hi);
	}

	private static void merge(int[] a, int[] aux, int lo, int mid, int hi) {
		for (int i = lo; i <= hi; i++)
			aux[i] = a[i];
		int i = lo, j = mid+1;
		for (int k = lo; k <= hi; k++) {
			if      (i > mid)         a[k] = aux[j++];
			else if (j > hi)          a[k] = aux[i++];
			else if (aux[i] < aux[j]) a[k] = aux[i++];
			else                      a[k] = aux[j++];
		}
	}
	
	private static void exch(int[] a, int i, int j) {
		int tmp = a[i];
		a[i] = a[j];
		a[j] = tmp;
	}

    public static void Quicksort(int[] a) {
		sort(a, 0, a.length-1);
	}
	
	private static void sort(int[] a, int lo, int hi) {
		if (hi <= lo) return;
		int j = partition(a, lo, hi);
		sort(a, lo, j-1);
		sort(a, j+1, hi);
	}

	private static int partition(int[] a, int lo, int hi) {
		int i = lo, j = hi+1;
		int v = a[lo];
		while (true) {
			while (a[++i] < v) 
				if (i == hi) break;
			while (a[--j] > v)
				if (j == lo) break;
			if (i >= j) break;
			exch(a, i, j);
		}
		exch(a, lo, j);
		return j;
	}