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

/**
* 插入排序
* 时间复杂度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) {// 右移
array[position] = array[position - 1];
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);
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];
r++;
}else {
array[k]=array1[l];
l++;
}
}
while(l<array1.length){
array[k]=array1[l];
l++;
k++;
}
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;
}