插入排序、合并排序、堆排序和快速排序

* 插入排序
* 时间复杂度O(n2)
* @param array原地排序算法
*/
public void insertSort(int[] array) {
　　for (int i = 1; i < array.length; i++) {
　　　　int present = array[i];
　　　　int position = i;
　　　　while (position > 0 &;&; array[position - 1] > present) {// 右移
 10　　　　　　 array[position] = array[position - 1];
 11　　　　　　 position--;
　　　　　　}
　　　　array[position] = present;
　　}
}

 

/**

* 合并排序
* O(nlogn)
* @param array
* @param left 第一个索引
* @param right 最后一个索引
*/
public void mergeSort(int []array,int left,int right){
　　if(left<right){
　　　　int middle=(left+right)/2;
　　　　mergeSort(array,left,middle);
 31　　　　 mergeSort(array,middle+1,right);
　　　　merge(array,left,middle,right);
　　}
}

public void merge(int []array,int left,int middle,int right){
　　int [] array1=new int[middle-left+1];
　　int [] array2=new int[right-middle];
　　for(int i=0;i<array1.length;i++){
　　　　array1[i]=array[left+i];
　　}
　　for(int i=0;i<array2.length;i++){
　　　　array2[i]=array[middle+i+1];
　　}
　　int l=0,r=0,k=left;
　　for(;k<=right&;&;l<array1.length&;&;r<array2.length;k++){
　　　　if(array1[l]>array2[r]){
　　　　　　array[k]=array2[r];
 49　　　　　　 r++;
　　　　}else {
　　　　　　array[k]=array1[l];
 52　　　　　　 l++;
　　　　}
　　}
　　while(l<array1.length){
　　　　array[k]=array1[l];
　　　　　　l++;
　　　　　　k++;
　　　　}
 60　　　 while(r<array2.length){
　　　　array[k]=array2[r];
　　　　r++;
　　　　k++;
　　　}
}

 

/**
* 堆排序
* 原地排序且O(nlogn)
* @param array
*/
public void heapSort(int [] array){
　　buildHeap(array);
　　for(int i=array.length-1;i>0;i--){
　　　　int k=array[0];
　　　　array[0]=array[i];
　　　　array[i]=k;
　　　　heapify(array, 0, i);
　　}
}
/**
* 构建最大堆
* @param array
*/
public void buildHeap(int [] array){
　　for(int i=array.length/2-1;i>-1;i--){
　　　　heapify(array,i,array.length);
　　}
}

/**
* 
* @param array 数组
* @param index 数组中的索引
* @param length 树中元素个数
*/
public void heapify(int [] array,int index,int length){
　　int present=index;//当前索引
　　int value=array[index];
　　int largest=array[index];
　　int largest_index=index;
　　while((2*present+1)<length){//判断是否有儿子
　　　　if(array[2*present+1]>largest){
　　　　largest=array[2*present+1];
　　　　largest_index=2*present+1;
　　}
　　if((2*present+2)<length&;&;array[2*present+2]>largest){
　　　　largest=array[2*present+2];
　　　　largest_index=2*present+2;
　　}
　　if(largest_index!=present){
　　　　array[present]=largest;
　　　　present=largest_index;
　　　　largest=value;
　　}else{
　　　　break;
　　}
　　}
　　array[present]=value;
}

 

/**
* 最坏时间O(n2)----在数组已经排好序时发生
* O(nlogn)
* @param array
* @param p
* @param r
*/
public void quickSort(int []array,int p,int r){
　　if(p<r){
　　　　int q=partition(array,p,r);
　　　　quickSort(array,p,q-1);
　　　　quickSort(array,q+1,r);
　　}
}

public int partition(int []array,int p,int r){
　　Random random=new Random();
　　exchange(array,r,random.nextInt(r-p+1)+p);//随机取数
　　int x=array[r];
　　int i=p-1;
　　for(int j=p;j<r;j++){
　　　　if(array[j]<=x){
　　　　i=i+1;
　　　　exchange(array,i,j);
　　}
}
　　exchange(array,i+1,r);
　　return i+1;
}

public void exchange(int []array,int p,int q){
　　int k=array[p];
　　array[p]=array[q];
　　array[q]=k;
}