【十大排序算法总结及JAVA代码实现】

﹏ヽ暗。殇╰゛Y 2024-04-28 08:04 140阅读 0赞

十大排序算法总结及JAVA代码实现

算法分类：

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

算法总结：
外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

  • 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
  • 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
  • 内排序：所有排序操作都在内存中完成；
  • 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
  • 时间复杂度： 一个算法执行所耗费的时间。
  • 空间复杂度：运行完一个程序所需内存的大小。

注： 1. n: 数据规模 2. k: “桶”的个数 3. In-place: 占用常数内存，不占用额外内存 Out-place: 占用额外内存

1.冒泡排序

基本思想：两个数比较大小，较大的数下沉，较小的数冒起来。

算法描述：

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

动态演示：

img

代码实现：

  1. /**
  2.      * 冒泡排序
  3.      *
  4.      * @param array
  5.      * @return
  6.      */
  7.     public static int[] bubbleSort(int[] array) {
  9.         if (array.length == 0)
  10.             return array;
  11.         for (int i = 0; i < array.length; i++)
  12.             for (int j = 0; j < array.length - 1 - i; j++)
  13.                 if (array[j + 1] < array[j]) {
  15.                     int temp = array[j + 1];
  16.                     array[j + 1] = array[j];
  17.                     array[j] = temp;
  18.                 }
  19.         return array;
  20.     }

复杂度分析：最佳情况：T(n) = O(n) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

2.快速排序

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

算法描述：

  • 对于第一趟我们选取第一个元素作为基准点
  • 对后面的元素进行移动，将后面的比基准点小的元素移动到前面
  • 对前面的元素进行移动，将前面的比基准点大的元素移动到后面
  • 重复二三操作，直到最后找到基准点的位置
  • 以这一次的基准点为轴线，划分为两部分，对划分出来的两个部分进行同样的操作

动态演示：

å¨è¿éæå¥å¾çæè¿°

代码实现：

  1. /**
  2.      * 快速排序方法
  3.      * @param array
  4.      * @param start
  5.      * @param end
  6.      * @return
  7.      */
  8.     public static int[] QuickSort(int[] array, int start, int end) {
  10.         if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
  11.         int smallIndex = partition(array, start, end);
  12.         if (smallIndex > start)
  13.             QuickSort(array, start, smallIndex - 1);
  14.         if (smallIndex < end)
  15.             QuickSort(array, smallIndex + 1, end);
  16.         return array;
  17.     }
  18.     /**
  19.      * 快速排序算法——partition
  20.      * @param array
  21.      * @param start
  22.      * @param end
  23.      * @return
  24.      */
  25.     public static int partition(int[] array, int start, int end) {
  27.         int pivot = (int) (start + Math.random() * (end - start + 1));
  28.         int smallIndex = start - 1;
  29.         swap(array, pivot, end);
  30.         for (int i = start; i <= end; i++)
  31.             if (array[i] <= array[end]) {
  33.                 smallIndex++;
  34.                 if (i > smallIndex)
  35.                     swap(array, i, smallIndex);
  36.             }
  37.         return smallIndex;
  38.     }
  40.     /**
  41.      * 交换数组内两个元素
  42.      * @param array
  43.      * @param i
  44.      * @param j
  45.      */
  46.     public static void swap(int[] array, int i, int j) {
  48.         int temp = array[i];
  49.         array[i] = array[j];
  50.         array[j] = temp;
  51.     }

复杂度分析： 最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(nlogn)

3.插入排序

基本思想： 将数据分为两个区域，有序区域和无序区域，我们每一次从无序区域选择元素插入到有序区域当中，直至排序完成。

算法描述：

  • 从第一个元素开始，我们认为这个元素是有序的
  • 去除下一个元素，在已经排序好的元素里面我们倒着遍历
  • 如果当前元素大于待插入元素，我们就将当前元素后移一位
  • 重复上述步骤，直到指针指向的元素小于带插入元素，或者是指针指向空
  • 将待插入元素插入选定的位置
  • 重复上面的操作直到整个序列变成有序的

动态演示：

img

代码实现：

  1. /**
  2.      * 插入排序
  3.      * @param array
  4.      * @return
  5.      */
  6.     public static int[] insertionSort(int[] array) {
  8.         if (array.length == 0)
  9.             return array;
  10.         int current;
  11.         for (int i = 0; i < array.length - 1; i++) {
  13.             current = array[i + 1];
  14.             int preIndex = i;
  15.             while (preIndex >= 0 && current < array[preIndex]) {
  17.                 array[preIndex + 1] = array[preIndex];
  18.                 preIndex--;
  19.             }
  20.             array[preIndex + 1] = current;
  21.         }
  22.         return array;
  23.     }

复杂度分析： 最佳情况：T(n) = O(n) 最坏情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

4.希尔排序

基本思想：希尔排序是建立在插入排序的基础上的，但他是优先比较间隔较远的元素，因此又叫做缩小增量排序。其核心就是保证部分序列有序，这样就能减少移动的次数。

算法描述：

  • 选择一个增量序列t1，t2，…，tk。其中序列递减，并且序列的最后一项必须是1.
  • 按照增量的个数，对整个序列进行k趟排序。
  • 每趟排序，根据对应的增量ti，我们对相应的若干长为ti的子序列，进行排序

动态演示：

img

代码实现：

  1. /**
  2.      * 希尔排序
  3.      *
  4.      * @param array
  5.      * @return
  6.      */
  7.     public static int[] ShellSort(int[] array) {
  9.         int len = array.length;
  10.         int temp, gap = len / 2;
  11.         while (gap > 0) {
  13.             for (int i = gap; i < len; i++) {
  15.                 temp = array[i];
  16.                 int preIndex = i - gap;
  17.                 while (preIndex >= 0 && array[preIndex] > temp) {
  19.                     array[preIndex + gap] = array[preIndex];
  20.                     preIndex -= gap;
  21.                 }
  22.                 array[preIndex + gap] = temp;
  23.             }
  24.             gap /= 2;
  25.         }
  26.         return array;
  27.     }

复杂度分析：最佳情况：T(n) = O(nlog2 n) 最坏情况：T(n) = O(nlog2 n) 平均情况：T(n) =O(nlog2n)

5.选择排序

基本思想：总是选择当前所有元素当中最小的元素放到最前面，这就是选择排序的核心思想。

算法描述：

  • 将数组分为两个区域，分别是，有序区和无序区，初始化有序区域是空，无序区域就是[0,n-1];
  • 每一次都是从无序区域当中选择当前最小的元素放在有序区域的最后面
  • 重复上述操作

动态演示：

img

代码实现：

  1. /**
  2.      * 选择排序
  3.      * @param array
  4.      * @return
  5.      */
  6.     public static int[] selectionSort(int[] array) {
  8.         if (array.length == 0)
  9.             return array;
  10.         for (int i = 0; i < array.length; i++) {
  12.             int minIndex = i;
  13.             for (int j = i; j < array.length; j++) {
  15.                 if (array[j] < array[minIndex]) //找到最小的数
  16.                     minIndex = j; //将最小数的索引保存
  17.             }
  18.             int temp = array[minIndex];
  19.             array[minIndex] = array[i];
  20.             array[i] = temp;
  21.         }
  22.         return array;
  23.     }

复杂度分析：最佳情况：T(n) = O(n2) 最差情况：T(n) = O(n2) 平均情况：T(n) = O(n2)

6.堆排序

基本思想：堆排序是建立堆得基础上的，我们根据需要构建最大堆或者是最小堆，那么堆的顶部的元素对应的就是最大或者是最小值。

算法描述：

  • 首先根据给出的序列构建堆
  • 然后将堆顶元素与数组的最后一个元素进行交换
  • 重新维护堆
  • 重复上面的二三操作，直到排序完成

动态演示：

å¨è¿éæå¥å¾çæè¿°

  1. //声明全局变量，用于记录数组array的长度；
  2.     static int len;
  3.     /**
  4.      * 堆排序算法
  5.      *
  6.      * @param array
  7.      * @return
  8.      */
  9.     public static int[] HeapSort(int[] array) {
  11.         len = array.length;
  12.         if (len < 1) return array;
  13.         //1.构建一个最大堆
  14.         buildMaxHeap(array);
  15.         //2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
  16.         while (len > 0) {
  18.             swap(array, 0, len - 1);
  19.             len--;
  20.             adjustHeap(array, 0);
  21.         }
  22.         return array;
  23.     }
  24.     /**
  25.      * 建立最大堆
  26.      *
  27.      * @param array
  28.      */
  29.     public static void buildMaxHeap(int[] array) {
  31.         //从最后一个非叶子节点开始向上构造最大堆
  32.         for (int i = (len/2 - 1); i >= 0; i--) {
  33.      //感谢 @让我发会呆 网友的提醒，此处应该为 i = (len/2 - 1) 
  34.             adjustHeap(array, i);
  35.         }
  36.     }
  37.     /**
  38.      * 调整使之成为最大堆
  39.      *
  40.      * @param array
  41.      * @param i
  42.      */
  43.     public static void adjustHeap(int[] array, int i) {
  45.         int maxIndex = i;
  46.         //如果有左子树，且左子树大于父节点，则将最大指针指向左子树
  47.         if (i * 2 < len && array[i * 2] > array[maxIndex])
  48.             maxIndex = i * 2;
  49.         //如果有右子树，且右子树大于父节点，则将最大指针指向右子树
  50.         if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
  51.             maxIndex = i * 2 + 1;
  52.         //如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
  53.         if (maxIndex != i) {
  55.             swap(array, maxIndex, i);
  56.             adjustHeap(array, maxIndex);
  57.         }
  58.     }

复杂度分析：最佳情况：T(n) = O(nlogn) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

7.计数排序

基本思想：计数排序需要记录输入数据的最大值与最小值，统计最大值与最小值之间的所有元素的出现次数，最后遍历一次记录数组就可以得到最后的顺序。

算法描述：

  • 找出待排序的数组中最大和最小的元素；
  • 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
  • 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
  • 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。

动态演示：

img

代码实现：

  1. /**
  2.      * 计数排序
  3.      *
  4.      * @param array
  5.      * @return
  6.      */
  7.     public static int[] CountingSort(int[] array) {
  9.         if (array.length == 0) return array;
  10.         int bias, min = array[0], max = array[0];
  11.         for (int i = 1; i < array.length; i++) {
  13.             if (array[i] > max)
  14.                 max = array[i];
  15.             if (array[i] < min)
  16.                 min = array[i];
  17.         }
  18.         bias = 0 - min;
  19.         int[] bucket = new int[max - min + 1];
  20.         Arrays.fill(bucket, 0);
  21.         for (int i = 0; i < array.length; i++) {
  23.             bucket[array[i] + bias]++;
  24.         }
  25.         int index = 0, i = 0;
  26.         while (index < array.length) {
  28.             if (bucket[i] != 0) {
  30.                 array[index] = i - bias;
  31.                 bucket[i]--;
  32.                 index++;
  33.             } else
  34.                 i++;
  35.         }
  36.         return array;
  37.     }

复杂度分析：最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n+k)

8.归并排序

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

算法描述：

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

动态演示：

img

代码实现：

  1. /**
  2.      * 归并排序
  3.      *
  4.      * @param array
  5.      * @return
  6.      */
  7.     public static int[] MergeSort(int[] array) {
  9.         if (array.length < 2) return array;
  10.         int mid = array.length / 2;
  11.         int[] left = Arrays.copyOfRange(array, 0, mid);
  12.         int[] right = Arrays.copyOfRange(array, mid, array.length);
  13.         return merge(MergeSort(left), MergeSort(right));
  14.     }
  15.     /**
  16.      * 归并排序——将两段排序好的数组结合成一个排序数组
  17.      *
  18.      * @param left
  19.      * @param right
  20.      * @return
  21.      */
  22.     public static int[] merge(int[] left, int[] right) {
  24.         int[] result = new int[left.length + right.length];
  25.         for (int index = 0, i = 0, j = 0; index < result.length; index++) {
  27.             if (i >= left.length)
  28.                 result[index] = right[j++];
  29.             else if (j >= right.length)
  30.                 result[index] = left[i++];
  31.             else if (left[i] > right[j])
  32.                 result[index] = right[j++];
  33.             else
  34.                 result[index] = left[i++];
  35.         }
  36.         return result;
  37.     }

复杂度分析：最佳情况：T(n) = O(n) 最差情况：T(n) = O(nlogn) 平均情况：T(n) = O(nlogn)

9.桶排序

基本思想：桶排序 (Bucket sort)的工作的原理：假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排序

算法描述：

  • 人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
  • 遍历输入数据，并且把数据一个一个放到对应的桶里去；
  • 对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
  • 从不是空的桶里把排好序的数据拼接起来。

注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。

动态演示：

å¨è¿éæå¥å¾çæè¿°

代码实现：

  1. /**
  2.      * 桶排序
  3.      * 
  4.      * @param array
  5.      * @param bucketSize
  6.      * @return
  7.      */
  8.     public static ArrayList<Integer> BucketSort(ArrayList<Integer> array, int bucketSize) {
  10.         if (array == null || array.size() < 2)
  11.             return array;
  12.         int max = array.get(0), min = array.get(0);
  13.         // 找到最大值最小值
  14.         for (int i = 0; i < array.size(); i++) {
  16.             if (array.get(i) > max)
  17.                 max = array.get(i);
  18.             if (array.get(i) < min)
  19.                 min = array.get(i);
  20.         }
  21.         int bucketCount = (max - min) / bucketSize + 1;
  22.         ArrayList<ArrayList<Integer>> bucketArr = new ArrayList<>(bucketCount);
  23.         ArrayList<Integer> resultArr = new ArrayList<>();
  24.         for (int i = 0; i < bucketCount; i++) {
  26.             bucketArr.add(new ArrayList<Integer>());
  27.         }
  28.         for (int i = 0; i < array.size(); i++) {
  30.             bucketArr.get((array.get(i) - min) / bucketSize).add(array.get(i));
  31.         }
  32.         for (int i = 0; i < bucketCount; i++) {
  34.             if (bucketSize == 1) {
  35.      // 如果带排序数组中有重复数字时  感谢 @见风任然是风 朋友指出错误
  36.                 for (int j = 0; j < bucketArr.get(i).size(); j++)
  37.                     resultArr.add(bucketArr.get(i).get(j));
  38.             } else {
  40.                 if (bucketCount == 1)
  41.                     bucketSize--;
  42.                 ArrayList<Integer> temp = BucketSort(bucketArr.get(i), bucketSize);
  43.                 for (int j = 0; j < temp.size(); j++)
  44.                     resultArr.add(temp.get(j));
  45.             }
  46.         }
  47.         return resultArr;
  48.     }

复杂度分析：最佳情况：T(n) = O(n+k) 最差情况：T(n) = O(n+k) 平均情况：T(n) = O(n2)

桶排序最好情况下使用线性时间O(n)，桶排序的时间复杂度，取决与对各个桶之间数据进行排序的时间复杂度，因为其它部分的时间复杂度都为O(n)。很显然，桶划分的越小，各个桶之间的数据越少，排序所用的时间也会越少。但相应的空间消耗就会增大。

10.基数排序

基本思想：基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。

算法描述：

  • 取得数组中的最大数，并取得位数；
  • arr为原始数组，从最低位开始取每个位组成radix数组；
  • 对radix进行计数排序（利用计数排序适用于小范围数的特点）；

动态演示：

img

代码实现：

  1. /**
  2.      * 基数排序
  3.      * @param array
  4.      * @return
  5.      */
  6.     public static int[] RadixSort(int[] array) {
  8.         if (array == null || array.length < 2)
  9.             return array;
  10.         // 1.先算出最大数的位数；
  11.         int max = array[0];
  12.         for (int i = 1; i < array.length; i++) {
  14.             max = Math.max(max, array[i]);
  15.         }
  16.         int maxDigit = 0;
  17.         while (max != 0) {
  19.             max /= 10;
  20.             maxDigit++;
  21.         }
  22.         int mod = 10, div = 1;
  23.         ArrayList<ArrayList<Integer>> bucketList = new ArrayList<ArrayList<Integer>>();
  24.         for (int i = 0; i < 10; i++)
  25.             bucketList.add(new ArrayList<Integer>());
  26.         for (int i = 0; i < maxDigit; i++, mod *= 10, div *= 10) {
  28.             for (int j = 0; j < array.length; j++) {
  30.                 int num = (array[j] % mod) / div;
  31.                 bucketList.get(num).add(array[j]);
  32.             }
  33.             int index = 0;
  34.             for (int j = 0; j < bucketList.size(); j++) {
  36.                 for (int k = 0; k < bucketList.get(j).size(); k++)
  37.                     array[index++] = bucketList.get(j).get(k);
  38.                 bucketList.get(j).clear();
  39.             }
  40.         }
  41.         return array;
  42.     }

复杂度分析：最佳情况：T(n) = O(n * k) 最差情况：T(n) = O(n * k) 平均情况：T(n) = O(n * k)

发表评论

表情：
评论列表 （有 0 条评论，140人围观）

还没有评论，来说两句吧...

相关阅读

    相关 十大排序算法Java实现

    > 之前写了JavaScript实现的排序算法，因为社会的压迫233333，Java可能也得写写，所以就将这个放在这里来了，算法介绍看之前JavaScript那一篇播客吧，这里

    向右看齐向右看齐/ 0 赞/ 273 阅读

    相关 十大排序算法总结

    0、开场 排序算法分为外部排序和内部排序。内部排序是指数据记录在内存中进行排序，而外部排序是排序的数据量很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的

    梦里梦外;梦里梦外;/ 0 赞/ 350 阅读