冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序java实现

package alogrithm;

import java.util.Arrays;
import java.util.Random;

public class Sort {
	
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
        int[] arr= new int[]{8,4,7,10,2,5,3,6,9};
        //bubbleSort(arr);
        //selectedSort(arr);
        //insertSort(arr);
        //quickSort(arr,0,arr.length-1);
        //shellSort(arr);
        //mergeSort(arr);
        heapSort(arr);
        System.out.print(Arrays.toString(arr));
	}
	//元素交换
	public static void exchange(int[] arr,int i,int j){
		int temp=0;
		temp=arr[i];
		arr[i]=arr[j];
		arr[j]=temp;
	}
	//冒泡排序
	//冒泡排序并不会去改变数组中之前相同的元素的相对位置，为稳定排序算法
	public static void bubbleSort(int[] arr){
		if(arr.length==0) return ;
		for(int i=arr.length-1;i>0;i--){
			for(int j=0;j<i;j++){
				if(arr[j]>arr[j+1]){
					exchange(arr,j,j+1);
				}
			}
		}
	}
	//选择排序
	//选择排序会去改变数组中之前相同的元素的相对位置，为不稳定排序算法
	public static void selectedSort(int[] arr){
		if(arr.length==0) return;
		int index=0;
		for(int i=0;i<arr.length-1;i++){
			index=i;
			for(int j=i;j<arr.length;j++){
				if(arr[index]>arr[j]){
					index=j;
				}
			}
			if(index!=i){
				exchange(arr,i,index);
			}
		}
	}
	//插入排序
	//插入排序并不会去改变数组中之前相同的元素的相对位置，为稳定排序算法
	public static void insertSort(int[] arr){
		if(arr.length==0) return;
		for(int i=1;i<arr.length;i++){
			for(int j=i;j>0;j--){
				if(arr[j]<arr[j-1]){
					exchange(arr,j,j-1);
				}
			}
		}
	}
	//快速排序
	//快速排序会去改变数组中之前相同的元素的相对位置，为不稳定排序算法
	//快速排序辅助函数
	public static int helpQuick(int[] arr,int low,int high){
		Random random = new Random(47);
	    int index = random.nextInt(high-low+1)+low;
	    exchange(arr,index,high);
	    int min=low-1;
	    for(int i=low;i<high;i++){
	    	if(arr[i]<arr[high]){
	    		++min;
	    		if(min!=i)
	    			exchange(arr,min,i);
	    	}
	    }
	    ++min;
	    exchange(arr,min,high);
	    return min;
		
	}
	//快速排序函数
	public static void quickSort(int[] arr,int low,int high){
		int index=helpQuick(arr,low,high);
		if(index>low)
			quickSort(arr,0,index-1);
		if(index<high)
			quickSort(arr,index+1,high);
	} 
	//希尔排序
	//希尔排序会去改变数组中之前相同的元素的相对位置，为不稳定排序算法
    public static void shellSort(int[] arr){
    	int length=arr.length;
    	int h=1;
    	while(h<length/3) h=3*h+1;
    	while(h>=1){
    		for(int i=h;i<length;i++){
    			for(int j=i;j>=h;j-=h){
    				if(arr[j]<arr[j-h])
    					exchange(arr,j,j-h);
    			}
    		}
    		h=h/3;
    	}
    }
    //归并排序
    //归并排序不会去改变数组中之前相同的元素的相对位置，为稳定排序算法
    //归并排序辅助函数--合并已经排序的两个数组
    
    public static void merge(int[] arr,int low,int mid,int high){
    	int i=low,j=mid+1;
    	int[] c=new int[arr.length];
    	for(int k=low;k<=high;k++){
    		c[k]=arr[k];
    	}
    	for(int k=low;k<=high;k++){
    		if(i>mid) arr[k]=c[j++];
    		else if(j>high) arr[k]=c[i++];
    		else if(c[j]<c[i]) arr[k]=c[j++];
    		else arr[k]=c[i++];
    	}
    }
    public static void mergeSort(int[] arr){
    	mergeSort(arr,0,arr.length-1);
    }
    public static void mergeSort(int[] arr,int low,int high){
    	if(high<=low) return;
    	int mid =low+(high-low)/2;
    	mergeSort(arr,low,mid);
    	mergeSort(arr,mid+1,high);
    	merge(arr,low,mid,high);
    }
    //堆排序
    //帮助函数，堆的下沉
    public static void sink(int[] arr,int k,int N){
    	while(k*2+1<=N){
    		int j=2*k+1;
    		if(j<N&&arr[j]<arr[j+1]) j++;
    		if(arr[k]>arr[j]) break;
    		exchange(arr,k,j);
    		k=j;
    	}
    }
    //堆排序
    public static void heapSort(int[] arr){
    	int N=arr.length-1;
    	for(int k=N/2;k>=0;k--){
    		sink(arr,k,N);
    	}
    	while(N>0){
    		exchange(arr,0,N--);
    		sink(arr,0,N);
    	}
    }
}