九大排序算法Java实现

之前学习数据结构与算法时花了三天时间整理九大排序算法，并采用Java语言来实现，今天第一次写博客，刚好可以把这些东西从总结的文档中拿出来与大家分享一下，同时作为自己以后的备忘录。

1.排序算法时间复杂度、稳定性分类：

2.排序算法问题描述与实现

2.1冒泡排序（交换排序-稳定）

【问题描述】对于一个int数组，请编写一个冒泡排序算法，对数组元素排序。 
问题分析：冒泡排序，顾名思义，从前往后遍历，每次遍历在末尾固定一个最大值。

易错点：每次内层循环结束都会在末尾确定一个元素的位置，因此内层循环的判断条件要减去外层的循环次数i

public int[] BobbleSort(int[] array){

for(int i=0;i<array.length-1;i++){

for(int j=0;j<array.length-1-i;j++){  //内层循环，注意array.length-1-i，一定要-i

swap(array,j,j+1);//交换数据元素的方法

}

}

return array;

}

public void swap(int[] array,int i,int j){//交换数据元素的方法

if(array[i]>array[j]){

int temp=array[i];

array[i]=array[j];

array[j]=temp;

}

}

冒泡排序的改进：加一个布尔型的flag，当某一趟冒泡排序没有元素交换时，则冒泡结束，元素已经有序，可以有效的减少冒泡次数。

2.2 选择排序（不稳定）

【问题描述】对于一个int数组，请编写一个选择排序算法，对数组元素排序。  
问题分析：选择排序，从前往后遍历，每次遍历从头开始依次选择最小的来排序。

注意点：

【初始升序】：交换0次，时间复杂度为o(n); 【初始降序】：交换n-1次，时间复杂度为o(n^2)。

【特点】：交换移动数据次数少，比较次数多。

public int[] choose(int[] array){

for(int i=0;i<array.length-1;i++){

int min=i;

for (int j = i+1; j < array.length; j++) {

if(array[min]>array[j])

min=j;

}

if(i!=min){

swap(array,i,min);

}

}

return array;

}

public void swap(int[] array,int i,int j){

if(array[i]>array[j]){

int temp=array[i];

array[i]=array[j];

array[j]=temp;

}

}

2.3 直接插入排序（稳定的 ）

【问题描述】对于一个int数组，请编写一个插入排序算法，对数组元素排序。  
问题分析：插入排序，从前往后遍历，每次遍历确定一个元素的位置，下一个元素从后往前依次与排序好的元素比较，类似于摸扑克牌。

注意点：假定n是数组的长度，首先假设第一个元素被放置在正确的位置上，这样仅需从1-n-1范围内对剩余元素进行排序。对于每次遍历，从0-i-1范围内21.的元素已经被排好序，每次遍历的任务是：通过扫描前面已排序的子列表，将位置i处的元素定位到从0到i的子列表之内的正确的位置上。将arr[i]复制为一个名为target的临时元素。向下扫描列表，比较这个目标值target与arr[i-1]、arr[i-2]的大小，依次类推。这个比较过程在小于或等于目标值的第一个元素(arr[j])处停止，或者在列表开始处停止（j=0）。在arr[i]小于前面任何已排序元素时，后一个条件（j=0）为真，因此，这个元素会占用新排序子列表的第一个位置。在扫描期间，大于目标值target的每个元素都会向右滑动一个位置（arr[j]=arr[j-1]）。一旦确定了正确位置j，目标值target（即原始的arr[i]）就会被复制到这个位置。与选择排序不同的是，插入排序将数据向右滑动，并且不会执行交换。

public int[] insert1(int[] array){

for(int i=1;i<array.length;i++){

int j=i;

int temp=array[i];

while(j>0&&array[j-1]>temp){

array[j]=array[j-1];//元素右移

j--;

}

array[j]=temp;

}

return array;

}

2.4 希尔排序（2个for循环+最后一个while，不稳定）

问题描述：对于一个int数组，请编写一个希尔排序算法，对数组元素排序。  
问题分析：希尔排序是改进的插入排序，算法先将要排序的一组数按某个增量d（n/2,n为要排序数的个数）分成若干组，每组中记录的下标相差d.对每组中全部元素进行直接插入排序，然后再用一个较小的增量（d/2）对它进行分组，在每组中再进行直接插入排序。当增量减到1时，进行直接插入排序后，排序完成。希尔排序法(缩小增量法) 属于插入类排序，是将整个无序列分割成若干小的子序列分别进行插入排序的方法。

• public int[] hillInsert(int[] array){
• for (int d = array.length>>1; d>=1; d=d>>1) {
• for(int i=d;i<array.length;i++){
• int j=i;
• int temp=array[i];
• while(j>=d&&array[j-d]>temp){
• array[j]=array[j-d];
• j-=d;
• }
• array[j]=temp;
• }
• }
• return array;
• }

2.5.堆排序（不稳定）

 问题描述：对于一个int数组，请编写一个堆排序算法，对数组元素排序。  
问题分析：堆数据结构是一种数组对象，它可以被视为一科完全二叉树结构（完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树）。它的特点是父节点的值大于（小于）两个子节点的值（分别称为大顶堆和小顶堆）。它常用于管理算法执行过程中的信息，应用场景包括堆排序，优先队列等。

完全二叉树性质：如果i>1,则双亲是结点[i/2]。也就是说下标i与2i和2i+1是双亲子女关系。 当排序对象为数组时，下标从0开始，所以下标 i 与下标 2i+1和2i+2是双亲子女关系。

算法思路：

• 堆排序：（大根堆）
• ①将存放在array[0，...，n-1]中的n个元素建成初始堆；
• ②将堆顶元素与堆底元素进行交换，则序列的最大值即已放到正确的位置；
• ③但此时堆被破坏，将堆顶元素向下调整使其继续保持大根堆的性质，再重复第②③步，直到堆中仅剩下一个元素为止。
• 堆排序算法的性能分析：
• 空间复杂度:o(1)；
• 时间复杂度:建堆：o(n)，每次调整o(log n)，故最好、最坏、平均情况下：o(n*logn);
• 稳定性：不稳定

• public static int[] heapMax(int[] array){  //建立大根堆
• for(int i=(array.length-2)/2;i>=0;i--){
• buildHeap(array,i,array.length);
• }
• return array;
• }
• private static void buildHeap(int[] array, int k, int length) {  //建堆方法
• // TODO Auto-generated method stub
• int temp=array[k];
• for(int i=2*k+1;i<length-1;i=2*i+1){
• if(array[i]<array[i+1]){
• i++;
• }
• if(temp>=array[i])
• break;
• else{
• array[k]=array[i];
• k=i;
• }
• }
• array[k]=temp;
• }
• public static int[] heapSortArray(int[] array){ //进行堆排序
• array=heapMax(array);
• for (int i =array.length-1; i >0; i--) {
• int temp=array[0];
• array[0]=array[i];
• array[i]=temp;
• buildHeap(array,0,i);
• }
• return array;
• }

2.6 归并排序（稳定）

问题描述：对于一个int数组，请编写一个归并排序算法，对数组元素排序。 
问题分析：归并排序是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide
and Conquer）的一个非常典型的应用。首先考虑下如何将将二个有序数列合并。这个非常简单，只要从比较二个数列的第一个数，谁小就先取谁，取了后就在对应数列中删除这个数。然后再进行比较，如果有数列为空，那直接将另一个数列的数据依次取出即可。可以看出合并有序数列的效率是比较高的，可以达到O(n)。

解决了上面的合并有序数列问题，再来看归并排序，其的基本思路就是将数组分成二组A，B，如果这二组组内的数据都是有序的，那么就可以很方便的将这二组数据进行排序。如何让这二组组内数据有序了？

可以将A，B组各自再分成二组。依次类推，当分出来的小组只有一个数据时，可以认为这个小组组内已经达到了有序，然后再合并相邻的二个小组就可以了。这样通过先递归的分解数列，再合并数列就完成了归并排序。

public
int[]
mergeSort(int[]
A, int n) {

//归并排序，递归做法，分而治之

mSort(A,0,n-1);

return A;

}

private void mSort(int[] A,int
left,int right){

//分而治之，递归常用的思想，跳出递归的条件

if(left>=right){

return;

}

//中点

int
mid
= (left+right)/2;

//有点类似后序遍历！

mSort(A,left,mid);

mSort(A,mid+1,right);

merge(A,left,mid,right);

}

//将左右俩组的按序子序列排列成按序序列

private void
merge(int[]
A,int left,int mid,int rightEnd){

//充当tem数组的下标

int
record
= left;

//最后复制数组时使用

int
record2
= left;

//右子序列的开始下标

int
m =mid+1;

int[]
tem
= new
int[A.length];

//只要left>mid或是m>rightEnd，就跳出循环

while(left<=mid&&m<=rightEnd){

if(A[left]<=A[m]){

tem[record++]=A[left++];

}else{

tem[record++]=A[m++];

}

}

while(left<=mid){

tem[record++]=A[left++];

}

while(m<=rightEnd){

tem[record++]=A[m++];

}

//复制数组

for(
;record2<=rightEnd;record2++){

A[record2] = tem[record2];

}

}

2.7 快速排序算法（不稳定）

问题描述：对于一个int数组，请编写一个快速排序算法，对数组元素排序。 
问题分析：快速排序（Quicksort）是对冒泡排序的一种改进，使用分治法（Divide and conquer）策略来把一个序列（list）分为两个子序列（sub-lists）。

从数列中挑出一个元素，称为”枢轴”（pivot）。重新排序数列，所有元素比枢轴值小的摆放在基准前面，所有元素比枢轴值大的摆在枢轴的后面（相同的数可以到任一边）。

在这个分区结束之后，该枢轴就处于数列的中间位置。这个称为分区（partition）操作。递归地（recursive）把小于枢轴值元素的子数列和大于枢轴值元素的子数列排序。

• public static final void quickSort(int[] array, intstart, intend) {
• // i相当于助手1的位置，j相当于助手2的位置
• int i = start, j = end;
• int pivot = array[i]; // 取第1个元素为基准元素
• int emptyIndex = i; // 表示空位的位置索引，默认为被取出的基准元素的位置
• // 如果需要排序的元素个数不止1个，就进入快速排序(只要i和j不同，就表明至少有2个数组元素需要排序)
• while (i < j) {
• // 助手2开始从右向左一个个地查找小于基准元素的元素
• while (i < j && pivot <= array[j])
• j--;
• if (i < j) {
• // 如果助手2在遇到助手1之前就找到了对应的元素，就将该元素给助手1的"空位"，j成了空位
• array[emptyIndex] = array[emptyIndex = j];
• }
• // 助手1开始从左向右一个个地查找大于基准元素的元素
• while (i < j && array[i] <= pivot)
• i++;
• if (i < j) {
• // 如果助手1在遇到助手2之前就找到了对应的元素，就将该元素给助手2的"空位"，i成了空位
• array[emptyIndex] = array[emptyIndex = i];
• }
• }
• // 助手1和助手2相遇后会停止循环，将最初取出的基准值给最后的空位
• array[emptyIndex] = pivot;
• // =====本轮快速排序完成=====
• // 如果分割点i左侧有2个以上的元素，递归调用继续对其进行快速排序
• if (i - start > 1) {
• quickSort(array, 0, i - 1);
• }
• // 如果分割点j右侧有2个以上的元素，递归调用继续对其进行快速排序
• if (end - j > 1) {
• quickSort(array, j + 1, end);
• }
• }

算法优化：选取基准轴点时采用三数取中法：

public class Quick {

public void sort(int[] array){

int start=0;

int end=array.length-1;

quickSort(array,start,end);

}

public void quickSort(int[] array, int start, int end) {

// TODO Auto-generated method stub

int i=start;

int j=end;

int emptyIndex=start;

int pivot=middle3(array,start,end);

while(i<j){

while(i<j&&array[j]>=pivot){

j--;

}

if(i<j)

array[emptyIndex]=array[emptyIndex=j];

while(i<j&&array[i]<=pivot){

i++;

}

if(i<j)

array[emptyIndex]=array[emptyIndex=i];

}

array[emptyIndex]=pivot;

if(i-start>1)

quickSort(array,start,i-1);

if(end-j>1)

quickSort(array,j+1,end);

}

2.8 计数排序算法（稳定，也是桶排序）

问题描述：对于一个int数组，请编写一个计数排序算法，对数组元素排序。 
问题分析：

1. 提前必须是已知待排序的关键字为整型且范围已知。 
2. 时间复杂度为O(n+k)，n指的是桶的个数，k指的是待排序数组的长度，不是基于比较的排序算法，因此效率非常之高。 
3. 稳定性好，这个是计数排序非常重要的特性，可以用在后面介绍的基数排序中。 
4. 但需要一些辅助数组，如C[0..k]，因此待排序的关键字范围0~k不宜过大。

public int[] countingSort(int[] A, int n) {

if(A==null ||n<2){

return A;

}

//找出桶的范围,即通过要排序的数组的最大最小值来确定桶范围

int min=A[0];

int max=A[0];

for(int i=0;i<n;i++){

min=Math.min(A[i],min);

max=Math.max(A[i],max);

}

//确定桶数组，桶的下标即为需排序数组的值，桶的值为序排序数同一组值出现的次数

int[] arr = new int[max-min+1];

//往桶里分配元素

for(int i=0;i<n;i++){

arr[A[i]-min]++;

}

//从桶中取出元素

int index=0;

for(int i=0;i<arr.length;i++){

while(arr[i]-->0){

A[index++]=i+min;

}

}

return A;

}

}

2.9 基数排序算法（稳定）

问题描述：对于一个int数组，请编写一个基数排序算法，对数组元素排序。 
问题分析：

基数排序（Radix sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。

键字范围0~k不宜过大。

public void sort(int[] array){

int max=0;

int d=0;// 位数

for (int i = 0; i < array.length; i++) {

max=Math.max(max, array[i]);

}

while(max>0){

max/=10;

d++;

}

int t=0;

int m=1;

int n=1;

int[][] temp=new int[10][array.length];

int[] order=new int[10];

while(m<=d){

for (int i = 0; i < array.length; i++) {

int k=((array[i]/n)%10);

temp[k][order[k]++]=array[i];

}

for (int i = 0; i < 10; i++) {

if(order[i]!=0){

for (int j = 0; j <order[i]; j++) {

array[t++]=temp[i][j];

}

order[i]=0;

}

}

t=0;

n=n*10;

m++;

}

}

采用链表的方式来实现基数排序：

//基数排序开始
public static void radixSort(int[] array){
int max=array[0];
for (int i = 0; i < array.length; i++) {
max=Math.max(max, array[i]);
}
int time=0;
while(max!=0){
time++;
max=max/10;
}
List<List<Integer>> list=new ArrayList<List<Integer>>();
for(int i=0;i<10;i++){
List<Integer> item=new ArrayList<Integer>();
list.add(item);
}

for (int i = 0; i < time; i++) {
for (int j = 0; j < array.length; j++) {
int index=array[j]%(int)Math.pow(10, i+1);
index/=(int)Math.pow(10, i);
list.get(index).add(array[j]);
}
int count=0;
for (List<Integer> a : list) {
for (int m : a) {
if(m!=0){
array[count++]=m;
}
}
a.clear();
}
}
}

//基数排序结束