JAVA排序算法实现和比较：冒泡，桶，选择，快排，归并

一。冒泡排序：

实现思想：

重复地走访过要排序的元素列，一次比较两个相邻的元素，如果他们的顺序（如从大到小、首字母从A到Z）错误就把他们交换过来。走访元素的工作是重复地进行直到没有相邻元素需要交换，也就是说该元素已经排序完成。

代码：

package NumSort;

//冒泡排序
public class BubbleSort {
    public static void main(String[] args){
        int num[] ={23,1,56,78,5,43,34,34,78,9,99};
        int n = num.length;
        int temp;
        for(int i=0;i<n;i++){
            for(int j=0;j<n-1-i;j++){
                if(num[j]>num[j+1]){
                    temp = num[j+1];
                    num[j+1] = num[j];
                    num[j] = temp;
                }
            }
        }
        for(int i=0;i<n;i++){
            System.out.print(num[i]+" ");
        }
    }
}

 

二。桶排序：

实现思想：

桶排序 (Bucket sort)或所谓的箱排序，工作的原理是将数组分到有限数量的桶子里。每个桶子再个别排序。

代码：

package NumSort;

//桶排序
public class BucketSort {
    public static void main(String[] args){
        int num[] ={23,1,56,78,5,43,34,34,78,9,99};
        int[] a = new int[100];
        for(int i=0;i<100;i++){
            a[i] = 0;
        }
        for(int i=0;i<num.length;i++){
            a[num[i]] += 1;
        }
        for(int i=0;i<100;i++){
            if(a[i]>0){
                for(int j=0;j<a[i];j++){
                    System.out.print(i+" ");
                }
            }
        }
    }
}

 

三。选择排序：

实现思想：

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。

代码：

package NumSort;

//选择排序
public class SelectSort {
    public static void main(String[] args){
        int num[] ={23,1,56,78,5,43,34,34,78,9,99};
        int n = num.length;
        int temp;
        for(int i=0;i<n;i++){
            for(int j=i+1;j<n;j++){
                if(num[i]>num[j]){
                    temp = num[i];
                    num[i] = num[j];
                    num[j] = temp;
                }
            }
        }
        for(int i=0;i<n;i++){
            System.out.print(num[i]+" ");
        }
    }
}

 

四。快速排序：

实现思想：

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码：

package NumSort;

import java.util.Arrays;

public class QuickSort2 {
    public static void main(String[] args){
        int num[] = {23,5,67,98,76,2,1,5,65,23,34};
        quickS(num,0,num.length-1);
        System.out.println(Arrays.toString(num));
    }
    public static void quickS(int num[],int left,int right){
        int i = left;
        int j = right;
        int temp;
        int middle = num[left];
        if(left>=right){
            return;
        }
        while(i!=j){
            while(num[j]>middle&&i<j){
                j--;
            }
            if(i<j){
                temp = num[i];
                num[i] = num[j];
                num[j] = temp;
                i++;
            }
            while(num[i]<middle&&i<j){
                i++;
            }
            if(i<j){
                temp = num[i];
                num[i] = num[j];
                num[j] = temp;
                j--;
            }
        }
        quickS(num,left,i-1);
        quickS(num,i+1,right);
    }
}

 

五。归并排序：

实现思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。

代码：

package NumSort;

import java.util.Arrays;

public class MergeSort {
    public static void main(String[] args){
        int num[] = {34,5,23,123,8,76,98,65,34,65,99};
        MergeS(num,0,num.length-1);
        System.out.println(Arrays.toString(num));
    }
    public static void Merge(int num[],int low,int middle,int high){
        int i = low;
        int j = middle+1;
        int k = 0;
        int B[] = new int[high-low+1];
        while(i<=middle&&j<=high){
            if(num[i]<=num[j]){
                B[k] = num[i];
                k++;
                i++;
            }
            else{
                B[k] = num[j];
                k++;
                j++;
            }
        }
        while(i<=middle){
            B[k++] = num[i++];
        }
        while(j<=high){
            B[k++] = num[j++];
        }
        //System.arraycopy(B, 0, num, 0, num.length);
        for(int l=0;l<B.length;l++){
            num[low+l] = B[l];
        }
    }
    public static void MergeS(int num[],int low,int high){
        int middle = (low+high)/2;
        if(low<high){
            MergeS(num,low,middle);
            MergeS(num,middle+1,high);
            Merge(num,low,middle,high);
        }
    }
}

 

六。希尔排序：

先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2<d1重复上述的分组和排序，直至所取的增量 =1( <  …<d2<d1)，即所有记录放在同一组中进行直接插入排序为止。

七。堆排序：

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆，是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值，即A[PARENT[i]] >= A[i]。在数组的非降序排序中，需要使用的就是大根堆，因为根据大根堆的要求可知，最大的值一定在堆顶。

八。基数排序：

第一步（来自百度百科）

以LSD为例，假设原来有一串数值如下所示：

73, 22, 93, 43, 55, 14, 28, 65, 39, 81

首先根据个位数的数值，在走访数值时将它们分配至编号0到9的桶子中：

0

1 81

2 22

3 73 93 43

4 14

5 55 65

6

7

8 28

9 39

第二步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

81, 22, 73, 93, 43, 14, 55, 65, 28, 39

接着再进行一次分配，这次是根据十位数来分配：

0

1 14

2 22 28

3 39

4 43

5 55

6 65

7 73

8 81

9 93

第三步

接下来将这些桶子中的数值重新串接起来，成为以下的数列：

14, 22, 28, 39, 43, 55, 65, 73, 81, 93

这时候整个数列已经排序完毕；如果排序的对象有三位数以上，则持续进行以上的动作直至最高位数为止。

LSD的基数排序适用于位数小的数列，如果位数多的话，使用MSD的效率会比较好。MSD的方式与LSD相反，是由高位数为基底开始进行分配，但在分配之后并不马上合并回一个数组中，而是在每个“桶子”中建立“子桶”，将每个桶子中的数值按照下一数位的值分配到“子桶”中。在进行完最低位数的分配后再合并回单一的数组中。

九。各排序算法比较：

图片来自网络：