排序算法
Posted 爱学习的大鱼
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了排序算法相关的知识，希望对你有一定的参考价值。
1.排序的介绍
排序也成为排序算法(Sort Algoritm)，排序是将一组数据,按指定的顺序进行排列的过程。
2. 排序的分类
-
内部排序法：
将需要处理的所有数据都加载到内部存储器(内存)中进行排序
-
外部排序法
数据量过大，无法全部加载到内存中，需要借助外部存储(如文件)进行排序。
-
常见的排序算法分类如下图：
相关术语解释：
1)稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
2)不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
3)内排序：所有排序操作都在内存中完成；
4)外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
5)时间复杂度： 一个算法执行所耗费的时间。
6)空间复杂度：运行完一个程序所需内存的大小。
7)n: 数据规模
3.排序算法的时间和空间复杂度
| 排序方法 | 时间复杂度(平均) | 时间复杂度(最坏) | 时间复杂度(最好) | 空间复杂度 | 稳定性 | 复杂性 |
|---|---|---|---|---|---|---|
| 直接插入排序 | O(n2) | O(n2) | O(n) | O(1) | 稳定 | 简单 |
| 希尔排序 | O(nlog2n) | O(n2) | O(n1.3) | O(1) | 不稳定 | 较复杂 |
| 直接选择排序 | O(n2) | O(n2) | O(n2) | O(1) | 不稳定 | 简单 |
| 堆排序 | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(1) | 不稳定 | 较复杂 |
| 冒泡排序 | O(n2) | O(n2) | O(n) | O(1) | 稳定 | 简单 |
| 快速排序 | O(nlog2n) | O(n2) | O(nlog2n) | O(nlog2n) | 不稳定 | 较复杂 |
| 归并排序 | O(nlog2n) | O(nlog2n) | O(nlog2n) | O(n) | 稳定 | 较复杂 |
| 基数排序 | O(d(n+r)) | O(d(n+r)) | O(d(n+r)) | O(n+r) | 稳定 | 较复杂 |
4. 排序算法原理即代码实现
4.1 冒泡排序
4.1.1 介绍
冒泡排序（Bubble Sort） 最为简单的一种排序，通过重复走完数组的所有元素，通过打擂台的方式两两比较，直到没有数可以交换的时候结束这个数，再到下个数，直到整个数组排好顺序。因一个个浮出所以叫冒泡排序。双重循环时间 复杂度O(n^2)
4.1.2 算法步骤
- 比较相邻两个数据如果。第一个比第二个大，就交换两个数
- 对每一个相邻的数做同样1的工作，这样从开始一队到结尾一队在最后的数就是最大的数。
- 针对所有元素上面的操作，除了最后一个。
- 重复1~3步骤，直到顺序完成。
4.1.3 动画演示
4.1.4 java 代码实现和数据测试
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class BubbleSort
public static void main(String[] args)
//时间复杂度为O(n^2)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int)(Math.random()*1000000);
long time = System.currentTimeMillis();
//sort1(arr);//未优化 time = 14536 time = 14184 time = 13270
sort2(arr);//优化 time = 13075 time = 13539 time = 13388
System.out.println("time = " + (System.currentTimeMillis() - time));
//冒泡排序
public static void sort1(int[] arr)
//数组长度
int len = arr.length;
for (int i = 0; i < len - 1; i++)
for (int j = 0; j < len - i - 1; j++)
//前一个元素大于后一个元素则交换
if (arr[j] > arr[j + 1])
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//冒泡排序优化
public static void sort2(int[] arr)
int len = arr.length;
//标志位
boolean flag;
for (int i = 0; i < len - 1; i++)
//未交换 为true
flag = true;
for (int j = 0; j < len - i - 1; j++)
//前一个元素大于后一个元素则交换
if (arr[j] > arr[j + 1])
//有交换则为false
flag = false;
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
//System.out.printf("第%d次交换:%s\\n", i + 1, Arrays.toString(arr));
//标志未变化则有序无需在进行交换
if (flag)
break;
4.2 选择排序
4.2.1 介绍
选择排序（Select Sort） 是直观的排序，通过确定一个 Key 最大或最小值，再从带排序的的数中找出最大或最小的交换到对应位置。再选择次之。双重循环时间复杂度为 O(n^2)
4.2.2 算法步骤
- 首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置。
- 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
- 重复第二步，直到所有元素均排序完毕。
4.2.3 动画演示
4.2.4 java 代码实现和数据测试
import java.util.Arrays;
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class SelectSort
public static void main(String[] args)
//时间复杂度为O(n^2)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int)(Math.random()*1000000);
long time = System.currentTimeMillis();
sort(arr);
//time = 5168 time = 5228 time = 5172
//时间比冒泡快,因为减少了交换数据的次数
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = -1,-42,213,3,1,-423,23,12,0;
//sort(arr);
//System.out.println(Arrays.toString(arr));
//选择排序
public static void sort(int[] arr)
//定义最小数
int min;
//定义标识符
int index;
//数组长度
int len = arr.length;
for (int i = 0; i < len - 1; i++)
min = arr[i];
index = i;
for (int j = i + 1; j < len; j++)
if (min < arr[j])
min = arr[j];
index = j;
if (index != i)
arr[index] = arr[i];
arr[i] = min;
//System.out.printf("第%d次交换:%s\\n", i + 1, Arrays.toString(arr));
4.3 插入排序
4.3.1 介绍
插入排序(InsertionSort)，一般也被称为直接插入排序。对于少量元素的排序，它是一个有效的算法。双重循环时间复杂度为 O(n^2)
4.3.2 算法步骤
- 将第一待排序序列第一个元素看做一个有序序列，把第二个元素到最后一个元素当成是未排序序列。
- 从头到尾依次扫描未排序序列，将扫描到的每个元素插入有序序列的适当位置。（如果待插入的元素与有序序列中的某个元素相等，则将待插入元素插入到相等元素的后面。）
4.3.3 动画演示
4.3.4 java 代码实现和数据测试
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class InsertSort
public static void main(String[] args)
//时间复杂度为O(n^2)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int) (Math.random() * 1000000);
long time = System.currentTimeMillis();
sort(arr);
//time = 852 time = 826 time = 836 time = 776
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = new int[]6, 5, 4, 3, 2, 1;
//sort(arr);
//System.out.println(Arrays.toString(arr));
//插入排序
public static void sort(int[] arr)
int len = arr.length;
int insert;
int index;
for (int i = 1; i < len; i++)
insert = arr[i];
index = i - 1;
while (index >= 0 && arr[index] > insert)
arr[index + 1] = arr[index];
index--;
arr[index + 1] = insert;
//System.out.printf("第%d次交换:%s\\n", i + 1, Arrays.toString(arr));
4.4 希尔排序
4.4.1 介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。
4.4.2 算法步骤
- 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
- 按增量序列个数 k，对序列进行 k 趟排序；
- 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
4.4.3 动画演示
4.4.4 java 代码实现和数据测试
import java.util.Arrays;
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class ShellSort
public static void main(String[] args)
//时间复杂度为O(log2n)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int) (Math.random() * 1000000);
long time = System.currentTimeMillis();
sort2(arr);
//time = 23 time = 20 time = 21
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = 8, 9, 1, 7, 2, 3, 5, 4, 6, 0;
//sort2(arr);
//希尔排序(交换法效率低) time = 8053 略快于冒泡排序
public static void sort1(int[] arr)
int len = arr.length;
int temp;
for (int gap = len / 2; gap > 0; gap /= 2)
for (int i = gap; i < len; i++)
for (int j = i - gap; j >= 0; j -= gap)
if (arr[j] > arr[j + gap])
temp = arr[j];
arr[j] = arr[j + gap];
arr[j + gap] = temp;
System.out.println(Arrays.toString(arr));
//希尔排序(插入法) time = 21
public static void sort2(int[] arr)
//插入值
int insert;
//标识符,插入值的上一个分组内的值坐标
int index;
int len = arr.length;
for (int gap = len / 2; gap > 0; gap /= 2) //分组,每次除2
for (int i = gap; i < len; i++) //对分组排序
insert = arr[i];
index = i - gap;
//分组内部插入排序 上个坐标大于等于0 且上个坐标值大于插入值
if (arr[index] > insert) //优化数据量越大效果越明显
while (index >= 0 && arr[index] > insert)
//满足交换 坐标后移
arr[index + gap] = arr[index];
index -= gap;
//交换完成后给对应坐标赋值
arr[index + gap] = insert;
//System.out.println(Arrays.toString(arr));
4.5 快速排序
4.5.1 介绍
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，排序 n 个项目要 Ο(nlogn) 次比较。在最坏状况下则需要 Ο(n2) 次比较，但这种状况并不常见。事实上，快速排序通常明显比其他 Ο(nlogn) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。
4.5.2 算法步骤
- 从数列中挑出一个元素，称为 "基准"（pivot）;
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
4.5.3 动画演示
4.5.4 java 代码实现和数据测试
import java.util.Arrays;
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class QuickSort
public static void main(String[] args)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int) (Math.random() * 1000000);
long time = System.currentTimeMillis();
sort1(arr, 0, arr.length - 1);//time = 20 time = 10 time = 30
//sort2(arr, 0, arr.length - 1);//time = 30 time = 20time = 32
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = 9, 8, 7, 6, 5, 4, 3, 2, 1;
//System.out.println(arr.length - 1);
//sort1(arr, 0, arr.length - 1);
//System.out.println(Arrays.toString(arr));
//取左值
private static void sort1(int[] arr, int left, int right)
if (left < right)
//设置基准值的位置
int pivot = left;
//比较开始值
int index = pivot + 1;
//循环将比pivot小的值放在index-1(后面新的pivot)的左边,大的值放右边
for (int i = index; i <= right; i++)
if (arr[i] < arr[pivot])
swap(arr, i, index);
index++;
//交换index的值
swap(arr, pivot, index - 1);
//定义新的基础下标
pivot = index - 1;
//左遍历,基准下标左移
sort1(arr, left, pivot - 1);
//右遍历,基准下标右移
sort1(arr, pivot + 1, right);
//取中间值
public static void sort2(int[] arr, int left, int right)
int r = right; //右标志位
int l = left; //坐标值位
int pivot = arr[(r + l) / 2]; //中间值(基准值)
//循环条件
while (l < r)
//左值小于中间值,则向右移动一位,直到找到大于中间值或中间值为止,得到该值坐标l
while (arr[l] < pivot)
l++;
//中间值小于右值,则向左移动一位,直到找到小于中间值或中间值为止,得到该值坐标r
while (pivot < arr[r])
r--;
//如果r>=l则退出循环
if (l >= r)
break;
//交换
swap(arr, l, r);
//如果(交换后)左值等于了中间值,说明中间值左边全部小于中间值,则无需在移动,移动右值
if (arr[l] == pivot)
r--;
//同理,移动左值,避免特殊情况(多个等于中间值)
if (arr[r] == pivot)
l++;
//退出循环时则完成了 左边值 <= 基准值 <= 右边值
//如果退出循环两个值相等则分别向另一个位置移动一格,以便递归
if (l == r)
l++;
r--;
//右递归
if (l < right)
sort2(arr, l, right);
//左递归
if (left < r)
sort2(arr, left, r);
//交换
public static void swap(int[] arr, int x, int y)
int temp = arr[x];
arr[x] = arr[y];
arr[y] = temp;
4.6 归并排序
4.6.1 介绍
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
4.6.2 算法步骤
- 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
- 设定两个指针，最初位置分别为两个已经排序序列的起始位置；
- 比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
- 重复步骤 3 直到某一指针达到序列尾；
- 将另一序列剩下的所有元素直接复制到合并序列尾。
4.6.3 动画演示
4.6.4 java 代码实现和数据测试
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class MergeSort
public static void main(String[] args)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int) (Math.random() * 1000000);
long time = System.currentTimeMillis();
mergeSort(arr, 0, arr.length - 1);//time = 26 time = 29 time = 28
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = 8, 4, 5, 7, 1, 3, 6;
//mergeSort(arr, 0, arr.length - 1);
//System.out.println(Arrays.toString(arr));
//归并排序
public static void mergeSort(int arr[], int left, int right)
//判断当前数组的长度是否满足要求(大于1)
if (left < right)
//中间值
int mid = (left + right) / 2;
//分治,将一个大数组分成两个小数组
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
//合并,递归的最底层为两个数据,向上回溯
merge(arr, left, mid, right);
//合并(两个数组)数据并排序
public static void merge(int[] arr, int left, int mid, int right)
//用i、j表示两个数组开始的起始坐标
int i = left;//[left,mid]
int j = mid + 1;//[mid+1,right]
//创建存放数据的临时数组空间,大小为(right - left) + 1
int[] temp = new int[(right - left) + 1];
//temp的起始位置
int t = 0;
//两个有序数组比较数据大小,按顺序将数据放入临时数组中,如果其中一个数组放置完成则退出循环
while (i <= mid && j <= right)
temp[t++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
//如果数组未遍历完则将剩余数据添加到 temp 后面
while (i <= mid)
temp[t++] = arr[i++];
//同上
while (j <= right)
temp[t++] = arr[j++];
//System.out.println("left = " + left + "\\tright = " + right);
t = 0;//恢复temp起始位置
//将合并的有序数据覆盖掉原有数据
while (left <= right)
arr[left++] = temp[t++];
4.7 基数排序
4.7.1 介绍
基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
4.7.2 算法步骤
- 事先准备10个数组(10个桶)， 0-9 分别对应 位数的 0-9
- 第一轮按照个位大小 放入到 对应的 各个数组中
- 然后从 0-9 个数组/桶，依次，按照加入元素的先后顺序取出
- 第二轮按照十位排序，将各个数，按照十位大小 放入到 对应的 各个数组中
- 然后从 0-9 个数组/桶，依次，按照加入元素的先后顺序取出
- 重复上述炒作直至最大数位数为止
4.7.3 动画演示
4.7.4 java 代码实现和数据测试
import java.util.Arrays;
/**
* @author 谢阳
* @version 1.8.0_131
*/
public class RadixSort
public static void main(String[] args)
int[] arr = new int[80000];
for (int i = 0; i < 80000; i++)
arr[i] = (int) (Math.random() * 1000000);
long time = System.currentTimeMillis();
radixSort(arr);
//time = 31 time = 21 time = 26 数据量越大效果越明显
System.out.println("time = " + (System.currentTimeMillis() - time));
//int[] arr = 53, 3, 542, 748, 14, 214, 9999, 12, 10000, 0;
//radixSort(arr);
//System.out.println(Arrays.toString(arr));
//基数排序
public static void radixSort(int[] arr)
//获取数组长度
int len = arr.length;
//获取数组中最大值
int maxValue = getMaxValue(arr, len);
//获取该数的长度
int valueLength = getValueLength(maxValue);
//创建放数的桶,10 表示 0~9 号桶
int[][] bucket = new int[10][len];
//创建统计每个桶中数据对应的计数器
int[] preBucketCount = new int[10];
//创建记录数据所在桶的坐标记录
int bucketIndex;
//循环valueLength次,dev是决定每次排序按相应规则(个、十、百等)排序
for (int i = 0, dev = 1; i < valueLength; i++, dev *= 10)
//遍历放入对应桶中
for (int j = 0; j < len; j++)
bucketIndex = arr[j] / dev % 10;//个位、十位、百位...
bucket[bucketIndex][preBucketCount[bucketIndex]] = arr[j];
//计数器大小等于值的个数
preBucketCount[bucketIndex]++;
int index = 0;
//遍历桶中数据并覆盖掉原有数据
for (int j = 0; j < bucket.length; j++)
for (int k = 0; k < preBucketCount[j]; k++)
arr[index++] = bucket[j][k];
//将计数清零
preBucketCount[j] = 0;
//得到数组中最大值
public static int getMaxValue(int[] arr, int len)
if (len == 0)
return 0;
int max = arr[0];
for (int i = 1; i < arr.length; i++)
if (max < arr[i])
max = arr[i];
return max;
//计算数值的长度
public static int getValueLength(int value)
int count = 0;
while (value != 0)
count++;
value /= 10;
return count;
参考资料
尚硅谷Java数据结构与java算法（Java数据结构与算法）
以上是关于排序算法的主要内容，如果未能解决你的问题，请参考以下文章