经典排序java_七大经典排序（Java版）

//希尔排序

public static void shellSort(inta[]){for(int r = a.length/2 ; r >= 1; r/=2){for(int i = r; i < a.length ; i++){int temp =a[i];int j = i -r;while(j >= 0 && temp

a[j+r] =a[j];

j-=r;

}

a[j+r] =temp;

}

}

}

快速排序算法

1.在待排序的元素任取一个元素作为基准(通常选第一个元素，但最的选择方法是从待排序元素中随机选取一个作为基准)，称为基准元素；

2.将待排序的元素进行分区，比基准元素大的元素放在它的右边，比其小的放在它的左边；

3.对左右两个分区重复以上步骤直到所有元素都是有序的。

public static void quickSort3(int arr[],int _left,int_right){int left =_left;int right =_right;int temp = 0;if(left <= right){ //待排序的元素至少有两个的情况

temp= arr[left]; //待排序的第一个元素作为基准元素

while(left != right){ //从左右两边交替扫描，直到left = right

while(right > left && arr[right] >=temp){

right--; //从右往左扫描，找到第一个比基准元素小的元素

}

arr[left]=arr[right];while(left < right && arr[left] <=temp){

left++; //从左往右扫描，找到第一个比基准元素大的元素

}

arr[right]=arr[left];

}

arr[right]= temp; //基准元素归位

quickSort3(arr,_left,left-1); //对基准元素左边的元素进行递归排序

quickSort3(arr, right+1,_right); //对基准元素右边的进行递归排序

}

}

堆排序算法

堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。首先简单了解下堆结构。

堆：

堆是具有以下性质的完全二叉树：

每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆；或者每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆。

堆排序的基本思想：将待排序序列构造成一个大顶堆，此时，整个序列的最大值就是堆顶的根节点。将其与末尾元素进行交换，此时末尾就为最大值。然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

堆排序的基本步骤：

1.构造初始堆。将给定无序序列构造成一个大顶堆(一般升序采用大顶堆，降序采用小顶堆)。

2.将堆顶元素与末尾元素进行交换，使末尾元素最大。然后继续调整堆，再将堆顶元素与末尾元素交换，得到第二大元素。如此反复进行交换、重建、交换。

public classHeapSort {public static voidmain(String []args){int []arr = {9,8,7,6,5,4,3,2,1};

sort(arr);

System.out.println(Arrays.toString(arr));

}public static void sort(int[]arr){//1.构建大顶堆

for(int i=arr.length/2-1;i>=0;i--){

adjustHeap(arr,i,arr.length);

}

for(int j=arr.length-1;j>0;j--){

swap(arr,0,j);

adjustHeap(arr,0,j);

}

}// 调整大顶堆

public static void adjustHeap(int []arr,int i,intlength){int temp = arr[i];

for(int k=i*2+1;k

if(k+1

k++;

}if(arr[k] >temp){//如果子节点大于父节点，将子节点值赋给父节点

arr[i] =arr[k];

i=k;

}else{break;

}

}

arr[i]= temp;

}//交换元素

public static void swap(int []arr,int a ,intb){int temp=arr[a];

arr[a]=arr[b];

arr[b]=temp;

}

}

归并排序

归并排序(MERGE-SORT)是利用归并的思想实现的排序方法，该算法采用经典的分治(divide-and-conquer)策略(分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。

public classMergeSort {public static voidmain(String []args){int []arr = {9,8,7,6,5,4,3,2,1};

sort(arr);

System.out.println(Arrays.toString(arr));

}public static void sort(int[]arr){int []temp = new int[arr.length];//在排序前，先建好一个长度等于原数组长度的临时数组，避免递归中频繁开辟空间

sort(arr,0,arr.length-1,temp);

}private static void sort(int[] arr,int left,int right,int[]temp){if(left

sort(arr,left,mid,temp);//左边归并排序，使得左子序列有序

sort(arr,mid+1,right,temp);//右边归并排序，使得右子序列有序

merge(arr,left,mid,right,temp);//将两个有序子数组合并操作

}

}private static void merge(int[] arr,int left,int mid,int right,int[] temp){int i = left;

int j = mid+1;

int t = 0;

while (i<=mid && j<=right){if(arr[i]<=arr[j]){

temp[t++] = arr[i++];

}else{

temp[t++] = arr[j++];

}

}while(i<=mid){

temp[t++] = arr[i++];

}while(j<=right){

temp[t++] = arr[j++];

}

t= 0;//将temp中的元素全部拷贝到原数组中

while(left <=right){

arr[left++] = temp[t++];

}

}

}

各个排序算法比较：

排序算法

平均速度

最坏情况

是否稳定

冒泡排序

O( n^2)

O( n^2)

稳定

快速排序

O(nlogn)

O( n^2)

不稳定

选择排序

O( n^2)

O( n^2)

不稳定

插入排序

O( n^2)

O( n^2)

稳定

堆排序

O(nlogn)

O(nlogn)

不稳定

Shell排序

O( n^(3/2) )

O( n^2)

不稳定

合并排序

O(nlogn)

O(nlogn)

稳定