比较排序：
冒泡、选择、插入、希尔、堆、归并、快排
非比较排序：
基数、计数、桶
稳定排序：
冒泡、插入、归并、基数、计数、桶
不稳定排序：
选择、希尔、堆、快排
分治思想：
归并、快排
冒泡排序
- 算法步骤：
1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。
3）针对所有的元素重复以上的步骤，除了最后一个。
4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。 - 优化策略：设立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。
- 动图演示：
- 适用场景：
少量数据 - 代码实现：
public class BubbleSort {
public int[] sort(int[] arr){
for (int i = 1; i < arr.length; i++) {
//标记，若为true，就表明此次循环没有进行交换，表明已经排好序，就跳出循环
boolean flag = true;
for (int j = 0; j < arr.length-i; j++) {
if (arr[j] > arr[j+1]){
int tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
//交换了，就设为false
flag =false;
}
}
if(flag) break;
}
return arr;
}
}
选择排序
- 算法步骤：
1）首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
2）再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
3）重复第二步，直到所有元素均排序完毕。 - 动图演示
- 适用场景：
少量数据 - 代码实现：
public class SelectSort{
public int[] sort(int[] arr){
for (int i = 0; i < arr.length-1; i++) {
int min = i;
for (int j = i+1; j < arr.length; j++) {
if (arr[j] < arr[min]){
//记录最小元素的下标
min = j;
}
}
//将找到的最小值和i位置所在的值进行交换
if (i != min){
int tmp = arr[i];
arr[i] = arr[min];
arr[min] = tmp;
}
}
return arr;
}
}
插入排序
- 算法步骤：
1）将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
2）从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。） - 动图演示：
- 适用场景：
小规模、基本有序的时候十分有效。在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率。 - 代码实现：
public class InsertSort{
public int[] sort(int[] arr){
//0为已排好序的，从1开始往有序序列里面插入
for (int i = 1; i < arr.length; i++) {
//要插入的数据
int tmp = arr[i];
//j是要插入的数据位置，它和j前已排好序的序列j-1 ~ 0比较，
int j = i;
while (j>0 && tmp < arr[j-1]){
//找到就将数据往后移一位
arr[j] = arr[j-1];
j--;
}
//将数据插入
if (j != i){
arr[j] = tmp;
}
}
return arr;
}
}
希尔排序
- 算法步骤：
1）选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
2）按增量序列个数 k，对序列进行 k 趟排序；
3）每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度 - 动图演示：
- 适用场景：
对插入排序的一种改进，中等大小规模表现良好，对规模非常大的数据排序不是最优选择。 - 代码实现
public class ShellSort{
public int[] sort(int[] arr){
//间隔计算
int gap = 1;
while(gap <= arr.length / 3){
gap = gap * 3 + 1;
}
while (gap > 0){
//相当于间隔为gap的插入排序，如果gap为1就和插入排序一样
for (int i = gap; i < arr.length; i++) {
int tmp = arr[i];
int j = i;
while (j >= gap && arr[j-gap] > tmp){
arr[j] = arr[j-gap];
j -= gap;
}
arr[j] = tmp;
}
//减小间隔
gap = gap / 3;
}
return arr;
}
}
堆排序
- 算法步骤
1）创建初始堆；（大顶堆和小顶堆）
2）把堆顶和堆尾互换；
3）把堆的尺寸缩小 1，并重新调整堆；
4）重复步骤 2，直到堆的尺寸为 1。 - 动图演示：
- 适用场景：
数据量大，适用面较广，可以适用比快排更大量的数，也适用于多核并行处理。堆排序所需的辅助空间少于快速排序，并且不会出现快速排序可能出现的最坏情况。 - 代码实现：
public class HeapSort{
public int[] sort(int[] arr){
int len = arr.length;
//先建大顶堆，用堆调整的方法建立
buildMaxHeap(arr, len);
for (int i = len -1 ; i > 0; i--) {
//交换堆顶和堆尾
swap(arr, 0 ,i);
len --; //堆大小减1
//调整堆
adjustHeap(arr, 0, len);
}
return arr;
}
//建大顶堆
private void buildMaxHeap(int[] arr, int len){
for (int i = len/2; i >= 0 ; i--) {
adjustHeap(arr, i, len);
}
}
//调整堆
private void adjustHeap(int[] arr, int index, int len){
int left = 2 * index + 1; //左子节点索引
int right = left + 1; //右子节点索引
int largest = index; //最大节点索引，默认值是当前节点（父节点）
//判断左子节点比父节点的大小，如果有节点，肯定必有左子节点
if (left < len && arr[left] > arr[largest]) {
largest=left;
}
//先判断是否有右子节点，再判断左右节点，哪个较大。
if (right < len && arr[right] > arr[largest]){
largest = right;
}
//当前位置的索引不是最大索引就交换，然后再重新调整，如果相等就不动。
if (largest != index){
swap(arr, index, largest);
adjustHeap(arr, largest, len);
}
}
//交换数据
private void swap(int[] arr, int i, int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
归并排序
- 算法步骤：
1）申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
2）设定两个指针，最初位置分别为两个已经排序序列的起始位置；
3）比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
4）重复步骤 3 直到某一指针达到序列尾；
5）将另一序列剩下的所有元素直接复制到合并序列尾 - 动图演示：
- 适用场景：
数据量大，且要求稳定的时候，可以考虑归并排序。 - 代码实现：
这里运用了Arrays.copyOfRange(T[ ] original,int from,int to)方法，将一个原始的数组original，从下标from开始复制，复制到上标to，生成一个新的数组。注意这里包括下标from，不包括上标to。
public class MergeSort{
public int[] sort(int[] arr){
if (arr.length < 2){
return arr;
}
int middle = arr.length / 2;
//将当前数组分为两部分（分治）
int[] left = Arrays.copyOfRange(arr, 0, middle);
int[] right = Arrays.copyOfRange(arr, middle, arr.length);
//递归
return mergeSort(sort(left), sort(right));
}
private int[] mergeSort(int[] left, int[] right){
//合并数组
int[] result = new int[left.length + right.length];
//判断左数组和右数组 中第一个数值的大小，将小的放入数组，并把小的那个数组的该项去掉
int i = 0;
while (left.length > 0 && right.length > 0){
if (left[0] <= right[0]){
result[i++] = left[0];
left = Arrays.copyOfRange(left,1, left.length);
}else{
result[i++] = right[0];
right = Arrays.copyOfRange(right,1, right.length);
}
}
//左边数组有剩余，加入数组
while (left.length > 0){
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
//右边数组有剩余，加入数组
while (right.length > 0){
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
}
快速排序
-
算法步骤：
1）首先取数组的第一个元素作为基准元素pivot。
2）重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
3）递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序； -
动图演示：
-
适用场景：
数据量大，快速排序是目前基于比较的排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短； -
代码实现：
public class QuickSort{
public int[] sort(int[] arr){
return quickSort(arr, 0, arr.length-1);
}
private int[] quickSort(int[] arr, int left, int right){
if (left < right){
int partition = partition(arr, left, right);
//分治
quickSort(arr, left, partition - 1);
quickSort(arr, partition + 1, right);
}
return arr;
}
private int partition(int[] arr, int left, int right){
int pivot = left;
int index = pivot + 1; //始终为第一个大于pivot值的位置
for (int i = index; i <= right; i++) {
if (arr[i] < arr[pivot]){
swap(arr, i, index);
index++;
}
}
//将pivot位置的值和最后一个小于pivot的值交换
swap(arr, pivot, index-1);
//交换后 index-1 就是 pivot 的位置
return index-1;
}
private void swap(int[] arr, int i, int j){
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
计数排序
- 算法步骤：
1）根据待排序集合中最大元素和最小元素的差值范围，申请额外空间；
2）遍历待排序集合，将每一个元素出现的次数记录到元素值对应的额外空间内；
3）对额外空间内数据进行计算，得出每一个元素的正确位置；
4）将待排序集合每一个元素移动到计算得出的正确位置上。 - 动图演示：
- 适用场景：
每个桶只存储单一键值；它的优势在于在对一定范围内的整数排序时，它的复杂度为Ο(n+k)（其中k是整数的范围），快于任何比较排序算法。当然这是一种牺牲空间换取时间的做法。 - 代码实现：
public class CountingSort{
public int[] sort(int[] arr){
int maxValue = getMaxValue(arr);
return countingSort(arr, maxValue);
}
private int[] countingSort(int[] arr, int maxValue){
int bucketLen = maxValue + 1;
int[] bucket = new int[bucketLen];
//按照数组中的值（对应桶中的key），将桶中对应值的加1
// 一个为1，两个就为2，...，依次增加，数组中value相同的情况
for (int value : arr){
bucket[value]++;
}
int sortedIndex = 0;
for (int i = 0; i < bucketLen; i++) {
//依次把桶中有数值的，将key取出来
while (bucket[i] > 0){
arr[sortedIndex++] = i;
//可能有相同的值
bucket[i]--;
}
}
return arr;
}
//取最大值，确定桶的范围
private int getMaxValue(int[] arr){
int maxValue = arr[0];
for(int value : arr){
if (maxValue < value){
maxValue = value;
}
}
return maxValue;
}
}
桶排序
- 算法步骤：
1）首先规定好桶的数量
2）其次计算好每个桶的数据范围 (max-min+1)/bucketCount
3）把数据放在对应的桶里，桶内是排好序的
4）遍历每个桶，得到最后排好序的序列 - 动图演示：
- 适用场景：
数据量大，求中位数。每个桶存储一定范围的数值，桶排序是计数排序的升级版。 - 代码实现：
public class BucketSort{
public int[] sort(int[] arr){
//7为桶数，自行设置
return bucketSort(arr,7);
}
private int[] bucketSort(int[] arr, int bucketLen){
if (arr.length == 0){
return arr;
}
//求数组的最大值和最小值
int minValue = arr[0];
int maxValue = arr[0];
for (int value: arr) {
if (value < minValue){
minValue = value;
}
if (value > maxValue){
maxValue = value;
}
}
//每个桶的大小
int bucketCount = (maxValue - minValue) / bucketLen + 1;
int[][] buckets = new int[bucketCount][0];
//利用映射函数将数据分配到各个桶中
for (int i = 0; i < arr.length; i++) {
int index = (arr[i] - minValue) / bucketLen;
//扩容桶，并添加数据
buckets[index] = arrAppend(buckets[index], arr[i]);
}
int arrIndex = 0;
for (int[] bucket : buckets) {
//取有数据的桶，进行排序
if(bucket.length > 0) {
//对每个桶进行排序，这里用的插入排序，数据量小用插入，数据量大用快速
InsertSort insertSort = new InsertSort();
bucket = insertSort.sort(bucket);
for (int value : bucket) {
arr[arrIndex++] = value;
}
}
}
return arr;
}
//扩容保存数据
private int[] arrAppend(int[] arr, int value){
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value; //新数组最后一位添加数据
return arr;
}
}
基数排序
- 算法步骤：
1）将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。
2）从最低位开始，依次进行一次排序。
3）这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
基数排序的方式可以采用 LSD（Least significant digital）或 MSD（Most significant digital），LSD 的排序方式由键值的最右边开始，而 MSD 则相反，由键值的最左边开始。 - 动图演示：
- 适用场景：
基数排序是一种非比较型整数排序算法，其原理是将整数按位数切割成不同的数字，然后按每个位数分别比较。由于整数也可以表达字符串（比如名字或日期）和特定格式的浮点数，所以基数排序也不是只能使用于整数。 - 代码实现：
public class RadixSort{
public int[] sort(int[] arr) {
int maxDigit = getMaxDigit(arr);
return radixSort(arr, maxDigit);
}
//获取最高位数
private int getMaxDigit(int[] arr) {
int maxValue = getMaxValue(arr);
return getNumLenght(maxValue);
}
//获取最大值
private int getMaxValue(int[] arr) {
int maxValue = arr[0];
for (int value : arr) {
if (maxValue < value) {
maxValue = value;
}
}
return maxValue;
}
//获取最高位，个位为1，十位为2，百位为3，...
private int getNumLenght(long num) {
if (num == 0) {
return 1;
}
int lenght = 0;
for (long temp = num; temp != 0; temp /= 10) {
lenght++;
}
return lenght;
}
private int[] radixSort(int[] arr, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
// 考虑负数的情况，这里扩展一倍队列数，其中 [0-9]对应负数，[10-19]对应正数 (bucket + 10)
int[][] buckets = new int[mod * 2][0];
for (int j = 0; j < arr.length; j++) {
//+mod 正好把正数和负数区分出来，[0-9]对应负数，[10-19]对应正数
int index = ((arr[j] % mod) / dev) + mod;
buckets[index] = arrayAppend(buckets[index], arr[j]);
}
//按照该位的顺序，把元素都放入到数组中。
int pos = 0;
for (int[] bucket : buckets) {
for (int value : bucket) {
arr[pos++] = value;
}
}
}
return arr;
}
//扩容保存数据
private int[] arrayAppend(int[] arr, int value) {
arr = Arrays.copyOf(arr, arr.length + 1);
arr[arr.length - 1] = value; //新数组最后一位添加数据
return arr;
}
}
代码下载连接：本文的可运行代码
参考连接：
https://www.toutiao.com/i6704815171367338508/
https://www.jianshu.com/u/47a4e21999fc
扫一扫
1395
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
