算法

二分查找——

静态方法rank()实现，接受一个整数键和一个已经有序的int数组作为参数，若该键存在于数组中，则返回索引。

a[low... high],不断拿键值和a[min]比较

实现：

package Algorithms;

import java.util.Arrays;


public class BinarySearch {
 public static int rank(int key,int[] a) {
	int low=0;
	int high=a.length-1;
	while(low<=high){
		int mid=(low+high)/2;
		if(key<a[mid]) high=mid;
		else if (key>a[mid]) low=mid;
		else return mid;
	}
	return -1;
}	
 public static void main(String[] args) {
		 
  int[] whitelist=In.readInts(args[0]);
  Arrays.sort(whitelist);
  while(!StdIn.isEmpty()){
	  //读取键值，如果不存在于白名单则将其打印
	  int key=StdIn.readInt();
	  if(rank(key, whitelist)<0)
		  StdOut.println(key);
     }
   }
}

二、归并排序

递归分成两半分别排序，然后将结果归并，时间nlogn

原地归并的抽象方法：先将所有元素复制到aux[]辅助数组，然后再归并回a[]。归并时的4个判断条件：左半边用尽（取右半边）   右半边用尽（取左半边） 右半边当前元素小于左半边当前元素（取右半边元素）  </p><p>右半边当前元素大于等于左半边当前元素（取左半边元素）</p><p>采用分而治之思想，空间复杂度：N(辅助数组）时间复杂度：NlgN<pre name="code" class="java">public class merge {
//原地归并的抽象方法
	public static void merge(Comparable[] a,int low,int mid,int high) {
		int i=low,j=mid+1;
		for(int k=low;k<=high;k++)
			aux[k]=a[k];
		for(int k=low;k<=high;k++)
			if(i>mid)    a[k]=aux[j++];
			else if(j>high)   a[k]=aux[i++];
			else if(less(aux[j],aux[i]))   a[k]=aux[j++];
			else   a[k]=aux[i++];
	}
//自顶向下的归并排序
	private static Comparable[]  aux;//原数组大小的辅助数组
	public static void sort(Comparable[] a) {
		aux=new Comparable[a.length];
		sort(a,0,a.length-1);
	}
	private static void sort(Comparable[] a,int low,int high) {
		if(high<=low)   return;//递归终止条件
		int mid=(low+high)/2;
		sort(a,low,mid);
		sort(a,mid+1,high);
		merge(a, low, mid, high);
	}
	
}

三、快速排序