排序算法
排序算法的介绍
概念：排序也称排序算法，排序是将一组数据，依指定的顺序进行排列的过程
排序的分类
1.内部排序：指将需要处理的所有数据都加载到内部存储器中进行排序
2.外部排序法：数据量过大，无法全部加载到内存中，需要借助外部存储（文件等）进行排序
常见的排序算法分类图
算法的时间复杂度
时间频度
基本概念：一个算法花费的时间与算法中语句的执行次数成正比，哪个算法中语句执行次数多，它花费时间就多，一个算法中的语句执行次数称为语句频度或时间频度，记为T(n)
时间复杂度
-
一般情况下，算法的基本操作语句的重复执行次数是问题规模n的某个函数，用T(n)表示，若有某个辅助函数f(n)，使得当n趋近于无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n)的同数量级函数。记作T(n)=O(f(n))，称O(f(n))为算法的渐进时间复杂度，简称时间复杂度
-
T(n)不同，但时间复杂度可能相同，如：
T ( n ) = n 2 + 7 n + 6 T(n)=n^2+7n+6 T(n)=n2+7n+6
与
T
(
n
)
=
3
n
2
+
2
n
+
2
T(n)=3n^2+2n+2
T(n)=3n2+2n+2
它们的T(n)不同，但时间复杂度相同，都为
O
(
n
2
)
O(n^2)
O(n2)
- 计算时间复杂度的方法
- 用常数1代替运行时间中的所有加法常数
- 修改后的运行次数函数中，只保留最高阶项
- 去除最高阶项的系数
常见的时间复杂度
- 常数阶
O ( 1 ) O(1) O(1)
int i = 1;
int j = 2;
++i;
j++;
int m = i + j;
- 对数阶
O ( l o g 2 n ) O(log_2n) O(log2n)
int i = 1;
while(i<n){
i = i * 2;
}
- 线性阶
O ( n ) O(n) O(n)
for(i = 1; i <= n; ++i){
j = i;
j++;
}
- 线性对数阶
O ( n l o g 2 n ) O(nlog_2n) O(nlog2n)
for(m = 1; m < n; m++){
i = 1;
while(i < n){
i = i * 2;
}
}
- 平方阶
O ( n 2 ) O(n^2) O(n2)
for(x = 1; i <= n; x++){
for(i = 1; i <= n; i++){
j = i;
j++;
}
}
//后面的立方阶和k次方阶都是依次类推，多层for循环嵌套即可
- 立方阶
O ( n 3 ) O(n^3) O(n3)
- k次方阶
O ( n k ) O(n^k) O(nk)
- 指数阶
O ( 2 n ) O(2^n) O(2n)
说明：
- 常见的算法时间复杂度由小到大依次为:
O ( 1 ) < O ( l o g 2 n ) < O ( n ) < O ( n l o g 2 n ) < O ( n 2 ) < O ( n 3 ) < O ( n k ) < O ( 2 n ) O(1)<O(log_2n)<O(n)<O(nlog_2n)<O(n^2)<O(n^3)<O(n^k)<O(2^n) O(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)<O(n3)<O(nk)<O(2n)
，随着问题规模n的不断增大，上述时间复杂度不断增大，算法的执行效率越低
- 我们应该尽量避免使用指数阶的算法
平均时间复杂度和最坏时间复杂度
- 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间
- 最坏情况下的时间复杂度称为最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长
- 平均时间复杂度和最坏时间复杂度是否一致和算法有关
算法的空间复杂度简介
基本概念：
- 类似时间复杂度的讨论，一个算法的空间复杂度定义为该算法所耗费的存储空间，它也是问题规模n的函数
- 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当n较大时，将占用较多的存储单元，例如快速排序和归并排序算法就属于这种情况
- 在做算法分析时，主要讨论的是时间复杂度。从用户的使用体验上来看的话，更看重的是程序执行的速度。一些缓存产品(redis,memcache)和算法(基数排序)本质就是用空间去换时间
冒泡排序
基本概念：
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒
因为排序的过程中，各个元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序，因此要在排序过程中设置一个标志flag判断元素是否进行过交换，从而减少不必要的比较
排序例子：
原始数据：3,2,-1,10,20
第一趟排序：
2,3,-1,10,20 （如果相邻的元素逆序就交换）
2,-1,3,10,20
2,-1,3,10,20
2,-1,3,10,20（第一轮排序决定了最大的数是20）
第二趟排序：
-1,2,3,10,20
-1,2,3,10,20
-1,2,3,10,20
第三趟排序：
-1,2,3,10,20
-1,2,3,10,20
第四趟排序：
-1,2,3,10,20
结论冒泡排序的规则：
- 一共进行数组的大小-1次大的循环
- 每一趟排序的次数在逐渐的减少
- 如果我们发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序，这个就是优化
冒泡排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 冒泡排序的算法
* 初始数组为{3, 9, -1, 10, -2}
*
* @author 87682
*/
public class BubbleSort {
public static void main(String[] args) {
int[] arr = {3, 9, -1, 10, -2};
// //为了容易理解，我们将冒泡排序的演变过程展示出来
// //第一趟排序，就是将最大的数排在最后
// //temp为临时变量
// int temp = 0;
// for(int j = 0; j < arr.length - 1 - 0; 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 - 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));
//测试冒泡排序
System.out.println("排序前");
System.out.println(Arrays.toString(arr));
bubbleSort(arr);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
}
/**
* 将前面的冒泡排序算法封装成一个方法
*/
private static void bubbleSort(int[] arr) {
//由此可以看出来冒泡排序的时间复杂度为O(n^2)
//定义一个临时变量
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，进行下次判断
flag = false;
}
}
}
}
选择排序
基本概念：
选择式排序也属于内部排序法，是从欲排序的数据中，按指定的规则选出来某一元素，再依次规定交换位置后达到排序的目的
排序例子：
原始数据：100,34,118,2
第一轮排序：2,34,118,100
第二轮排序：2,34,118,100
第三轮排序：2,34,100,118
说明：
-
选择排序一共有数组大小-1轮排序
-
每一轮排序，又是一个循环，循环的规则（代码）
2.1 先假定当前这个数是最小的数
2.2 然后和后面的每个数进行比较，如果发现有比当前数更小的数，就重新确定最小数，并得到下标
2.3 当遍历到数组的最后时，就得到了本轮最小数和下标
2.4 交换
选择排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 选择排序的算法，时间比冒泡排序短
* 初始数组为{101, 34, 119, 1}
*
* @author 87682
*/
public class SelectSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
System.out.println("原始数组");
System.out.println(Arrays.toString(arr));
selectSort(arr);
System.out.println("排序后");
System.out.println(Arrays.toString(arr));
}
/**
* 选择排序
*/
private static void selectSort(int[] 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
// min = arr[j];
// //重置minIndex
// minIndex = j;
// }
// }
// //将最小值放在arr[0]的位置，即交换
// if (minIndex != 0){
// arr[minIndex] = arr[0];
// arr[0] = min;
// }
// System.out.println("第一轮后");
// System.out.println(Arrays.toString(arr));
//
// //原始的数组：101, 34, 119, 1
// //第二轮排序：1, 34, 119, 101
// //第二轮
// minIndex = 1;
// min = arr[1];
// for (int j = 1 + 1; j < arr.length; j++){
// if (min > arr[j]){
// //说明假定的最小值并不是最小的
// //重置min
// min = arr[j];
// //重置minIndex
// minIndex = j;
// }
// }
// //将最小值放在arr[1]的位置，即交换
// if (minIndex != 1){
// arr[minIndex] = arr[1];
// arr[1] = min;
// }
// System.out.println("第二轮后");
// System.out.println(Arrays.toString(arr));
//
// //原始的数组：101, 34, 119, 1
// //第三轮排序：1, 34, 101, 119
// //第三轮
// minIndex = 2;
// min = arr[2];
// for (int j = 2 + 1; j < arr.length; j++){
// if (min > arr[j]){
// //说明假定的最小值并不是最小的
// //重置min
// min = arr[j];
// //重置minIndex
// minIndex = j;
// }
// }
// //将最小值放在arr[1]的位置，即交换
// if (minIndex != 2){
// arr[minIndex] = arr[2];
// arr[2] = min;
// }
// System.out.println("第三轮后");
// System.out.println(Arrays.toString(arr));
//在推导的过程中，我们发现了规律，因此可以使用一个循环来解决问题
//选择排序的时间复杂度也是O(n^2)
for (int i = 0; i < arr.length; i++) {
int minIndex = i;
int min = arr[i];
for (int j = i + 1; j < arr.length; j++) {
if (min > arr[j]) {
//说明假定的最小值并不是最小的
//重置min
min = arr[j];
//重置minIndex
minIndex = j;
}
}
//将最小值放在arr[0]的位置，即交换
if (minIndex != i) {
arr[minIndex] = arr[i];
arr[i] = min;
}
// System.out.println("第" + (i + 1) + "轮后");
// System.out.println(Arrays.toString(arr));
}
}
}
插入排序
插入排序基本概念：
插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的
插入排序法思想：
插入排序的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表
排序例子：
原始数据：100,34,118,2
第一轮排序：34,100,118,2
第二轮排序：34,100,118,2
第三轮排序：2,34,100,118
插入排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 插入排序的算法
* 初始数组为{101, 34, 119, 1}
*
* @author 87682
*/
public class InsertSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
insertSort(arr);
}
/**
* 插入排序
*/
private static void insertSort(int[] arr) {
// //使用逐步推导的方式来讲解，便于理解
// //第一轮{101, 34, 119, 1} => {34, 101, 119, 1}
// //定义待插入的数
// int insertVal = arr[1];
// //即arr[1]的前面这个数的下标
// int insertIndex = 1 - 1;
//
// //给insertVal找到一个插入的位置
// //说明
// //1. insertIndex >= 0 保证在给insertVal找插入位置时，不越界
// //2. insertVal < arr[insertIndex] 待插入的数还没有找到适当的插入位置
// //3. 就需要将arr[insertIndex]后移
// while (insertIndex >= 0 && insertVal < arr[insertIndex]){
// //{101, 34, 119, 1} => {101, 101, 119, 1}
// arr[insertIndex + 1] = arr[insertIndex];
// insertIndex--;
// }
// //当退出while循环时，说明插入的位置找到，insertIndex + 1
// arr[insertIndex + 1] = insertVal;
//
// System.out.println("第一轮插入后");
// System.out.println(Arrays.toString(arr));
//
// //第二轮
// insertVal = arr[2];
// insertIndex = 2 - 1;
// while (insertIndex >= 0 && insertVal < arr[insertIndex]){
// arr[insertIndex + 1] = arr[insertIndex];
// insertIndex--;
// }
// //当退出while循环时，说明插入的位置找到，insertIndex + 1
// arr[insertIndex + 1] = insertVal;
//
// System.out.println("第二轮插入后");
// System.out.println(Arrays.toString(arr));
//
// //第三轮
// insertVal = arr[3];
// insertIndex = 3 - 1;
// while (insertIndex >= 0 && insertVal < arr[insertIndex]){
// arr[insertIndex + 1] = arr[insertIndex];
// insertIndex--;
// }
// //当退出while循环时，说明插入的位置找到，insertIndex + 1
// arr[insertIndex + 1] = insertVal;
//
// System.out.println("第三轮插入后");
// System.out.println(Arrays.toString(arr));
//使用for循环把代码简化
int insertVal = 0;
int insertIndex = 0;
for (int i = 1; i < arr.length; i++) {
//定义待插入的数
insertVal = arr[i];
//即arr[1]的前面这个数的下标
insertIndex = i - 1;
//给insertVal找到一个插入的位置
//说明
//1. insertIndex >= 0 保证在给insertVal找插入位置时，不越界
//2. insertVal < arr[insertIndex] 待插入的数还没有找到适当的插入位置
//3. 就需要将arr[insertIndex]后移
while (insertIndex >= 0 && insertVal < arr[insertIndex]) {
//{101, 34, 119, 1} => {101, 101, 119, 1}
arr[insertIndex + 1] = arr[insertIndex];
insertIndex--;
}
//当退出while循环时，说明插入的位置找到，insertIndex + 1为原先的后移前数据的位置，把需要插入的数据赋值给它
//这里判断我们是否需要赋值
if (insertIndex + 1 != i) {
arr[insertIndex + 1] = insertVal;
}
System.out.println("第" + i + "轮插入后");
System.out.println(Arrays.toString(arr));
}
}
}
希尔排序
希尔排序法的概念：
希尔排序是希尔于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序
希尔排序法基本思想：
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件给分成一组，算法便终止
希尔排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 希尔排序的算法
* 初始数组为{8, 9, 1, 7, 2, 3, 5, 4, 6, 0}
*
* @author 87682
*/
public class ShellSort {
public static void main(String[] args) {
int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
System.out.println("希尔排序前");
System.out.println(Arrays.toString(arr));
shellSortBetter(arr);
System.out.println("希尔排序后");
System.out.println(Arrays.toString(arr));
}
/**
* 使用逐步推导的方式来编写希尔排序（交换式的）
*/
private static void shellSort(int[] arr) {
// //希尔排序的第一轮排序
// //因为第一轮排序，是将10个数据分成了5组
// //定义一个临时变量
// int temp = 0;
// 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++) {
// //遍历各组中所有的元素（共有5组，每组有2个元素），步长是5
// 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++) {
// //遍历各组中所有的元素（共有5组，每组有2个元素），步长是5
// 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));
//根据前面的逐步分析，我们使用循环处理
int temp = 0;
//定义一个计数器
int count = 0;
for (int gap = arr.length / 2; gap > 0; gap /= 2) {
for (int i = gap; i < arr.length; i++) {
//遍历各组中所有的元素（共有gap组），步长是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));
}
}
/**
* 对交换式的希尔排序进行优化->移位法
*/
private static void shellSortBetter(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[j];
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;
}
}
}
}
}
快速排序
快速排序法概念：
快速排序是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
快速排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 快速排序的算法
* 初始数组为{-9, 78, 0, 23, -567, 70}
*
* @author 87682
*/
public class QuickSort {
public static void main(String[] args) {
int[] arr = {-9, 78, 0, 23, -567, 70};
quickSort(arr, 0, arr.length - 1);
System.out.println("arr=" + Arrays.toString(arr));
}
private 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的值，这个时候让arr[r]向前移动
if (arr[l] == pivot) {
r -= 1;
}
//如果交换完后发现arr[r]的值等于pivot的值，这个时候让arr[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);
}
}
}
归并排序
归并排序概念：
归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的答案“修补”在一起，即分而治之）
归并排序的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 归并排序的算法
* 初始数组为{8, 4, 5, 7, 1, 3, 6, 2}
*
* @author 87682
*/
public class MergeSort {
public static void main(String[] args) {
int[] arr = {8, 4, 5, 7, 1, 3, 6, 2};
//说明归并排序需要一个额外的空间开销
int[] temp = new int[arr.length];
mergeSort(arr, 0, arr.length - 1, temp);
System.out.println("归并排序后=" + Arrays.toString(arr));
}
/**
* 分 + 合方法
*
* @param arr 需要排序的原始数组
* @param left 最左边的索引
* @param right 最右边的索引
* @param temp 做中转的数组
*/
private 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 做中转的数组
*/
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
//初始化i，表示左边有序序列的初始索引
int i = left;
//初始化j，表示右边有序序列的初始索引
int j = mid + 1;
//t是指向temp数组的当前索引
int t = 0;
//第一步：
//先把左右两边的数据按照规则填充到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;
while (tempLeft <= right) {
//第一次合并时tempLeft = 0，right = 1
//第二次合并时tempLeft = 2，right = 3
//第三次合并时tempLeft = 0，right = 3
//...最后一次才是tempLeft = 0，right = 7
arr[tempLeft] = temp[t];
t += 1;
tempLeft += 1;
}
}
}
基数排序
基数排序（桶排序）概念：
- 基数排序属于“分配式排序”，又称“桶子法”或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
- 基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法
- 基数排序是桶排序的扩展
- 基数排序是1887年赫尔曼.何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较
基数排序的基本思想：
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列
基数排序的操作原理图解：
基数排序（桶排序）的Java实现代码：
package sort;
import java.util.Arrays;
/**
* 基数排序的算法
* 初始数组为{53, 3, 542, 748, 14, 214}
*
* @author 87682
*/
public class RadixSort {
public static void main(String[] args) {
int[] arr = {53, 3, 542, 748, 14, 214};
radixSort(arr);
}
private static void radixSort(int[] arr) {
//定义一个二维数组表示十个桶，每个桶就是一个一维数组
//说明：
//1.二维数组包含了十个一维数组
//2.为了防止在放入数的时候，数据溢出，则每个一维数组（桶）大小定位arr.length
//3.很明确，基数排序是使用空间换时间的一个经典算法
int[][] bucket = new int[10][arr.length];
//为了记录每个桶中实际存放了多少个数据，我们定义一个一维数组来记录各个桶每次放入的数据个数
//bucketElementCounts[0]记录的就是bucket[0]桶的放入数据的个数，其他的依此类推
int[] bucketElementCounts = new int[10];
// //第一轮针对每个元素的个位进行排序处理
// 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个桶（即第k个一维数组）
// for (int l = 0; l < bucketElementCounts[k]; l++){
// //取出元素放入到arr中
// arr[index] = bucket[k][l];
// index++;
// }
// }
// //第一轮处理后，需要将每个bucketElementCounts[k]置0
// bucketElementCounts[k] = 0;
// }
// System.out.println("第一轮对个位的排序处理arr=" + Arrays.toString(arr));
//
// //=================================================================
//
// //第二轮针对每个元素的十位进行排序处理
// 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个桶（即第k个一维数组）
// for (int l = 0; l < bucketElementCounts[k]; l++){
// //取出元素放入到arr中
// arr[index] = bucket[k][l];
// index++;
// }
// }
// //第二轮处理后，需要将每个bucketElementCounts[k]置0
// bucketElementCounts[k] = 0;
// }
// System.out.println("第二轮对个位的排序处理arr=" + Arrays.toString(arr));
//
//
// //=================================================================
//
// //第三轮针对每个元素的百位进行排序处理
// 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个桶（即第k个一维数组）
// for (int l = 0; l < bucketElementCounts[k]; l++){
// //取出元素放入到arr中
// arr[index] = bucket[k][l];
// index++;
// }
// }
// //第三轮处理后，需要将每个bucketElementCounts[k]置0
// bucketElementCounts[k] = 0;
// }
// System.out.println("第三轮对个位的排序处理arr=" + Arrays.toString(arr));
//根据前面的推导过程，我们可以得到最终的基数排序代码
//1.得到数组中最大数的位数
//假设第一个数就是最大数
int max = arr[0];
for (int i = 1; i < arr.length; i++) {
if (arr[i] > max) {
max = arr[i];
}
}
//得到最大数的位数
int maxLength = (max + "").length();
//这里我们使用循环将代码处理一下
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个桶（即第k个一维数组）
for (int l = 0; l < bucketElementCounts[k]; l++) {
//取出元素放入到arr中
arr[index] = bucket[k][l];
index++;
}
}
//第i+1轮处理后，需要将每个bucketElementCounts[k]置0
bucketElementCounts[k] = 0;
}
System.out.println("第" + (i + 1) + "轮对个位的排序处理arr=" + Arrays.toString(arr));
}
}
}
基数排序的一些注意点：
- 基数排序是对传统桶排序的扩展，速度很快
- 基数排序是经典的空间换时间的方式，占用内存很大，当对海量数据排序时，容易造成OutOfMemoryError（堆内存溢出）
- 基数排序是稳定的。（注：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的，否则称为不稳定的）
- 有负数的数组，我们不用基数排序进行进行排序，防止数组越界情况，如果硬要处理负数可以在负数情况下取绝对值进行处理
常用排序算法的对比
| 排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 排序方式 | 稳定性 |
|---|---|---|---|---|---|---|
| 冒泡排序 | O(n^2) | O(n) | O(n^2) | O(1) | In-place | 稳定 |
| 选择排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | In-place | 不稳定 |
| 插入排序 | O(n^2) | O(n^2) | O(n^2) | O(1) | In-place | 稳定 |
| 希尔排序 | O(nlogn) | O(nlog_2n) | O(nlog_2n) | O(1) | In-place | 不稳定 |
| 归并排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(n) | Out-place | 稳定 |
| 快速排序 | O(nlogn) | O(nlogn) | O(n^2) | O(logn) | In-place | 不稳定 |
| 堆排序 | O(nlogn) | O(nlogn) | O(nlogn) | O(1) | In-place | 不稳定 |
| 计数排序 | O(n+k) | O(n+k) | O(n+k) | O(k) | Out-place | 稳定 |
| 桶排序 | O(n+k) | O(n+k) | O(n^2) | O(n+k) | Out-place | 稳定 |
| 基数排序 | O(n*k) | O(n*k) | O(n*k) | O(n+k) | Out-place | 稳定 |
注：由于桶排序、计数排序和基数排序十分相似，所以不再多述，而堆排序涉及二叉树部分，所以也先不研究，每一种排序都有很多值得思考的思想，不论刷什么算法题，很多思想可以套用，比如递归，分治这种思想就十分可贵，需要花大量时间取琢磨，包括每个算法的效率也可以去造海量数据进行测试，不同算法应用场景不同，在学了这么多框架知识之后，回过头再加深一下算法知识，也是为了以后有更大的提升空间。
432
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
