import java.util.Arrays;
public class AllSort {
public static void main(String[] args){
int[] arr={2,9,3,6,1,0,1};
//selectSort(arr);
//bubbleSort(arr);
//insertSort(arr);
//shellSort(arr);
//shellSort2(arr);
//mergeSort(arr);
//quickSort(arr);
heapSort(arr);
for(int i:arr){
System.out.print(i+" ");
}
}
public static void swap(int[] arr,int i,int j){
int temp=arr[i];
arr[i]=arr[j];
arr[j]=temp;
}
// 最好的情况：正序，交换0次，比较O(n^2)
// 最坏的情况：交换n-1次，比较O(n^2)
// 平均O(n^2)
// 不稳定 eg：5 6 5 2 原来相等的数据排序后交换了顺序
// 空间复杂度O(1)
public static void selectSort(int[] arr){
if(arr==null || arr.length ==0){
return;
}
for(int i=0;i=0;i--){
isSwap=false;
for(int j=0;jarr[j+1]){
swap(arr, j, j+1);
isSwap=true;
}
}
if(!isSwap) return;
}
}
//最好的情况：正序，比较n-1次，移动0次，复杂度O(n)
//最坏的情况：逆序，交换O(n^2)，移动O(n^2)，复杂度O(n^2)
//平均：O(n^2)
//稳定的
//空间O(1)
public static void insertSort(int[] arr){
if(arr==null || arr.length ==0){
return;
}
for(int i=1;i=0 && arr[j]>key) {
arr[j+1]=arr[j];
}
arr[j+1]=key;
}
}
/*改进的插入排序算法
*eg：主键最小的元素在最后面，则将它移动到正确位置需要移动n-1次
*希尔排序是为了改进插入排序，交换不相邻的元素以对数组的局部进行排序，
*并最终用插入排序将局部有序的数组排序。
*把记录按下标的一定增量分组，对每一组数据使用插入排序，
*一个h有序数组则是h个有序子数组组成的，
*随着增量逐渐减少每组包含的关键词越来越多，
*当增量减至1时，整个文件恰被分成一组，算法便终止。
*/
//最好 O(n^s)，最坏O(n^s)，实际复杂度和增量序列有关，
//s[1,2]之间，取决于增量序列，一般最好O(n^1.3)
//shell在排好序的情况下比插入排序要差的
//eg：1234，插入比较3次，shell，d=2，[1,3][2,4]比较2次，
//然后d=d/2=1[1,2,3,4]比较3次，总共比较5次
public static void shellSort(int[] arr){
if(arr==null ||arr.length==0){
return;
}
int N=arr.length;
int h=1;
while(h < N/3) h=3*h+1;//1,4,13,40,121,...
while (h >= 1) {
//将数组变为h有序
for (int i = h; i < N; i++) {
//将a[i]插入到a[i-h],a[i-2*h],a[i-3*h]...通过交换相邻元素法
for(int j=i;j>=h&&arr[j]=1){
for(int i=gap;i=0 && arr[j-gap]>key){
arr[j]=arr[j-gap];
j-=gap;
}
arr[j]=key;
}
gap=gap/3;
}
}
//最好&最坏&平均O(nlogn)，空间O(n)，稳定的
public static void mergeSort(int[] arr){
if(arr==null || arr.length==0){
return;
}
mergeSort(arr,0,arr.length-1);
}
private static void mergeSort(int[] arr,int lo,int hi){
if(lo>=hi){
return;
}
int mid=(lo+hi)>>1;
mergeSort(arr,lo,mid);
mergeSort(arr,mid+1,hi);
merge(arr,lo,mid,hi);
}
private static void merge(int[] arr,int lo,int mid,int hi){
int[] left=Arrays.copyOfRange(arr, lo, mid+1);
int[] right=Arrays.copyOfRange(arr, mid+1, hi+1);
int i=0,j=0,k=lo;
while (i=hi){
return;
}
int j=partition(arr,lo,hi);
quickSort(arr, lo, j-1);
quickSort(arr, j+1, hi);
}
private static int partition(int [] arr,int lo,int hi){
int i=lo;
int key=arr[lo];
int j=hi+1;
while (true) {
while (arr[++i]key) {
if(j==lo) break;
}
if(i>=j) break;
swap(arr, i, j);
}
swap(arr, lo, j);
return j;
}
//建堆O(n)，最好，最坏，平均nlogn，空间O(1)
public static void heapSort(int[] arr){
if(arr==null||arr.length==0){
return;
}
for(int i=(arr.length-1)/2;i>=0;i--){
adjustMaxHeap(arr,i,arr.length);
}
for (int i = arr.length-1; i >= 0; i--) {
swap(arr, i, 0);
adjustMaxHeap(arr, 0, i);
}
}
private static void adjustMaxHeap(int[] arr,int i,int lastIndex){
int left=2*i+1;
int right=2*i+2;
int maxIndex=i;
if(left arr[maxIndex]){
maxIndex=left;
}
if(rightarr[maxIndex]){
maxIndex=right;
}
if(i != maxIndex){
swap(arr, maxIndex, i);
adjustMaxHeap(arr, maxIndex, lastIndex);
}
}
}
