七大经典排序算法总结（Java和Kotlin语言实现）

0.前言

本文总结了七大常见经典的排序算法，会结合动画演示、算法说明和代码实现来说明，希望对你有所帮助。

根据在排序过程中待排序的记录是否全部放置在内存中，排序分为：内排序和外排序。

对内排序来说，排序算法的性能主要受3个方面的影响。

• 时间性能

  内排序中，主要进行两种操作：比较和移动。高效的排序算法应该尽可能少的关键字比较次数和尽可能少的记录移动次数。

• 辅助空间

  辅助存储空间是除了存放排序所占用的在座空间之外，执行算法所需要的其他存储空间。

• 算法的复杂度

排序算法分类：

排序算法大体可分为两种：

• 一种是比较排序，时间复杂度 $O(nlogn)$ ~ $O(n^2)$，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。
• 另一种是非比较排序，时间复杂度可以达到$O(n)$，主要有：计数排序，基数排序，桶排序等。

下面给出常见比较算法的排序性能

图片名词解释：

• n: 数据规模
• k: “桶”的个数
• In-place: 占用常数内存，不占用额外内存
• Out-place: 占用额外内存

1.冒泡排序（Bubble Sort）

冒泡排序是一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果是反序则交换，直到没有反序的记录为止。

1.1 算法描述

1. 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
2. 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
3. 针对所有的元素重复以上的步骤，除了最后一个；
4. 重复步骤1~3，直到排序完成

1.2 动图演示

1.3代码实现

普通版：

• Java版：

public static void main(String []args){
        int[] arr= new int[15];
        for (int i=0;i<arr.length;i++){
            arr[i] = new Random().nextInt(15);
        }
        System.out.println(Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println(Arrays.toString(arr));
    }
    private static void bubbleSort(int[] arr) {
        long startTime = System.nanoTime();
        for(int i=0;i<arr.length-1;i++){//冒泡趟数
            for(int j=0;j<arr.length-i-1;j++){
                if(arr[j]>arr[j+1]){
                    swap(arr,j,j+1);
                }
            }
        }
        long endTime = System.nanoTime();
        //执行时间
        System.out.println((endTime - startTime)/1000.0 + "ms");
    }
    //交换
    private static void swap(int[] arr,int a,int b){
        int temp = arr[a];
        arr[a] = arr[b];
        arr[b] = temp;
    }

• Kotlin版：

  fun main() {
      val arr = IntArray(15)
      for (i in arr.indices) {
          arr[i] = Random().nextInt(15)
      }
          println("排序前:${Arrays.toString(arr)}")
          bubbleSort(arr)
          println("排序后:${Arrays.toString(arr)}")
  }
  
  private fun bubbleSort(array: IntArray){
      val startTime = System.nanoTime()
      for (i in 0 until  array.size -1){
          for (j in 0 until array.size -i -1){
              if (array[j]>array[j+1]){
                  swap(array,j,j+1)
              }
          }
      }
      val endTime = System.nanoTime()
      //执行时间
      println(((endTime - startTime) / 1000.0).toString() + "ms")
  }
  //交换
  private fun swap(array: IntArray,a:Int,b:Int){
      val temp = array[a]
      array[a] = array[b]
      array[b] = temp
  }
  

改进版：

• 加标志，加入了判断是否已经排序了的boolean变量，之后就退出循环。可避免已经有序的情况下重复的无意义的循环判断。

  //加入了判断是否已经排序了的boolean变量
  private static void bubbleSort(int[] arr) {
          long start = System.nanoTime();
          for(int i=0;i<arr.length-1;i++){//冒泡趟数
              boolean isSort = true;
              for(int j=0;j<arr.length-i-1;j++){
                  if(arr[j]>arr[j+1]){
                      swap(arr,j,j+1);
                      isSort = false;
                  }
              }
              if (isSort) break;
          }
          long end = System.nanoTime();
          System.out.println((end - start)/1000.0 + "ms");
      }
  

• 记录上一次最后交换的那个位置，下一轮交换只需要进行到这个位置即可

//java版
private static void bubbleSort2(int[] arr) {
        long startTime = System.nanoTime();
        for (int end = arr.length - 1; end > 0; end--) { 
            int border = 0;
            for (int i = 0; i < end; i++) {
                if (arr[i] > arr[i + 1]) {
                    swap(arr, i, i + 1);
                    border = i + 1;
                }
            }
            end = border;
        }
        long endTime = System.nanoTime();
        System.out.println((endTime - startTime) / 1000.0 + "ms");
    }

//kotlin
private fun bubbleSort2(arr: IntArray) {
    val startTime = System.nanoTime()
    var end = arr.size - 1
    while (end > 0) { 
        var border = 0
        for (i in 0 until end) {
            if (arr[i] > arr[i + 1]) {
                swap(arr, i, i + 1)
                border = i + 1
            }
        }
        end = border
        end--
    }
    val endTime = System.nanoTime()
    println(((endTime - startTime) / 1000.0).toString() + "ms")
}

2.选择排序（Selection Sort）

2.1工作原理

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

• 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

2.2算法描述

n个记录的直接选择排序可经过$n-1$趟直接选择排序得到有序结果。具体算法描述如下：

• 初始状态：无序区为$R[1..n]$，有序区为空；

• 第i趟排序$(i=1,2,3\dots n-1)$开始时，当前有序区和无序区分别为$R[1..i-1]和R(i..n）$。该趟排序从当前无序区中选出关键字最小的记录 $R[k]$，将它与无序区的第1个记录$R$交换，使$R[1..i]$和$R[i+1..n)$分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

• $n-1$趟结束，数组有序化了。

2.3动图演示

2.4代码实现

    //选择排序
    private static void selectionSort(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            //记录后面最小的下标
            int mIndex = i;
            for (int j = i; j < arr.length; j++) {
                if (arr[j] < arr[mIndex]){//找到最小的数
                    mIndex = j;//将最小的索引保存
                }
            }
            swap(arr, i, mIndex);
        }
    }

3.插入排序（Insertion Sort）

3.1 算法描述

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

1. 从第一个元素开始，该元素可以认为已经被排序；
2. 取出下一个元素，在已经排序的元素序列中从后向前扫描；
3. 如果该元素（已排序）大于新元素，将该元素移到下一位置；
4. 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
5. 将新元素插入到该位置后；
6. 重复步骤2~5。

3.2 动图演示

3.3代码实现

• Java版

   //插入排序
    private static void insertionSort(int[] array) {
        int current;
        for (int i = 0; i < array.length - 1; i++) {
            current = array[i + 1];
            int preIndex = i;
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex+1] = array[preIndex];
                preIndex--;
            }
            array[preIndex + 1] = current;
        }
    }

• Kotlin版

    //插入排序
    private fun insertionSort(array: IntArray) {
        var current: Int
        for (i in 0 until array.size - 1) {
            current = array[i + 1]
            var preIndex = i
            while (preIndex >= 0 && current < array[preIndex]) {
                array[preIndex + 1] = array[preIndex]
                preIndex--
            }
            array[preIndex + 1] = current
        }
    }

4.希尔排序(Shell Sort)

希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破$O(n^2）$的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。

希尔排序使更高效的插入排序，它的思想在于，

• 把数组分成几块，每一块进行一个插入排序；

• 而分块的依据在于增量的选择分好块之后，从$gap$开始到$n$，每一组和它前面的元素（自己组内的）进行插入排序；

每次和组内的元素比较完之后，最后的元素基本就是有序的了，希尔排序相对于插入排序的优势在于插入排序每次只能将数据移动一位，不过希尔排序时间复杂度的大小还是要取决于步长的合适度，另外希尔排序不是一种稳定的排序算法。

4.1 算法描述

我们来看下希尔排序的基本步骤，在此我们选择增量$gap=length/2$，缩小增量继续以$gap=gap/2$的方式，这种增量选择我们可以用一个序列来表示，$n/2,(n/2)/2...1$，称为增量序列。希尔排序的增量序列的选择与证明是个数学难题，我们选择的这个增量序列是比较常用的，也是希尔建议的增量，称为希尔增量，但其实这个增量序列不是最优的。此处我们做示例使用希尔增量。

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

• 选择一个增量序列$t_1，t_2，\dots ，t_k$，其中$t_i>t_j$，$t_k=1$；
• 按增量序列个数$k$，对序列进行$k$ 趟排序；
• 每趟排序，根据对应的增量$t_i$，将待排序列分割成若干长度为$m$ 的子序列，分别对各子表进行直接插入排序。仅增量因子为$1$时，整个序列作为一个表来处理，表长度即为整个序列的长度。

4.2 过程演示

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-svGwibJ8-1587126742798)(https://images2018.cnblogs.com/blog/1192699/201803/1192699-20180319094116040-1638766271.png)]

4.3动图演示

4.4 代码实现

• Java版：

　　/**
     * 希尔排序
     */
    private static void shellSort(int[] arr) {
        long startTime = System.nanoTime();
        int len = arr.length;
        int temp;
        int gap = len / 2; //增量序列
        while (gap > 0) {
            for (int i = gap; i < len; i++) { //从数组第gap个元素开始
                temp = arr[i];  //每个元素与自己组内的数据进行直接插入排序
                int preIndex = i - gap; 
                while (preIndex >= 0 && arr[preIndex] > temp) {
                    arr[preIndex + gap] = arr[preIndex];
                    preIndex -= gap;
                }
                arr[preIndex + gap] = temp;
            }
            gap /= 2;
        }
        long endTime = System.nanoTime();
        System.out.println((endTime - startTime) / 1000.0 + "ms");
    }

• Kotlin版

private fun shellSort(arr: IntArray) {
        val startTime = System.nanoTime()
        val len = arr.size
        var temp: Int
        var gap = len / 2
        while (gap > 0) {
            for (i in gap until len) {
                temp = arr[i]
                var preIndex = i - gap
                while (preIndex >= 0 && arr[preIndex] > temp) {
                    arr[preIndex + gap] = arr[preIndex]
                    preIndex -= gap
                }
                arr[preIndex + gap] = temp
            }
            gap /= 2
        }
        val endTime = System.nanoTime()
        println(((endTime - startTime) / 1000.0).toString() + "ms")
    }

5.快速排序（Quick Sort）

快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。

其他表达方式：（快速排序的基本思想）
随机找出一个数，可以随机取，也可以取固定位置，一般是取第一个或最后一个称为基准，然后就是比基准小的在左边，比基准大的放到右边，如何放做，就是和基准进行交换，这样交换完左边都是比基准小的，右边都是比较基准大的，这样就将一个数组分成了两个子数组，然后再按照同样的方法把子数组再分成更小的子数组，直到不能分解为止。

5.1 算法描述

快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

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

5.2 动图演示

5.3 代码实现

• Java版

	//快速排序方法
	private static void quickSort(int[] array, int start, int end) {
        if (array.length < 1 || start < 0 || end >= array.length || start > end) {
            return;
        }
        int smallIndex = partition(array, start, end);
        if (smallIndex > start) {
            quickSort(array, start, smallIndex - 1);
        }
        if (smallIndex < end) {
            quickSort(array, smallIndex + 1, end);
        }
    }
	//快速排序算法——partition
    private static int partition(int[] array, int start, int end) {
        int pivot = (int) (start + Math.random() * (end - start + 1));
        int smallIndex = start - 1;
        swap(array, pivot, end);
        for (int i = start; i <= end; i++)
            if (array[i] <= array[end]) {
                smallIndex++;
                if (i > smallIndex)
                    swap(array, i, smallIndex);
            }
        return smallIndex;
    }

	//交换数组内两个元素
    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

• Kotlin版

  	//快速排序方法
    private fun quickSort(array: IntArray, start: Int, end: Int) {
          if (array.isEmpty() || start < 0 || end >= array.size || start > end) {
              return
          }
          val smallIndex = partition(array, start, end)
          if (smallIndex > start) {
              quickSort(array, start, smallIndex - 1)
          }
          if (smallIndex < end) {
              quickSort(array, smallIndex + 1, end)
          }
      }
  	//快速排序算法——partition
      private fun partition(array: IntArray, start: Int, end: Int): Int {
          val pivot = (start + Math.random() * (end - start + 1)).toInt()
          var smallIndex = start - 1
          swap(array, pivot, end)
          for (i in start..end)
              if (array[i] <= array[end]) {
                  smallIndex++
                  if (i > smallIndex)
                      swap(array, i, smallIndex)
              }
          return smallIndex
      }
  	//交换数组内两个元素
      private fun swap(array: IntArray, i: Int, j: Int) {
          val temp = array[i]
          array[i] = array[j]
          array[j] = temp
      }
  

  快速排序可优化的地方:

  • 优化选取基准,如采用"三数取中"、“九数取中”

  • 优化不必要的交换

  • 优化数组时的排序方案

  • 优化递归操作

    具体不在此展开，感兴趣的可以查看其他资料深入研究。

6.堆排序（Heap Sort）

堆排序（Heap sort）是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

6.1 算法描述

• 将初始待排序关键字序列$(R1,R2\dots .Rn)$构建成大顶堆，此堆为初始的无序区；
• 将堆顶元素$R[1]$与最后一个元素$R[n]$交换，此时得到新的无序区$(R1,R2,\dots \dots Rn-1)$和新的有序区$(Rn)$,且满足$R[1,2\dots n-1]<=R[n]$；
• 由于交换后新的堆顶$R[1]$可能违反堆的性质，因此需要对当前无序区$(R1,R2,\dots \dots Rn-1)$调整为新堆，然后再次将$R[1]$与无序区最后一个元素交换，得到新的无序区$(R1,R2\dots .Rn-2)$和新的有序区$(Rn-1,Rn)$。不断重复此过程直到有序区的元素个数为$n-1$，则整个排序过程完成。

6.2 动图演示

6.3 代码实现

注意：这里用到了完全二叉树的部分性质：详情见《数据结构二叉树知识点总结》

• Java版

	//声明全局变量，用于记录数组array的长度；
	static int len;
    private static int[] heapSort(int[] array) {
        len = array.length;
        if (len < 1) return array;
        //构建一个最大堆
        buildMaxHeap(array);
        while (len > 0) {
            swap(array, 0, len - 1);
            len--;
            adjustHeap(array, 0);
        }
        return array;
    }

    //调整使之成为最大堆
    private static void adjustHeap(int[] array, int i) {
        int maxIndex = i;
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 < len && array[i * 2] > array[maxIndex]) {
            maxIndex = i * 2;
        }
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) {
            maxIndex = i * 2 + 1;
        }
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i);
            adjustHeap(array, maxIndex);
        }
    }

    //建立最大堆
    private static void buildMaxHeap(int[] array) {
        for (int i = (len / 2 - 1); i >= 0; i--) {
            adjustHeap(array, i);
        }
    }

• Kotlin版

private fun heapSort(array: IntArray): IntArray {
        len = array.size
        if (len < 1) return array
        //构建一个最大堆
        buildMaxHeap(array)
        while (len > 0) {
            swap(array, 0, len - 1)
            len--
            adjustHeap(array, 0)
        }
        return array
    }

    //调整使之成为最大堆
    private fun adjustHeap(array: IntArray, i: Int) {
        var maxIndex = i
        //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
        if (i * 2 < len && array[i * 2] > array[maxIndex]) {
            maxIndex = i * 2
        }
        //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
        if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex]) {
            maxIndex = i * 2 + 1
        }
        //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
        if (maxIndex != i) {
            swap(array, maxIndex, i)
            adjustHeap(array, maxIndex)
        }
    }

    //建立最大堆
    private fun buildMaxHeap(array: IntArray) {
        for (i in len / 2 - 1 downTo 0) {
            adjustHeap(array, i)
        }
    }

7、归并排序（Merge Sort）

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

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

7.1 算法描述

• 把长度为$n$的输入序列分成两个长度为$n/2$的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

7.2 动图演示

7.3 代码实现

• Java版

　   /**
     * 归并排序
     */
    private static int[] mergeSort(int[] array) {
        if (array.length < 2) return array;
        int mid = array.length / 2;
        int[] left = Arrays.copyOfRange(array, 0, mid);
        int[] right = Arrays.copyOfRange(array, mid, array.length);
        return merge(mergeSort(left), mergeSort(right));
    }

    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     */
    private static int[] merge(int[] left, int[] right) {
        int[] result = new int[left.length + right.length];
        for (int index = 0, i = 0, j = 0; index < result.length; index++) {
            if (i >= left.length)
                result[index] = right[j++];
            else if (j >= right.length)
                result[index] = left[i++];
            else if (left[i] > right[j])
                result[index] = right[j++];
            else
                result[index] = left[i++];
        }
        return result;
    }

• Kotlin版：

    /**
     * 归并排序
     */
    private fun mergeSort(array: IntArray): IntArray {
        if (array.size < 2) return array
        val mid = array.size / 2
        val left = Arrays.copyOfRange(array, 0, mid)
        val right = Arrays.copyOfRange(array, mid, array.size)
        return merge(mergeSort(left), mergeSort(right))
    }

    /**
     * 归并排序——将两段排序好的数组结合成一个排序数组
     */
    private fun merge(left: IntArray, right: IntArray): IntArray {
        val result = IntArray(left.size + right.size)
        var index = 0
        var i = 0
        var j = 0
        while (index < result.size) {
            when {
                i >= left.size -> result[index] = right[j++]
                j >= right.size -> result[index] = left[i++]
                left[i] > right[j] -> result[index] = right[j++]
                else -> result[index] = left[i++]
            }
            index++
        }
        return result
    }

8.其他排序

桶排序、基数排序、计数排序 （略），后期看情况继续完善。

9.总结

本文总结了常见的七种算法，主要在于了解各自的算法思想。图片大多来源于网络，侵删。如有不足之处，欢迎指正。

上一篇：常见的数据结构和算法小结

参考资料：

1.十大经典排序算法最强总结（含JAVA代码实现）

2.五分钟学算法

3.程杰 .大话数据结构. 北京：清华大学出版社, 2011