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);
}
}
}