所有人对排序这个词并不陌生，最常见的从小到大，从大到小排序，按年龄和身高排序，或者是人们日常生活中点外卖时商家的排序。同样在java中，任何Comparable的对象，即任何实现了接口Comparable进而定义了方法compareTo的类的对象，都可以排序。如何具体的比较两个对象，依赖于对象的特性。
目录
常见排序算法分类
时间复杂度简单介绍
假如我要去超市。有如下选择，走路，自己开车，坐朋友车，坐公共汽车。哪种方式最好？首先，最好的概念是什么？是最省钱，最省自己的时间，最省朋友的时间，还是对环境更有利？假定对读者而言，最好的选择是指最快的方式。在定义了标准后，如何来评估这些选择？显然不希望将所有4种选择都试一遍后才发现哪一种最快。就像编写四个不同的程序来执行同一个任务从而可以度量哪一个是最快的。相反，读者可以考查每种选择的开销，考虑旅行的距离和速度，交通的拥挤程度，天气等等。
衡量一个算法的复杂度，并非度量这个算法有多棘手或者多困难，而是度量算法执行所需要的时间，称之为时间复杂度。或者执行所需要内存，称为算法的空间复杂度。常对这两种复杂度分别度量。
衡量一个程序（算法）的执行时间
①事后统计法：先运行，后看时间。但要在同一硬件，同一电脑下运行
②事前估算法：分析时间复杂度
时间频度：一个算法花费的时间与算法中语句的执行次数成正比例，哪个算法中语句执行次数多，它花费时间就多。一个算法中的语句执行次数称为语句频度或时间频度。记为T(n)。
tips：①忽略常数项 比如5n + 10 与 6n + 20。 后面的常数项可忽略。
②忽略低次项：比如3n^2 + n + 10 与 4n^2 + n + 20。后面的n + 10 与 n + 20 可忽略。
③忽略系数：比如8n^2+7n 和 6n^2 + 2n n前面的8和6可以省略。
-
一般情况下，算法中的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
-
T(n) 不同，但时间复杂度可能相同。 如：T(n)=n²+7n+6 与 T(n)=3n²+2n+2 它们的T(n) 不同，但时间复杂度相同，都为O(n²)。
-
计算时间复杂度的方法：
- 用常数1代替运行时间中的所有加法常数 T(n)=n²+7n+6 => T(n)=n²+7n+1
- 修改后的运行次数函数中，只保留最高阶项 T(n)=n²+7n+1 => T(n) = n²
- 去除最高阶项的系数 T(n) = n² => T(n) = n² => O(n²）
常见的时间复杂度：
- 常见的算法时间复杂度由小到大依次为：Ο(1)＜Ο(log2n)＜Ο(n)＜Ο(nlog2n)＜Ο(n^2)＜Ο(n^3)＜ Ο(n^k) ＜Ο(2^n) < O(n!)，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低。慎用指数阶的算法，（指数爆炸）
- 常数阶O(1)
- 没有循环，无论代码有多长，时间复杂度都是O(1)
int i = 1; int j = 2; i++; j++; int m = i + j; -
对数阶O(log2n)
-
说明：在while循环里面，每次都将 i 乘以 2，乘完之后，i 距离 n 就越来越近了。假设循环x次之后，i 就大于 2 了，此时这个循环就退出了。也就是说 2 的 x 次方等于 n，那么 x = log2n也就是说当循环 log2n 次以后，这个代码就结束了。因此这个代码的时间复杂度为：O(log2n) 。 O(log2n) 的这个2 时间上是根据代码变化的，i = i * 3 ，则是 O(log3n)
int n = 100; int i = 1; while (i < n) { i = i * 2; } -
线性阶O(n)
-
说明：这段代码，for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度
int n = 100; int j = 0; for (int i = 1; i <= n; i++) { j = i; j++; } -
线性对数阶O(nlog2n)
-
顾名思义，根据前两个，线性对数阶O(nlogN) 是，将时间复杂度为O(logn)的代码循环N遍的话，那么它的时间复杂度就是 n*O(log2N)，也就是了O(nlog2N)
int n = 100; int m; int i; for (m = 1; m < n; m++) { i = 1; while (i < n) { i = i * 2; } } -
平方阶O(n^2)
-
平方阶O(n²) ，如果把 O(n) 的代码再嵌套循环一遍，它的时间复杂度就是 O(n²)，这段代码其实就是嵌套了2层n循环，它的时间复杂度就是 O(nn)，即 O(n²) 如果将其中一层循环的n改成m，那它的时间复杂度就变成了 O(mn)
int x; int j; int i = 0; int n = 100; for (x = 1; i <= n; x++) { for (i = 1; i <= n; i++) { j = i; j ++; } } -
立方阶O(n^3)
-
就是三层循环，依次类推
-
k次方阶O(n^k)
-
依次类推
-
指数阶O(2^n)
冒泡排序
基本思想：通过对待排序序列从前向后（从下标较小的元素开始），两个指针变量，依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像杯子里的气泡一样逐渐向上冒。
因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行国交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行国交换。从而减少不必要的比较。
public class BubbleSort {
public static void main(String[] args) {
//int arr[] = {3,9,-1,10,20};
//System.out.println("排序前");
//System.out.println(Arrays.toString(arr));
//测试冒泡排序的速度O(n^2),给80000个数据，测试
//创建要给80000个随机的数组
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 800000);//random表示0到1的某个小数
}
//排序前
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
//测试冒泡排序
bubbleSort(arr);
//排序后
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
//System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
/*
//第二趟排序，就是将第二大的数排在倒数第二位
for (int j = 0;j < arr.length - 1 - 1;j++){
//如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第二趟排序后的数组");
System.out.println(Arrays.toString(arr));
//第三趟排序，就是将第三大的数排在倒数第三位
for (int j = 0;j < arr.length - 1 - 2;j++){
//如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第三趟排序后的数组");
System.out.println(Arrays.toString(arr));
//第四趟排序，就是将第四大的数排在倒数第四位
for (int j = 0;j < arr.length - 1 - 3;j++){
//如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
System.out.println("第四趟排序后的数组");
System.out.println(Arrays.toString(arr));
*/
}
//封装成一个方法
public static void bubbleSort(int[] arr){
//m冒泡排序的时间复杂度O(n^2) //n的平方
int temp = 0;//临时变量
boolean flag = false;//标识变量，表示是否进行过交换 优化
for (int i = 0;i < arr.length - 1;i++){
for (int j = 0;j < arr.length - 1 - i;j++){
//如果前面的数比后面的数大，则交换
if (arr[j] > arr[j + 1]){
flag = true;
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
//System.out.println("第"+(i+1)+"趟排序后的数组");
//System.out.println(Arrays.toString(arr));
if (!flag){//在一趟排序中，一次交换都没有发生过
break;
}else {
flag = false;//重置flag ! ,进行下一次判断
}
}
}
}
选择排序
基本思想：第一次从arr[0] 到 arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1] 到 arr[n-1] 中选取最小值，与arr[1]交换。第三次从arr[2] 到 arr[n-1]中选取最小值，与arr[2]交换，依次类推，第i次从arr[i - 1] 到 arr[n - 1]中选取最小值，与arr[i - 1]交换。得到一个从小到大的有序序列。
public class SelectSort {
public static void main(String[] args) {
//int[] arr = {101,34,119,1};
//创建要给80000个随机的数组
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
System.out.println("排序前");
//System.out.println(Arrays.toString(arr));
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
selectSort(arr);
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
//System.out.println("排序后");
//System.out.println(Arrays.toString(arr));
}
//选择排序
public static void selectSort(int[] arr){
//在推导的过程中，我们发现了规律，因此可以用for来解决
//选择排序时间复杂度是O(n^2)
for (int i = 0;i < arr.length - 1;i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {//说明假定的最小值，并不是最小
min = arr[j];//重置min
minIndex = j;//重置minIndex
}
}
//将最小值，放在arr[0],即交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
//System.out.println("第"+(i+1)+"轮后");
//System.out.println(Arrays.toString(arr));
}
//原始的数组：101 34 119 1
//第一轮排序 1 34 119 101
/*
//第一轮
int minIndex = 0;
int min = arr[0];
for (int j = 0 + 1;j < arr.length;j++){
if (min > arr[j]){//说明假定的最小值，并不是最小
min = arr[j];//重置min
minIndex = j;//重置minIndex
}
}
//将最小值，放在arr[0],即交换
if (minIndex != 0){
arr[minIndex] = arr[0];
arr[0] = min;
}
System.out.println("第一轮后");
System.out.println(Arrays.toString(arr));
//第2轮
minIndex = 1;
min = arr[1];
for (int j = 1 + 1;j < arr.length;j++){
if (min > arr[j]){//说明假定的最小值，并不是最小
min = arr[j];//重置min
minIndex = j;//重置minIndex
}
}
//将最小值，放在arr[0],即交换
if (minIndex != 1){
arr[minIndex] = arr[1];
arr[1] = min;
}
System.out.println("第2轮后");
System.out.println(Arrays.toString(arr));
//第3轮
minIndex = 2;
min = arr[2];
for (int j = 2 + 1;j < arr.length;j++){
if (min > arr[j]){//说明假定的最小值，并不是最小
min = arr[j];//重置min
minIndex = j;//重置minIndex
}
}
//将最小值，放在arr[0],即交换
if (minIndex != 2){
arr[minIndex] = arr[2];
arr[2] = min;
}
System.out.println("第3轮后");
System.out.println(Arrays.toString(arr));
*/
}
}
插入排序
基本思想：把n个元素看成一个有序表，一个无序表，刚开始arr[0]为有序表，后面所有数为无序表，第一次把后面的无序表的第一个放到有序表中，并在有序表中是按从小到大的排序（现在有序表是两个排序好的元素）。第二次再从无序表中放一个到有序表中，并在有序表中进行排序（此时有序表是三个有序的元素）.....依次类推。
图片理解
public class InsertSort {
public static void main(String[] args) {
//int[] arr = {101,34,119,1,66,33,-88};
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
insertSort(arr);//调用插入排序算法
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
}
//插入排序
public static void insertSort(int[] arr){
int insertVal = 0;
int insertIndex = 0;
//使用for循环把代码简化
for (int i = 1;i < arr.length;i++){
//第一轮{101,34,119,1} => {34,101,119,1}
//定义待插入的数
insertVal = arr[i];
//索引
insertIndex = i - 1;//即arr[1]的前面这个数的下标
//给insertVal 找到插入的位置
//说明
//1.insertIndex >= 0保证在给insertVal 找插入位置，不越界
//2.insertVal < arr[insertIndex] 待插入的数，还没有找到插入的位置
//3.就需要将arr[indexIndex] 后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];//{101,34,119,1} => {101,101,119,1}
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insertIndex + 1
//这里我们判断是否需要赋值
if (insertIndex + 1 != i){
arr[insertIndex + 1] = insertVal;
}
//System.out.println("第"+i+"轮插入");
//System.out.println(Arrays.toString(arr));
}
/*
//第一轮{101,34,119,1} => {34,101,119,1}
//定义待插入的数
int insertVal = arr[1];
//索引
int insertIndex = 1 - 1;//即arr[1]的前面这个数的下标
//给insertVal 找到插入的位置
//说明
//1.insertIndex >= 0保证在给insertVal 找插入位置，不越界
//2.insertVal < arr[insertIndex] 待插入的数，还没有找到插入的位置
//3.就需要将arr[indexIndex] 后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];//{101,34,119,1} => {101,101,119,1}
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insertIndex + 1
arr[insertIndex + 1] = insertVal;
System.out.println("第一轮插入");
System.out.println(Arrays.toString(arr));
//第2轮
insertVal = arr[2];
insertIndex = 2 - 1;
while (insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];//{101,34,119,1} => {101,101,119,1}
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第2轮插入");
System.out.println(Arrays.toString(arr));
//第3轮
insertVal = arr[3];
insertIndex = 3 - 1;
while (insertIndex >= 0 && insertVal < arr[insertIndex]){
arr[insertIndex + 1] = arr[insertIndex];//{101,34,119,1} => {101,101,119,1}
insertIndex--;
}
arr[insertIndex + 1] = insertVal;
System.out.println("第3轮插入");
System.out.println(Arrays.toString(arr));
*/
}
}
希尔排序（缩小增量排序）
基本思想：希尔排序也是一种排序算法，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量法。（我的理解是 一大堆无序的数据，参差不齐，缩小增量的话。怎么说，感觉就像采了一大堆萝卜，经过分组再缩小增量再分组的方法，不会导致几个巨大的萝卜摆在前几个，巨小的萝卜排在最后几个，虽然还没有真正从小到大排好，但各个萝卜之间的个头差距不会太大。减少工作量。）
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序。
希尔排序交换法：分完组后，按照简单插入排序进行排序，一个个比较的排，很浪费时间。
希尔排序移动法：分完组后，在这一组以内，找到最小的那个依次进行排序。节约时间。
图片理解
public class ShellSort {
public static void main(String[] args) {
//int[] arr = {8,9,1,7,2,3,5,4,6,0};
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
//shellSort(arr);//交换式
shellSort2(arr);//移位式
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
}
//使用逐步推导的方式来编写希尔排序
public static void shellSort(int[] arr){
int temp = 0;
int count = 0;
//更具逐步分析，使用for循环 循环gap代替
for (int gap = arr.length / 2;gap > 0;gap /= 2){
for (int i = gap;i < arr.length;i++){
//遍历各组中所有的元素(共5组，每组有2个元素)，步长gap
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("希尔排序第"+ (++count) +"轮=" + Arrays.toString(arr));
}
/*
int temp = 0;
//希尔排序的第一轮排序
//因为第一轮排序，是将10个数据分成了5组
for (int i = 5;i < arr.length;i++){
//遍历各组中所有的元素(共5组，每组有2个元素)，步长5
for (int j = i - 5;j >= 0;j -= 5){
//如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j] > arr[j + 5]){
temp = arr[j];
arr[j] = arr[j + 5];
arr[j + 5] = temp;
}
}
}
System.out.println("希尔排序一轮后=" + Arrays.toString(arr));
//希尔排序的第二轮排序
//因为第二轮排序，是将10个数据分成了5/2 = 2组
for (int i = 2;i < arr.length;i++){
//遍历各组中所有的元素(共2组，每组有2个元素)，步长2
for (int j = i - 2;j >= 0;j -= 2){
//如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j] > arr[j + 2]){
temp = arr[j];
arr[j] = arr[j + 2];
arr[j + 2] = temp;
}
}
}
System.out.println("希尔排序二轮后=" + Arrays.toString(arr));
//希尔排序的第三轮排序
//因为第三轮排序，是将10个数据分成了2/2 = 1组
for (int i = 1;i < arr.length;i++){
//遍历各组中所有的元素(共2组，每组有2个元素)，步长2
for (int j = i - 1;j >= 0;j -= 1){
//如果当前元素大于加上步长后的那个元素，说明交换
if (arr[j] > arr[j + 1]){
temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
System.out.println("希尔排序三轮后=" + Arrays.toString(arr));
*/
}
//对交换式的希尔排序进行优化 -》移位法
public static void shellSort2(int[] arr){
//增量gap，并逐步的缩小增量
for (int gap = arr.length / 2;gap > 0;gap /= 2){
//从第gap个元素，逐个对其所在的组进行直接插入排序
for (int i = gap;i < arr.length;i++){
int j = i;
int temp = arr[i];
if (arr[j] < arr[j - gap]){
while (j - gap >= 0 && temp < arr[j - gap]){
//移动
arr[j] = arr[j - gap];
j -= gap;
}
//当退出while后，就给temp找到插入的位置
arr[j] = temp;
}
}
}
}
}
快速排序
基本思想：快速排序是利用分治的思想对冒泡排序的的一种改进。
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，这两部分分别向下递归进行。
图片理解：
public class QuickSort {
public static void main(String[] args) {
//int[] arr = {-9,88,0,24,-555,70};
//测试快排执行速度
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
quickSort(arr,0, arr.length-1);//中间值占了一位，所以要减1
//System.out.println("arr=" + Arrays.toString(arr));
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
}
public static void quickSort(int[] arr,int left,int right){
int l = left;
int r = right;
//pivot 中轴值
int pivot = arr[(left + right) / 2];
int temp = 0;//临时变量，作为交换时使用
//while循环的目的是让比pivot值小放到左边
//比pivot值大的放到右边
while (l < r){
//在pivot的左边一直找，找到大于等于pivot值，才退出
while (arr[l] < pivot){
l += 1;
}
//在pivot的右边一直找，找到小于等于pivot值，才退出
while (arr[r] > pivot){
r -= 1;
}
//如果l >= r说明pivot的左右两的值，已经按照左边全部是小于等于pivot值，右边全部都是大于等于pivot的值
if (l >= r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换完后，发现这个arr[l] == pivot值相等 就让r--，前移
if (arr[l] == pivot){
r -= 1;
}
//如果交换完后，发现这个arr[r] == pivot 就让l++，后移
if (arr[r] == pivot){
l += 1;
}
}
//如果l == r，必须l++，r--，否则会出现栈溢出
if (l == r){
l += 1;
r -= 1;
}
//向左递归
if (left < r){
quickSort(arr,left,r);
}
//向右递归
if (right > l){
quickSort(arr,l,right);
}
}
}
归并排序
基本思想：归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)
归并是将一个数组分为两半，对着两半分别排序，再将他们归并成一个有序数组。归并排序的算法通常是以递归的形式表达的。递归算法将一个问题的解法分解成两个或更多个规模更小却截然不同的问题，分别解决每个新问题，再将他们的解法组合起来解决原问题，这样的策略称为是一种分治法，也就是说，将问题分割成若干部分，分别对每一部分求解，从而得到整个解。尽管分治算法通常是以递归的形式表达的，但不要求一定要表达为递归的形式。
图片理解：
治的图解
代码演示：
public class MergeSort {
public static void main(String[] args) {
//int arr[] = {8,4,5,7,1,3,6,2};
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
int temp[] = new int[arr.length];//归并排序需要一个额外空间
mergeSort(arr,0,arr.length - 1,temp);
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
//System.out.println("归并排序后=" + Arrays.toString(arr));
}
//分+合方法
public static void mergeSort(int[] arr,int left,int right,int[] temp){
if (left < right){
int mid = (left + right) / 2;//中间索引
//向左递归进行分解
mergeSort(arr,left,mid,temp);
//向右递归进行分解
mergeSort(arr,mid + 1,right,temp);
//合并
merge(arr,left,mid,right,temp);
}
}
//合并方法
/**
*
* @param arr 排序的原始数组
* @param left 左边有序序列的初始索引
* @param mid 中间索引
* @param right 右边索引
* @param temp 转化后的数组，做中转的数组
*/
//最好看图理解
public static void merge(int[] arr,int left,int mid,int right,int[] temp){
//System.out.println("xxxx");
int i = left;//初始化i，左边有序序列的初始索引
int j = mid + 1;//初始化j，右边有序序列的初始索引。加1因为mid是中间靠左的数，所以要加1
int t = 0;//指向temp数组的当前索引
//(一)
//先把左右两边(有序)的数据按照规则填充到temp数组
//直到左右两边的有序序列，有一边处理完毕为止
while (i <= mid && j <= right){
//如果左边的有序序列的当前元素，小于等于右边的有序序列的当前元素
//即将左边的当前元素，填充到temp数组
//然后t++,i++
if (arr[i] <= arr[j]){
temp[t] = arr[i];
t += 1;
i += 1;
}else {//反之，将右边有序序列的当前元素，填充到temp数组
temp[t] = arr[j];
t += 1;
j += 1;
}
}
//(二)
//把有剩余数据的一边的数据依次全部填充到temp中
while (i <= mid){//左边的有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[i];
t += 1;
i += 1;
}
while (j <= right){//右边的有序序列还有剩余的元素，就全部填充到temp
temp[t] = arr[j];
t += 1;
j += 1;
}
//(三) 看图理解
//将temp数组的元素拷贝到arr
//注意，并不是每次都拷贝所有，治，一部分一部分的治下去
t = 0;
int tempLeft = left;
//第一次合并 tempLeft = 0，right = 1 第二次 tl = 2 ri = 3 第三次 tl = 0 ri = 3
//最后一次tl = 0 ri = 7
//System.out.println("tempLeft= " + tempLeft + "right= " + right);
while (tempLeft <= right){
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
基数排序（桶排序）
- 基数排序（radix sort）属于“分配式排序”（distribution sort），又称桶排序（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
- 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
- 基数排序(Radix Sort)是桶排序的扩展
- 基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较
- 基数排序是按照低位先排序，然后收集
- 再按照高位排序，然后再收集
- 依次类推，直到最高位
- 有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序
- 最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前
代码演示：
public class RadixSort {//桶排序 基数排序 快
public static void main(String[] args) {
//int arr[] = {53, 3, 542, 748, 14, 214};
int[] arr = new int[80000];
for (int i = 0;i < 80000;i++){
arr[i] = (int) (Math.random() * 8000000);
}
System.out.println("排序前");
Date data1 = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String date1str = simpleDateFormat.format(data1);
System.out.println("排序前的时间是=" + date1str);
radixSort(arr);
Date data2 = new Date();
String date2str = simpleDateFormat.format(data2);
System.out.println("排序后的时间是=" + date2str);
//System.out.println("基数排序后" + Arrays.toString(arr));
}
//基数排序方法
public static void radixSort(int[] arr) {
//根据前面的推导过程，我们可以得到最终的基数排序代码
//1.得到数组中最大的数的位数
int max = arr[0];//假设第一个数就是最大数
for (int i = 1;i < arr.length;i++){
if (arr[i] > max){
max = arr[i];
}
}
//得到最大数是几位数 max加上一个空串，把他变成一个字符串 非常的妙
int maxLength = (max + "").length();
//说明
/*
1.二维数组包含10个一维数组
2.为了防止在放入数的时候，数据溢出，则每一个一维数组(桶),大小定为arr.length
3.这题，基数排序是使用空间换时间的经典算法
*/
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中，实际存放了多少个数据，定义一个一维数组来记录各个桶的每次放入的数据个数
//可以这样理解：比如bucketElementCounts[0],记录的就是bucket[0] 桶的放入数据个数
int[] bucketElementCounts = new int[10];
//这里我们使用循环将代码处理
for (int i = 0, n = 1;i < maxLength;i++,n*=10){
//(针对于每个元素的对应位进行排序处理) 第一次是个位，第二次是十位
for (int j = 0;j < arr.length;j++){
//取出每个元素的对应位的值
int digitofElement = arr[j] / n % 10;
//放入对应的桶中
bucket[digitofElement][bucketElementCounts[digitofElement]]= arr[j];
bucketElementCounts[digitofElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组) 方便第二次放桶
int index = 0;
//遍历每一桶，并将桶中的数据，放入到原来的数组
for (int k = 0;k < bucketElementCounts.length;k++){
//如果桶中，有数据，我们才放到原数组
if (bucketElementCounts[k] != 0){
//循环该桶 即第k个一维数组，放入
for (int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入arr
arr[index++] = bucket[k][l];
}
}
//第i+1处理后，需要将每个bucketElementCounts[k] = 0 ！！！
bucketElementCounts[k] = 0;
}
//System.out.println("第" + (i+1) +"轮，对个位数处理arr= "+ Arrays.toString(arr));
}
/*
//第一轮(针对于每个元素的个位进行排序处理)
for (int j = 0;j < arr.length;j++){
//取出每个元素的个数
int digitofElement = arr[j] / 1 % 10;
bucket[digitofElement][bucketElementCounts[digitofElement]]= arr[j];
bucketElementCounts[digitofElement]++;
}
//按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组) 方便第二次放桶
int index = 0;
//遍历每一桶，并将桶中的数据，放入到原来的数组
for (int k = 0;k < bucketElementCounts.length;k++){
//如果桶中，有数据，我们才放到原数组
if (bucketElementCounts[k] != 0){
//循环该桶 即第k个一维数组，放入
for (int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入arr
arr[index++] = bucket[k][l];
}
}
//第一轮处理后，需要将每个bucketElementCounts[k] = 0 ！！！
bucketElementCounts[k] = 0;
}
System.out.println("第1轮，对个位数处理arr= "+ Arrays.toString(arr));
//***********************************
//第2轮 针对每个元素的个位进行排序处理
for (int j = 0;j < arr.length;j++){
//取出每个元素的个数
int digitofElement = arr[j] / 10 % 10;//举例子就明白了
bucket[digitofElement][bucketElementCounts[digitofElement]]= arr[j];
bucketElementCounts[digitofElement]++;
}
index = 0;
for (int k = 0;k < bucketElementCounts.length;k++){
//如果桶中，有数据，我们才放到原数组
if (bucketElementCounts[k] != 0){
//循环该桶 即第k个一维数组，放入
for (int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入arr
arr[index++] = bucket[k][l];
}
}
bucketElementCounts[k] = 0;
}
System.out.println("第2轮，对十位数的处理arr= " + Arrays.toString(arr));
//第3轮 针对每个元素的百位进行排序处理
for (int j = 0;j < arr.length;j++){
//取出每个元素的个数
int digitofElement = arr[j] / 100 % 10;//举例子就明白了
bucket[digitofElement][bucketElementCounts[digitofElement]]= arr[j];
bucketElementCounts[digitofElement]++;
}
index = 0;
for (int k = 0;k < bucketElementCounts.length;k++){
//如果桶中，有数据，我们才放到原数组
if (bucketElementCounts[k] != 0){
//循环该桶 即第k个一维数组，放入
for (int l = 0;l < bucketElementCounts[k];l++){
//取出元素放入arr
arr[index++] = bucket[k][l];
}
}
}
System.out.println("第3轮，对百位数的处理arr= " + Arrays.toString(arr));
*/
}
}
图片小结各类排序算法：
相关术语解释
-
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面
-
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面
-
内排序：所有排序操作都在内存中完成
-
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行
-
时间复杂度： 一个算法执行所耗费的时间
-
空间复杂度：运行完一个程序所需内存的大小
-
n: 数据规模
-
k: “桶”的个数
-
In-place: 不占用额外内存
-
Out-place: 占用额外内存
618
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
