Java之经典排序算法

1.1 快速排序

快速排序,一种排序很快的方法,使用分治思想,就是说快速排序是通过把数据分成几部分来处理的一种算法。快排本身和其使用的分治思想都很重要,也是面试可能出现的一大难点。

1. 算法步骤

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

2. 动图演示

-1

3.代码实现

  1. public class QuickSort implements IArraySort {
  2.      @Override
  3.      public int[] sort(int[] sourceArray) throws Exception {
  4.          // 对 arr 进行拷贝,不改变参数内容
  5.          int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  6.          return quickSort(arr, 0, arr.length  1);
  7.      }
  8.      private int[] quickSort(int[] arr, int left, int right) {
  9.          if (left < right) {
  10.              int partitionIndex = partition(arr, left, right);
  11.              quickSort(arr, left, partitionIndex  1);
  12.              quickSort(arr, partitionIndex + 1, right);
  13.          }
  14.          return arr;
  15.      }
  16.      private int partition(int[] arr, int left, int right) {
  17.          // 设定基准值(pivot)
  18.          int pivot = left;
  19.          int index = pivot + 1;
  20.          for (int i = index; i <= right; i++) {
  21.              if (arr[i] < arr[pivot]) {
  22.                  swap(arr, i, index);
  23.                  index++;
  24.              }
  25.          }
  26.          swap(arr, pivot, index  1);
  27.          return index  1;
  28.      }
  29.      private void swap(int[] arr, int i, int j) {
  30.          int temp = arr[i];
  31.          arr[i] = arr[j];
  32.          arr[j] = temp;
  33.      }
  34. }

1.2 堆排序

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

  1. 大顶堆:每个节点的值都大于或等于其子节点的值,在堆排序算法中用于升序排列;
  2. 小顶堆:每个节点的值都小于或等于其子节点的值,在堆排序算法中用于降序排列;

 1. 算法步骤

  1. 创建一个堆 H[0……n-1];
  2. 把堆首(最大值)和堆尾互换;
  3. 把堆的尺寸缩小 1,并调用 shift_down(0),目的是把新的数组顶端数据调整到相应位置;
  4. 重复步骤 2,直到堆的尺寸为 1。

 2. 动图演示

-2

-3

3. 代码实现

  1. public class HeapSort implements IArraySort {
  2.      @Override
  3.      public int[] sort(int[] sourceArray) throws Exception {
  4.          // 对 arr 进行拷贝,不改变参数内容
  5.          int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  6.          int len = arr.length;
  7.          buildMaxHeap(arr, len);
  8.          for (int i = len  1; i > 0; i–) {
  9.              swap(arr, 0, i);
  10.              len–;
  11.              heapify(arr, 0, len);
  12.          }
  13.          return arr;
  14.      }
  15.      private void buildMaxHeap(int[] arr, int len) {
  16.          for (int i = (int) Math.floor(len / 2); i >= 0; i–) {
  17.              heapify(arr, i, len);
  18.          }
  19.      }
  20.      private void heapify(int[] arr, int i, int len) {
  21.          int left = 2 * i + 1;
  22.          int right = 2 * i + 2;
  23.          int largest = i;
  24.          if (left < len && arr[left] > arr[largest]) {
  25.              largest = left;
  26.          }
  27.          if (right < len && arr[right] > arr[largest]) {
  28.              largest = right;
  29.          }
  30.          if (largest != i) {
  31.              swap(arr, i, largest);
  32.              heapify(arr, largest, len);
  33.          }
  34.      }
  35.      private void swap(int[] arr, int i, int j) {
  36.          int temp = arr[i];
  37.          arr[i] = arr[j];
  38.          arr[j] = temp;
  39.      }
  40. }

1.3 计数排序

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

1. 计数排序的特征

当输入的元素是 n 个 0 到 k 之间的整数时,它的运行时间是 Θ(n + k)。计数排序不是比较排序,排序的速度快于任何比较排序算法。

由于用来计数的数组C的长度取决于待排序数组中数据的范围(等于待排序数组的最大值与最小值的差加上1),这使得计数排序对于数据范围很大的数组,需要大量时间和内存。例如:计数排序是用来排序0到100之间的数字的最好的算法,但是它不适合按字母顺序排序人名。但是,计数排序可以用在基数排序中的算法来排序数据范围很大的数组。

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

算法的步骤如下:

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

 2. 动图演示

-4

3.代码实现

  1. public class CountingSort implements IArraySort {
  2.      @Override
  3.      public int[] sort(int[] sourceArray) throws Exception {
  4.          // 对 arr 进行拷贝,不改变参数内容
  5.          int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  6.          int maxValue = getMaxValue(arr);
  7.          return countingSort(arr, maxValue);
  8.      }
  9.      private int[] countingSort(int[] arr, int maxValue) {
  10.          int bucketLen = maxValue + 1;
  11.          int[] bucket = new int[bucketLen];
  12.          for (int value : arr) {
  13.              bucket[value]++;
  14.          }
  15.          int sortedIndex = 0;
  16.          for (int j = 0; j < bucketLen; j++) {
  17.              while (bucket[j] > 0) {
  18.                  arr[sortedIndex++] = j;
  19.                  bucket[j]–;
  20.              }
  21.          }
  22.          return arr;
  23.      }
  24.      private int getMaxValue(int[] arr) {
  25.          int maxValue = arr[0];
  26.          for (int value : arr) {
  27.              if (maxValue < value) {
  28.                  maxValue = value;
  29.              }
  30.          }
  31.          return maxValue;
  32.      }
  33. }

1.4 桶排序

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:

  1. 在额外空间充足的情况下,尽量增大桶的数量
  2. 使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。

1. 什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

2. 什么时候最慢

当输入的数据被分配到了同一个桶中。

3. 示意图

元素分布在桶中:

-5

然后,元素在每个桶中排序:

-6

4.代码实现

  1. public class BucketSort implements IArraySort {
  2.      private static final InsertSort insertSort = new InsertSort();
  3.      @Override
  4.      public int[] sort(int[] sourceArray) throws Exception {
  5.          // 对 arr 进行拷贝,不改变参数内容
  6.          int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  7.          return bucketSort(arr, 5);
  8.      }
  9.      private int[] bucketSort(int[] arr, int bucketSize) throws Exception {
  10.          if (arr.length == 0) {
  11.              return arr;
  12.          }
  13.          int minValue = arr[0];
  14.          int maxValue = arr[0];
  15.          for (int value : arr) {
  16.              if (value < minValue) {
  17.                  minValue = value;
  18.              } else if (value > maxValue) {
  19.                  maxValue = value;
  20.              }
  21.          }
  22.          int bucketCount = (int) Math.floor((maxValue  minValue) / bucketSize) + 1;
  23.          int[][] buckets = new int[bucketCount][0];
  24.          // 利用映射函数将数据分配到各个桶中
  25.          for (int i = 0; i < arr.length; i++) {
  26.              int index = (int) Math.floor((arr[i]  minValue) / bucketSize);
  27.              buckets[index] = arrAppend(buckets[index], arr[i]);
  28.          }
  29.          int arrIndex = 0;
  30.          for (int[] bucket : buckets) {
  31.              if (bucket.length <= 0) {
  32.                  continue;
  33.              }
  34.              // 对每个桶进行排序,这里使用了插入排序
  35.              bucket = insertSort.sort(bucket);
  36.              for (int value : bucket) {
  37.                  arr[arrIndex++] = value;
  38.              }
  39.          }
  40.          return arr;
  41.      }
  42.      /**
  43.          * 自动扩容,并保存数据
  44.          *
  45.          * @param arr
  46.          * @param value
  47.          */
  48.      private int[] arrAppend(int[] arr, int value) {
  49.          arr = Arrays.copyOf(arr, arr.length + 1);
  50.          arr[arr.length  1] = value;
  51.          return arr;
  52.      }
  53. }

1.5 基数排序

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

1. 基数排序 vs 计数排序 vs 桶排序

基数排序有两种方法:

这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

  • 基数排序:根据键值的每位数字来分配桶;
  • 计数排序:每个桶只存储单一键值;
  • 桶排序:每个桶存储一定范围的数值;

 2. LSD 基数排序动图演示

-7

3.代码实现

  1. /**
  2.      * 基数排序
  3.      * 考虑负数的情况还可以参考: https://code.i-harness.com/zh-CN/q/e98fa9
  4.      */
  5. public class RadixSort implements IArraySort {
  6.      @Override
  7.      public int[] sort(int[] sourceArray) throws Exception {
  8.          // 对 arr 进行拷贝,不改变参数内容
  9.          int[] arr = Arrays.copyOf(sourceArray, sourceArray.length);
  10.          int maxDigit = getMaxDigit(arr);
  11.          return radixSort(arr, maxDigit);
  12.      }
  13.      /**
  14.          * 获取最高位数
  15.          */
  16.      private int getMaxDigit(int[] arr) {
  17.          int maxValue = getMaxValue(arr);
  18.          return getNumLenght(maxValue);
  19.      }
  20.      private int getMaxValue(int[] arr) {
  21.          int maxValue = arr[0];
  22.          for (int value : arr) {
  23.              if (maxValue < value) {
  24.                  maxValue = value;
  25.              }
  26.          }
  27.          return maxValue;
  28.      }
  29.      protected int getNumLenght(long num) {
  30.          if (num == 0) {
  31.              return 1;
  32.          }
  33.          int lenght = 0;
  34.          for (long temp = num; temp != 0; temp /= 10) {
  35.              lenght++;
  36.          }
  37.          return lenght;
  38.      }
  39.      private int[] radixSort(int[] arr, int maxDigit) {
  40.          int mod = 10;
  41.          int dev = 1;
  42.          for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
  43.              // 考虑负数的情况,这里扩展一倍队列数,其中 [0-9]对应负数,[10-19]对应正数 (bucket + 10)
  44.              int[][] counter = new int[mod * 2][0];
  45.              for (int j = 0; j < arr.length; j++) {
  46.                  int bucket = ((arr[j] % mod) / dev) + mod;
  47.                  counter[bucket] = arrayAppend(counter[bucket], arr[j]);
  48.              }
  49.              int pos = 0;
  50.              for (int[] bucket : counter) {
  51.                  for (int value : bucket) {
  52.                      arr[pos++] = value;
  53.                  }
  54.              }
  55.          }
  56.          return arr;
  57.      }
  58.      /**
  59.          * 自动扩容,并保存数据
  60.          *
  61.          * @param arr
  62.          * @param value
  63.          */
  64.      private int[] arrayAppend(int[] arr, int value) {
  65.          arr = Arrays.copyOf(arr, arr.length + 1);
  66.          arr[arr.length  1] = value;
  67.          return arr;
  68.      }
  69. }

到此这篇关于Java之经典排序算法的文章就介绍到这了,更多相关Java排序算法内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们!

标签

发表评论