十大经典排序算法

排序算法是《数据结构与算法》中最基本的算法之一。排序算法可以分为内部排序和外部排序。

　　①内部排序：数据记录在内存中进行排序，常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。

　　②外部排序：因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

　　十大排序算法之间的比较如下所示：

一、冒泡排序

　　冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

作为最简单的排序算法之一，冒泡排序给我的感觉就像 Abandon 在单词书里出现的感觉一样，每次都在第一页第一位，所以最熟悉。冒泡排序还有一种优化算法，就是立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。但这种改进对于提升性能来说并没有什么太大作用。

（1）算法步骤：

　　①比较相邻的元素。如果第一个比第二个大，就交换他们两个。

　　②对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

　　③针对所有的元素重复以上的步骤，除了最后一个。

　　④持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

（2）最好情况：当输入的数据已是有序时

（3）最坏情况：当输入的数据是逆序时

（4）动态过程展示

 

（5）核心代码实现

int[] bubblesort(int []num){
    int len=num.length;
    int temp=0;
    for(int i=0;i<len-1;i++){
        for(int j=0;j<len-i-1;j++){
            if(num[j]>num[j+1]){
                temp=num[j];
                num[j]=num[j+1];
                num[j+1]=temp;
            }
        }
    }
    return num;
}

 

二、插入排序

　　插入排序（Insert Sort）的代码实现虽然没有冒泡排序和选择排序那么简单粗暴，但它的原理应该是最容易理解的了，因为只要打过扑克牌的人都应该能够秒懂。插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序和冒泡排序一样，也有一种优化算法，叫做拆半插入。

（1）算法步骤：

　　①将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。

　　②从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）

（2）最好情况：当输入的数据已是有序时

（3）最坏情况：当输入的数据是逆序时

（4）动态过程展示

 

（5）核心代码实现

 

int[] insertsort(int []num){
    int len=num.length;
    int temp=0;
    for(int i=1;i<len;i++){
        temp=num[i];                           
        for(int j=i;j>0&&num[j-1]>temp;j--){
            num[j]=num[j-1];
        }
        num[j]=temp;
    }
    return num;
}

 

三、选择排序

选择排序（Select Sort）是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。

（1）算法步骤：

　　①首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。

　　②再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

重复第二步，直到所有元素均排序完毕。

（2）动态过程展示

 

（3）核心代码实现

int[] selectsort(int []num){
    int len=num.length;
    int temp=0;
    int k=0;
    for(int i=0;i<len-1;i++){
        k=i;
        for(int j=i+1;j<len;j++){
            if(num[k]>num[j]){
                k=j;
            }
        }
        if(k!=i){
            temp=num[i];
            num[i]=num[k];
            num[k]=temp;
        }
    }
    return num;
}

四、希尔排序

  希尔排序(Shell Sort)，也称递减增量排序算法，是插入排序的一种更高效的改进版本。但希尔排序是非稳定排序算法。希尔排序是基于插入排序的以下两点性质而提出改进方法的：

　　①插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率；

　　②但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位；

　　希尔排序的基本思想是：先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。

（1）算法步骤：

　　①选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；

　　②按增量序列个数 k，对序列进行 k 趟排序；

　　③每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

（2）动态过程展示

 

（3）核心代码实现

 

int[] shellsort(int []num){
    int len=num.length;
    int temp=0;
    int j=0;
    for(int gap=len/2;gap>0;gap=gap/2){
        for(int i=gap;i<len;i++){
            temp=num[i];
            for(j=i;j>=gap;j-=gap){
                if(num[j-gap]>temp){
                    num[j]=num[j-gap];
                }
                else{
                    break;
                }
            }
            num[j]=temp;
        }
    }
    return num;
}

 

五、归并排序

　　归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。

作为一种典型的分而治之思想的算法应用，归并排序的实现由两种方法：

　　①自上而下的递归；

　　②自下而上的迭代；

　　和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是 O(nlogn) 的时间复杂度。代价是需要额外的内存空间。

（1）算法步骤：

　　①申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；

　　②设定两个指针，最初位置分别为两个已经排序序列的起始位置；

　　③比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；

　　④重复步骤 ③ 直到某一指针达到序列尾；

　　⑤将另一序列剩下的所有元素直接复制到合并序列尾。

（2）动态过程展示

 

（3）核心代码实现

 

void merge(int []num,int low,int mid,int high){
    int []temp=new int[num.length];
    int i=low;
    int j=mid+1;
    int k=0;
    while(i<=mid&&j<=high){
        if(num[i]<num[j]){
            temp[k]=num[i];
            k++;
            i++;
        }
        else{
            temp[k]=num[j];
            k++;
            j++;
        }
    }
    while(i<=mid){
        temp[k]=num[i];
        k++;
        i++;
    }
    while(j<=high){
        temp[k]=num[j];
        k++;
        j++;
    }
    for(int n=0;n<num.lenth;n++){
        num[n+low]=temp[n];
    }
}
void mergesort(int []num;int low;int high){
    int mid=(low+high)/2;
    if(low<high){
        mergesort(num,low,mid);
        mergesort(num,mid+1,high);
        merge(num,low,mid,high);
    }
}

 

六、快速排序

　　快速排序(Quick Sort)是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。

快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists）。快速排序又是一种分而治之思想在排序算法上的典型应用。本质上来看，快速排序应该算是在冒泡排序基础上的递归分治法。快速排序的名字起的是简单粗暴，因为一听到这个名字你就知道它存在的意义，就是快，而且效率高！它是处理大数据最快的排序算法之一了。快速排序的最坏运行情况是 O(n²)，比如说顺序数列的快排。但它的平摊期望时间是 O(nlogn)，且 O(nlogn) 记号中隐含的常数因子很小，比复杂度稳定等于 O(nlogn) 的归并排序要小很多。所以，对绝大多数顺序性较弱的随机数列而言，快速排序总是优于归并排序。

（1）算法步骤：

　　①从数列中挑出一个元素，称为 "基准"（pivot）;

　　②重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；

　　③递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；

（2）动态过程展示

 

（3）核心代码实现

 

int getmidpos(int []num,int low,int high){
    int temp=num[low];
    while(low<high){
        while(low<high&&temp<num[high]){
            high--;
        }
        num[low]=num[high];
        while(low<high&&num[low]<temp){
            low++;
        }
        num[high]=num[low];
    }
    num[low]=temp;
    return low;
}

void quicksort(int []num,int low ,int high){
    if(low<high){
        int mid=getmidpos(num,low,high);
        quicksort(num,low,mid-1);
        quicksort(num,mid+1 ,high);
    }
}

int[] quick(int []num,int low,int high){
    if(num.length>0){
        low=0;
        high=num.length-1;
        quicksort(num,low,high);
    }
    return num;
}

 

七、堆排序

　　堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。分为两种方法：

　　①大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；

　　②小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；

　　堆排序的平均时间复杂度为 Ο(nlogn)。

（1）算法步骤：

　　①创建一个堆 H[0……n-1]；

　　②把堆首（最大值）和堆尾互换；

　　③把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

　　④重复步骤 2，直到堆的尺寸为 1。

（2）动态过程展示

                     

（3）核心代码实现

 

int[] HeapSort(int[] num){
    int[] arr = Arrays.copyOf(num, num.length);
    int len = arr.length;
    buildMaxHeap(arr, len);
    for (int i = len - 1; i > 0; i--) {
        swap(arr, 0, i);
        len--;
        heapify(arr, 0, len);
    }
    return num;
   }

void buildMaxHeap(int[] num, int len) {
    int start=(int) Math.floor(len / 2);
    for (int i = start; i >= 0; i--) {
        heapify(num, i, len);
    }
}

void heapify(int[] num, int i, int len) {
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int largest = i;
    if (left < len && num[left] > num[largest]) {
        largest = left;
    }
    if (right < len && num[right] > num[largest]) {
        largest = right;
    }
    if (largest != i) {
        swap(num, i, largest);
        heapify(num, largest, len);
    }
}

void swap(int[] num, int i, int j) {
    int temp = num[i];
    num[i] = num[j];
    num[j] = temp;
}

 

八、基数排序

　　基数排序（Radix Sort）是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。

（1）算法步骤：

　　①创建一个堆 H[0……n-1]；

　　②把堆首（最大值）和堆尾互换；

　　③把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；

　　④重复步骤 2，直到堆的尺寸为 1。

（2）动态过程展示

 

（2）核心代码实现

 

int[] sort(int[] num) {
    int[] arr = Arrays.copyOf(num, num.length);
    int maxDigit = getMaxDigit(arr);
    return radixSort(arr, maxDigit);
}

    
int getMaxDigit(int[] arr) {
    int maxValue = getMaxValue(arr);
    return getNumLength(maxValue);
}

int getMaxValue(int[] arr) {
    int maxValue = arr[0];
    for (int value : arr) {
        if (maxValue < value) {
            maxValue = value;
        }
    }
    return maxValue;
}

int getNumLength(long num) {
    if (num == 0) {
        return 1;
    }
    int lenght = 0;
    for (long temp = num; temp != 0; temp /= 10) {
        lenght++;
    }
    return lenght;
}

int[] RadixSort(int[] num, int maxDigit) {
    int mod = 10;
    int dev = 1;
    for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
        int[][] counter = new int[mod * 2][0];
        for (int j = 0; j < num.length; j++) {
            int bucket = ((num[j] % mod) / dev) + mod;
            counter[bucket] = arrayAppend(counter[bucket], num[j]);
        }
        int pos = 0;
        for (int[] bucket : counter) {
            for (int value : bucket) {
                num[pos++] = value;
            }
        }
    }
    return num; 
}

    
int[] arrayAppend(int[] num, int value) {
    num = Arrays.copyOf(num, num.length + 1);
    num[num.length - 1] = value;
    return num;
}

 

九、计数排序

　　计数排序（Count Sort）的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。计数排序的特征：当输入的元素是 n 个 0 到 k 之间的整数时，它的运行时间是 Θ(n + k)。计数排序不是比较排序，排序的速度快于任何比较排序算法。由于用来计数的数组C的长度取决于待排序数组中数据的范围（等于待排序数组的最大值与最小值的差加上1），这使得计数排序对于数据范围很大的数组，需要大量时间和内存。例如：计数排序是用来排序0到100之间的数字的最好的算法，但是它不适合按字母顺序排序人名。但是，计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

　　通俗地理解，例如有 10 个年龄不同的人，统计出有 8 个人的年龄比 A 小，那 A 的年龄就排在第 9 位,用这个方法可以得到其他每个人的位置,也就排好了序。当然，年龄有重复时需要特殊处理（保证稳定性），这就是为什么最后要反向填充目标数组，以及将每个数字的统计减去 1 的原因。

（1）算法步骤：

　　①找出待排序的数组中最大和最小的元素

　　②统计数组中每个值为i的元素出现的次数，存入数组C的第i项

　　③对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）

　　④反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

（2）动态过程展示

 

（3）核心代码实现

 

int[] countsort(int[] num){
    int[] arr = Arrays.copyOf(num, num.length);
    int maxValue = getMaxValue(arr);
    return countingSort(arr, maxValue);
}

int[] countingSort(int[] num, int maxValue) {
    int bucketLen = maxValue + 1;
    int[] bucket = new int[bucketLen];
    for (int value : num) {
        bucket[value]++;
    }
    int sortedIndex = 0;
    for (int j = 0; j < bucketLen; j++) {
        while (bucket[j] > 0) {
            num[sortedIndex++] = j;
            bucket[j]--;
        }
    }
    return num;
}

int getMaxValue(int[] num) {
    int maxValue = num[0];
    for (int value : num) {
        if (maxValue < value) {
           maxValue = value;
        }
    }
    return maxValue;
}

 

本文参考来自：https://www.runoob.com/w3cnote/ten-sorting-algorithm.html