排序
排序也称排序算法 （ Algorithm）排序是将一组数据，依指定的顺序进行排列的过程。
排序的分类
内部排序：指将需要处理的所有数据都加载到内存中进行排序。
外部排序：无法全部加载到内存中，需要借助外部存储（文件等）进行排序。
时间复杂度
度量一个程序执行时间的两种方法
事后统计的方法
这种方法可行，但有两个问题：
- 要想对设计的算法运行性能进行评测，需要实际运行程序；
- 所得时间的统计量依赖于计算机的硬件、软件等环境因素，
这种方式，要在同一台计算机的相同状态下运行，才能比较那个算法速度更快
事前估算的方法
通过分析某个算法的时间复杂度来判断那个算法更优
- 时间频度
时间频度：一个算法花费时间与算法中语句的执行次数成正比，那个算法中语句执行次数多，它花费时间就多。**一个算法中的语句执行次数称为语句频度或时间频度。**记为T(n)
比如计算1-100所有数字之和，我们设计两种算法：
//方案1 for循环
int total = 0;
int end = 100;
for (int i = 0; i <=end ; i++) {
total+=i;
}
//T(n) = n+1;
//方案2 直接计算
total = (1+end)*end/2
//T(n) = 1;
忽略常数项
结论：
1 2n+20 和 2n随着n变大，执行曲线无线接近，20可以忽略
2 3n+10 和 3n随着n变大，执行曲线无线接近，10可以忽略
忽略低次项（3次方及以上不能忽略）
结论：
- 2n2+3n+10 和 2n2随着n变大，执行曲线无限接近，可以忽略3n+10
- n2+5n+20和n2随着n变大，执行曲线无限接近，可以忽略5n+20
忽略系数
结论：
1 随这n值变大，5n2+7n 和 3n2+2n，执行曲线重合，说明这种情况下，5和3可以忽略
2 而n3+5n 和 6n3+4n，执行曲线分离，说明多少次方是关键
- 时间复杂度
1 一般情况下，算法中的基本操作语句的成分执行次数是问题规模n的某个函数，用T(n)表示，若某个辅助函数f(n),使得当n趋近无穷大时，T(n)/f(n)的极限值为不等于零的常数，则称f(n)是T(n）的同数量级函数。记作T(n)=O (f(n)),称O (f(n)) 为算法的渐进时间复杂度，简称时间复杂度。
2 T(n)不同，但时间复杂度可能相同。如T(n)=n2+7n+6与 T(n)=3n2+2n+2他们的T(n）不同，但是时间复杂度相同都为 O(n2))
3 计算时间复杂度的方法：
- 用常数1代替运行时间中的所有加法常数 T(n)=n2+7n+6 =>T(n)=n2+7n+1
- 修改后的运行次数函数中，只保留最高阶项 T(n)=n2+7n+1=>T(n)=n2
- 去除最高阶项的系数 T(n)=n2=>O(n2)
常见的时间复杂度
常数阶O(1)
对数阶O(log2n)
线性阶O(n)
线性对数阶O(nlog2n)
平方阶O(n2)
立方阶O(n3)
K方阶O(nk)
指方阶O(2n)
说明 ：
常见的算法时间复杂度由小到大排序 ： O(1)<O(log2n)<O(n)<O(nlog2n)<O(n2)<O(n3)<O(nk)<O(2n)
因此我们应尽可能避免指数阶的算法
常数阶O(1)
无论代码执行了多少行，只要是没有循环等复杂结构，那么这个代码时间复杂度就是O(1)
int i = 1;
int j = 2;
++i;
j++;
int m =i+j;
上述代码在执行的时候，它消耗的时间并不随着某个变量的增加而增加，那么无论这类代码有多长，即使有几万几十万行，都可以用O(1)来表示它的时间复杂度
** 对数阶O(log2n) **
int i = 1;
while(i<n){
i = i*2;
}
说明：在while循环里面，每次都将i乘以2，乘完之后，i距离n就越来越近了。假设循环x次之后，i就大于n了，此时这个循环就退出了，也就是说2的x次方等于n，那么x=log2n也就是说当循环log2n次以后，这个代码就结束了。因此这个代码的时间复杂度为O(log2n)。O(log2n)的这个2时间上是根据代码变化的，i=i*3，则是O(log3n)。
线性阶O(n)
for (int i = 1; i <=n ; i++) {
j=i;
j++;
}
说明:for循环里面的代码会执行n遍，因此它消耗的时间是随着n的变化而变化的，因此这类代码都可以用O(n)来表示它的时间复杂度
线性对数阶O(nlog2n)
for (int m = 1; m < n ; m++) {
i = 1;
while (i<n){
i = i+2;
}
}
说明：线性对数阶O(nlogN)其实非常容易理解，将时间复杂度为线性对数阶O(nlogN)代码循环N次的话，复杂度就是 n*O(logN)，也就是线性对数阶O(nlogN)
** 平方阶O(n2) **
for (int x = 1; x <= n ; x++) {
for (int i = 1; i <=n ; i++) {
j=i;
j++;
}
}
说明：如果把O(n)的代码再嵌套循环一次，他的时间复杂度就是O(n2),这段代码其实就是嵌套了2层n循环，它的时间复杂度就是O(n*n）
立方阶O(n3) 、K方阶O(nk)
说明：参考上面的O(n2)去理解就好了，O(n3)相当于三层n循环，其他的类似
平均时间复杂度和最坏时间复杂度
1 平均时间复杂度是指所有可能的输入实例均以等概率出现的情况下，该算法的运行时间。
2 最坏情况下的时间复杂度称最坏时间复杂度。一般讨论的时间复杂度均是最坏情况下的时间复杂度。这样做的原因是：最坏情况下的时间复杂度是算法在任何输入实例上运行时间的界限，这就保证了算法的运行时间不会比最坏情况更长。
3 平均时间复杂度和最坏时间复杂度是否一致，和算法有关：
- 空间复杂度
算法的空间复杂度介绍
- 类似于时间复杂度的讨论，一个算法的空间复杂度（Space Comolexity）定义为该算法所耗费的存储空间，它也是问题规模n的函数。
- 空间复杂度（Space Comolexity）是对一个算法在运行过程中临时占用存储空间大小的量度。有的算法需要占用的临时工作单元数与解决问题的规模n有关，它随着n的增大而增大，当较大时，将占用较多的存储单元，列如：快速排序和归并排序算法，基数排序就属于这种情况
- 在做算法分析时，主要讨论的是时间复杂度。从用户体验上看，更看重的是程序执行的速度。一些缓存产品（redis,memcache）和算法（基数排序）本质就是用空间换时间。
冒泡排序
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始），依次比较相邻元素的值，若发现逆序则交换，使较大的元素逐渐从前移到后部，就像水底的气泡一样逐渐向上冒。
优化：
因为排序的过程中，各元素不断接近自己的位置， 如果一趟比较下来没有进行过交换 ， 就说明序列有序，因此要在排序过程中设置一个标志 flag 判断元素是否进行过交换。从而减少不必要的比较。(这里说的优化，可以在冒泡排序写好后，在进行)
图解冒泡排序
小结 ：
- 一共进行 数组大小-1 大的循环
- 每趟排序的次数都在逐步的减少
- 如果我们发现在某趟排序中，没有发生一次交换，可以提前结束冒泡排序，这个算优化
代码实现
时间复杂度O（n2）
public class BubbleSort {
public static void main(String[] args) {
int arr[] = {-1, 3, 9, 10, -2};
// 1 按照步骤拆解冒泡排序
//bubbleSortStep(arr);
// 2 常规冒泡排序
//bubbleSort(arr);
// 3 优化后的冒泡排序
bubbleSortBetter(arr);
}
/**
* 当没有进行交换时 说明顺序是正确的 就会跳出循环
*
* 原始数组： [-1, 3, 9, 10, -2]
* 第1轮排序结果：[-1, 3, 9, -2, 10]
* 第2轮排序结果：[-1, 3, -2, 9, 10]
* 第3轮排序结果：[-1, -2, 3, 9, 10]
* 第4轮排序结果：[-2, -1, 3, 9, 10]
* 排序后结果：[-2, -1, 3, 9, 10]
* @param arr
*/
public static void bubbleSortBetter(int[] arr){
System.out.println("原始数组： "+Arrays.toString(arr));
for (int i = 0; i < arr.length-1; i++) {
boolean flag = false;
int temp = 0;
for(int j = 0;j<arr.length-1 - i;j++ ){
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
flag = true;
}
}
System.out.println("第"+(i+1)+"轮排序结果："+Arrays.toString(arr));
if(!flag){
break;
}
}
System.out.println("排序后结果："+Arrays.toString(arr));
}
/**
* 原始数组： [-1, 3, 9, 10, -2]
* 第1轮排序结果：[-1, 3, 9, -2, 10]
* 第2轮排序结果：[-1, 3, -2, 9, 10]
* 第3轮排序结果：[-1, -2, 3, 9, 10]
* 第4轮排序结果：[-2, -1, 3, 9, 10]
* 排序后结果：[-2, -1, 3, 9, 10]
* @param arr
*/
public static void bubbleSort(int[] arr){
System.out.println("原始数组： "+Arrays.toString(arr));
for (int i = 0; i < arr.length-1; i++) {
int temp = 0;
for(int j = 0;j<arr.length-1 - i;j++ ){
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
//System.out.println("第"+(i+1)+"轮排序结果："+Arrays.toString(arr));
}
System.out.println("排序后结果："+Arrays.toString(arr));
}
/**
* 原始数组： [-1, 3, 9, 10, -2]
* 第一轮排序结果：[-1, 3, 9, -2, 10]
* 第二轮排序结果：[-1, 3, -2, 9, 10]
* 第三轮排序结果：[-1, -2, 3, 9, 10]
* 第四轮排序结果：[-2, -1, 3, 9, 10]
* @param arr
*/
public static void bubbleSortStep(int[] arr){
System.out.println("原始数组： "+Arrays.toString(arr));
int temp = 0;
for(int j = 0;j<arr.length-1;j++ ){
if(arr[j]>arr[j+1]){
temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
System.out.println("第一轮排序结果："+Arrays.toString(arr));
temp = 0;
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("第二轮排序结果："+Arrays.toString(arr));
temp = 0;
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("第三轮排序结果："+Arrays.toString(arr));
temp = 0;
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("第四轮排序结果："+Arrays.toString(arr));
}
}
选择排序
选择排序也是一种简单的内部排序方法，他基本的思想是：第一次从arr[1]-arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[2]-arr[n-1]选择最小值与arr[1]交换…第i次从arr[i]-arr[n-1]中选择最小值与arr[i-1]交换…第n-1次 比较 arr[n-1]与arr[n-2]是否需要交换，总共进行n-1次，得到一个从小到大的有序序列。
图解选择排序
小结：
- 选择排序一共有 数组大小-1 轮循环
- 每1轮排序，又是一个循环，循环规则
1 先假定当前这个数是最小数
2 然后和后面的每个数进行比较，如果发现有比当前更小的数就重新确定最小数，并得到下标
3 当遍历到数组的最后时，就得到本轮最小的数和下标
4 交换
代码实现
时间复杂度 O(n2)
public class SelectSort {
public static void main(String[] args) {
int[] arr = {101, 34, 119, 1};
System.out.println("原始数组："+ Arrays.toString(arr));
//1 选择排序步骤拆解
//selectSortStep(arr);
//2 常规选择排序
selectSort(arr);
}
/**
* 原始数组：[101, 34, 119, 1]
* 第1轮排序结果：[1, 34, 119, 101]
* 第2轮排序结果：[1, 34, 119, 101]
* 第3轮排序结果：[1, 34, 101, 119]
* @param arr
*/
private static void selectSort(int[] arr) {
for (int i = 0; i < arr.length-1; i++) {
int minIndex = i;
int min = arr[minIndex];
for (int j = i+1; j < arr.length; j++) {
if(min>arr[j]){
minIndex = j;
min = arr[j];
}
}
if(minIndex!=i){//判断如果相同 说明假设大小正常 就不用交换
int temp = arr[i];
arr[i] = min;
arr[minIndex] = temp;
}
System.out.println("第"+(i+1)+"轮排序结果："+ Arrays.toString(arr));
}
}
/**
* 原始数组：[101, 34, 119, 1]
* 第一轮排序结果：[1, 34, 119, 101]
* 第二轮排序结果：[1, 34, 119, 101]
* 第三轮排序结果：[1, 34, 101, 119]
* @param arr
*/
private static void selectSortStep(int[] arr) {
int minIndex = 0;
int min = arr[minIndex];
for (int j = 1; j < arr.length; j++) {
if(min>arr[j]){
minIndex = j;
min = arr[j];
}
}
//交换最小值
int temp = arr[0];
arr[0] = arr[minIndex];
arr[minIndex] = temp;
System.out.println("第一轮排序结果："+ Arrays.toString(arr));
minIndex = 1;
min = arr[minIndex];
for (int j = 2; j < arr.length; j++) {
if(min>arr[j]){
minIndex = j;
min = arr[j];
}
}
temp = arr[1];
arr[1] = arr[minIndex];
arr[minIndex] = temp;
System.out.println("第二轮排序结果："+ Arrays.toString(arr));
minIndex = 2;
min = arr[minIndex];
for (int j = 3; j < arr.length; j++) {
if(min>arr[j]){
minIndex = j;
min = arr[j];
}
}
temp = arr[2];
arr[2] = arr[minIndex];
arr[minIndex] = temp;
System.out.println("第三轮排序结果："+ Arrays.toString(arr));
}
}
插入排序
插入排序属于内部排序，是对于排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的；
插入排序基本思想：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含n-1个元素，排序过程中每次从无序表中取出一个元素，把它的排序码依次与有序元素的排序码进行比较，将他插入到有序表中的适当位置，使其成为新的有序表。
图解插入排序
小结：
- 将前面arr[0]看成有序数组 后面arr[1]~arr[3]看着无序
- 将arr[1]与前面有序数组对比，放到对应的位置（第一次比较只需比较一次 arr[1]=34<arr[0]=101, 需要将arr[0]往后移，并将arr[1]往前移动），此时有序数组为 arr[0]= 34 arr[1]=101;
- 重复上述步骤，直到 数组长度 （将arr[2]=119>arr[1]=101,不需要移位，此时有序数组为 arr[0]= 34 arr[1]=101 arr[2] =119…）最终得到新数组
代码实现
时间复杂度O(n2)
public class InsertSort {
public static void main(String[] args) {
int arr[] = {101,34,119,1};
//分步演练
//insertSortStep(arr);
//常规插入排序
insertSort(arr);
}
/**
* 信息打印
* 第1轮：[34, 101, 119, 1]
* 第2轮：[34, 101, 119, 1]
* 第3轮：[1, 34, 101, 119]
*/
public static void insertSort(int arr[]){
// i 从1开始 arr.length不用减一
for (int i = 1; i < arr.length; i++) {
// 先指定一个待插入的数 无序列表第一个 第一次从arr[1]开始
int insertVal = arr[i];
// 有序列表最后一个开始
int insertIndex = i-1;
/**
* 寻找插入的位置
* insertIndex>=0 保证数组下标不越界
* insertVal < arr[insertIndex] 待插入的值 < 有序列当前的值 说明没有找到位置 insertIndex 前移
*/
while(insertIndex>=0 && insertVal < arr[insertIndex]){
arr[insertIndex+1] = arr[insertIndex];//待插入的值=待插入前一位的值 往后移动一个下标 101 101 119 1
insertIndex--; //insertIndex 前移
}
//退出循环表示找到位置为 insertIndex+1（因为insertIndex 初始化的时候是待插入的前一个数 （在循环内多减1拿去比较前一位数））
arr[insertIndex+1] = insertVal;
System.out.println("第"+i+"轮："+ Arrays.toString(arr));
}
}
/**
* 信息打印
* 第一轮：[34, 101, 119, 1]
* 第二轮：[34, 101, 119, 1]
* 第三轮：[1, 34, 101, 119]
*/
public static void insertSortStep(int arr[]){
// 先指定一个待插入的数 无序列表第一个 第一次从arr[1]开始
int insertVal = arr[1];
// 有序列表最后一个开始
int insertIndex = 1-1;
/**
* 寻找插入的位置
* insertIndex>=0 保证数组下标不越界
* insertVal < arr[insertIndex] 待插入的值 < 有序列当前的值 说明没有找到位置 insertIndex 前移
*/
while(insertIndex>=0 && insertVal < arr[insertIndex]){
arr[insertIndex+1] = arr[insertIndex];//待插入的值=待插入前一位的值 往后移动一个下标 101 101 119 1
insertIndex--; //insertIndex 前移
}
//退出循环表示找到位置为 insertIndex+1（因为insertIndex 初始化的时候是待插入的前一个数 （在循环内多减1拿去比较前一位数））
arr[insertIndex+1] = insertVal;
System.out.println("第一轮："+ Arrays.toString(arr));
insertVal = arr[2];
insertIndex = 2-1;
while(insertIndex>=0&&insertVal<arr[insertIndex]){
arr[insertIndex+1] = arr[insertIndex];
insertIndex--;
}
arr[insertIndex+1] = insertVal;
System.out.println("第二轮："+ Arrays.toString(arr));
insertVal = arr[3];
insertIndex = 3-1;
while(insertIndex>=0&&insertVal<arr[insertIndex]){
//第一次循环 34 101 119 119 第二次循环 34 101 101 119 第三次循环 34 34 101 119 第四次跳出循环 此时inertIndex = -1
arr[insertIndex+1] = arr[insertIndex];
insertIndex--;
}
arr[insertIndex+1] = insertVal;
System.out.println("第三轮："+ Arrays.toString(arr));
}
}
希尔排序
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个高效的版本，也称缩小增量排序。
希尔排序的基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减到1时，整个文件恰好被分成一组，算法便终止
图解希尔算法
代码实现（交换元素）
效率并不是很高
public class ShellSortExchange {
public static void main(String[] args) {
int arr[] = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
//分步演示过程
//shellSortStep(arr);
/**
* 信息打印
* 希尔算法第一轮排序：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
* 希尔算法第二轮排序：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
* 希尔算法第二轮排序：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
*/
//常规希尔排序
shellSort(arr);
/**
* 信息打印
* 希尔算法第1轮排序：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
* 希尔算法第2轮排序：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
* 希尔算法第3轮排序：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
* 希尔算法排序结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
*/
}
public static void shellSort(int[] arr) {
int temp = 0;
int gap = arr.length/2;
int count = 1;
while(gap!=0){
for (int i = gap; i <arr.length ; 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;
}
}
}
gap/=2;
System.out.println("希尔算法第"+(count++)+"轮排序："+ Arrays.toString(arr));
}
System.out.println("希尔算法排序结果："+ Arrays.toString(arr));
}
public static void shellSortStep(int[] arr) {
// 第一轮排序 步长增量 => 10/2 =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));
//第二轮排序 步长增量 => 5/2 =2
for (int i = 2; i < arr.length ; i++) {
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));
//第三轮排序 步长增量 => 2/2 =1
for (int i = 1; i < arr.length ; i++) {
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));
}
}
代码实现（移动元素）
移动法没有交换 效率更高
/**
* 希尔移位方式第0轮：[3, 5, 1, 6, 0, 8, 9, 4, 7, 2]
* 希尔移位方式第1轮：[0, 2, 1, 4, 3, 5, 7, 6, 9, 8]
* 希尔移位方式第2轮：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
* 希尔移位方式排序结果：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
* @param arr
*/
private static void shellSortBetter(int[] arr) {
int count = 0;
// 获取增量gap 并逐步缩小
for (int gap = arr.length/2 ; gap>0 ; gap/=2) {
//从第gap个元素，逐个对其在的组进行直接插入排序
for (int i = gap; i < arr.length ; i++) {
//待插入的元素
int insertVal = arr[i];
// 有序列表最后一个开始
int insertIndex = i-gap;
while(insertIndex>=0 && insertVal<arr[insertIndex]){
arr[insertIndex+gap] = arr[insertIndex];
insertIndex-=gap;
}
arr[insertIndex+gap]= insertVal;
}
System.out.println("希尔移位方式第"+(count++)+"轮："+Arrays.toString(arr));
}
System.out.println("希尔移位方式排序结果："+Arrays.toString(arr));
}
快速排序
快速排序是对冒泡排序的一种改进，基本思路是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另一部分的所有数据要小，然后再按此法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列
代码实现
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(Arrays.toString(arr));
}
/**
* 打印信息 [-567, -9, 0, 0, 23, 23, 70, 78]
* @param arr
* @param left 左索引
* @param right 右索引
*/
private static void quickSort(int[] arr,int left,int right) {
int l = left;
int r = right;
//中轴
int pivot = arr[(left+right)/2];
int temp;
while(l<r){
//pivot的左边一直找 找到大于等于pivot的值 就退出
while(arr[l]<pivot){
l++;
}
//pivot的右边一直找 找到小于等于pivot的值 就退出
while(arr[r]>pivot){
r--;
}
//如果成立说明 左边的值已经全部小于等于prvot的值 右边的值已经大于pivot的值
if(l>=r){
break;
}
//交换
temp = arr[l];
arr[l] = arr[r];
arr[r] = temp;
//如果交换后 发现arr[l]=pivot r前移 r--
if(arr[l]==pivot){
r--;
}else if(arr[r]==pivot){//如果交换后 发现arr[r]=pivot l后移 l++
l++;
}
}
//当l==r时，说明两者都在pivot上 去除中间轴的下标 如果不去除会栈溢出
if(l==r){
l++;
r--;
}
//向左递归
if(left<r){
quickSort(arr,left,r);
}
//向右递归
if(right>l){
quickSort(arr,l,right);
}
}
}
归并排序
归并排序是利用归并的思想实现的排序方法，该算法采用经典的分治策略（分治法将问题分成一些小的问题然后递归求解，而治的阶段则将分的阶段得到的各答案“修补”在一起，即分而治之）
图解分析
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程，递归深度为log2n。
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤。
代码实现
public class MergeSort {
public static void main(String[] args) {
int[] arr = {8,4,5,7,1,3,6,2};
//mergeSort(arr,0,arr.length-1);
int[] newArr = mergeSortBetter(arr, 0, arr.length - 1);
System.out.println("排序后的数组："+Arrays.toString(arr));
}
/**
* [4, 8, 5, 7, 1, 3, 6, 2]
* [4, 8, 5, 7, 1, 3, 6, 2]
* [4, 5, 7, 8, 1, 3, 6, 2]
* [4, 5, 7, 8, 1, 3, 6, 2]
* [4, 5, 7, 8, 1, 3, 2, 6]
* [4, 5, 7, 8, 1, 2, 3, 6]
* [1, 2, 3, 4, 5, 6, 7, 8]
* 排序后的数组：[1, 2, 3, 4, 5, 6, 7, 8]
* @param arr
* @param left
* @param right
*/
private static void mergeSort(int[] arr, int left, int right) {
if(left<right){
int[] temp = new int[arr.length];
int mid = (left+right)/2;
//向左递归拆分
mergeSort(arr,left,mid);
//向右递归拆分
mergeSort(arr,mid+1,right);
//合并
merge(arr,left,mid,right,temp);
System.out.println(Arrays.toString(arr));
}
}
/**
* 合并方法
* @param arr
* @param left
* @param mid
* @param right
* @param temp
*/
private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
//创建临时变量
int t = 0; //初始化temp的位置
int ls = left;//左边索引起始位置；
int rs = mid+1;//右边索引起始位置
//将左右两边有序数据 填充到temp中 ；直到左右两边有序序列有一边处理完毕
while(ls<=mid&&rs<=right){
// arr[ls]<arr[rs] => 左边的放入temp数组 且 temp后移 ls 后移
if(arr[ls]<arr[rs]){
temp[t++] = arr[ls++];
}else{
temp[t++] = arr[rs++];
}
}
//将有剩余的一边数组依次加入到temp尾部
while(ls<=mid){//如果是左边有剩余拷入
temp[t++] = arr[ls++];
}
while(rs<=right){//如果是右边有剩余拷入
temp[t++] = arr[rs++];
}
//将temp的数组重新放到arr中
t = 0;
int tempLeft = left;
while (tempLeft<=right){
arr[tempLeft++] = temp[t++];
}
}
/**
* 排序后的数组：[8, 4, 5, 7, 1, 3, 6, 2]
*
* @param arr
* @param left
* @param right
* @return
*/
public static int[] mergeSortBetter(int[] arr, int left, int right) {
if (left == right)
return new int[] { arr[left] };
int mid = left + (right - left) / 2;
int[] leftArr = mergeSortBetter(arr, left, mid); //左有序数组
int[] rightArr = mergeSortBetter(arr, mid + 1, right); //右有序数组
int[] newArr = new int[leftArr.length + rightArr.length]; //新有序数组
int t = 0;
int l = 0;
int r = 0;
while (l < leftArr.length && r < rightArr.length) {
newArr[t++] = leftArr[l] < rightArr[r] ? leftArr[l++] : rightArr[r++];
}
while (l < leftArr.length)
newArr[t++] = leftArr[l++];
while (r < rightArr.length)
newArr[t++] = rightArr[r++];
return newArr;
}
}
基数排序
基数排序（radix sort）也称桶排序属于“分配式排序”（distribution sort），又称“桶子法”，（bucket sort）或bin sort, 顾名思议，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
- 基数排序法是属于稳定性的排序，基数排序法是效率高的稳定性排序法
- 基数排序是桶排序的扩展
- 基数排序不能给负数排序
稳定排序：如果要排序的数组有两个相同的数字 如： a1 = a2 =1 {a1,2,3,a2}排序后 {a1,a2,2,3}；a1还是在a2的前面
图解基数排序
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后，数列就变成一个有序序列。
这样说明，比较难理解，看看图文解释：
代码实现
/**
* 空间换时间
*/
public class RadixSort {
public static void main(String[] args) {
int[] arr = {53,3,542,748,14,214};
radixSortStep(arr);
//radixSort(arr);
}
/**
* 信息打印
* 第0轮 个位 排序后的结果：[542, 53, 3, 14, 214, 748]
* 第1轮 个位 排序后的结果：[3, 14, 214, 542, 748, 53]
* 第2轮 个位 排序后的结果：[3, 14, 53, 214, 542, 748]
* 基数排序后的结果：[3, 14, 53, 214, 542, 748]
* @param arr
*/
private static void radixSort(int[] arr) {
//0 先从数组中获取最大的数，以便确认循环多少次
int max = arr[0];
for (int i:arr) {
if(i>max){
max = i;
}
}
int maxLength = (max+"").length();
int count = 0;
int index;
//1 创建一个二维数组 0~9需要0个一维数组 原数组长度避免越界
int[][] bucket = new int[10][arr.length];
//2 将原始数组个位数取余并放入对应的桶中
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 num = arr[j]/n%10;
bucket[num][bucketElementCounts[num]] =arr[j];
bucketElementCounts[num]++;
}
//3 将桶中的元素依次放入原始数组
index = 0;
for (int k = 0; k < bucket.length; k++) {
if(bucketElementCounts[k]!=0){
for (int j = 0; j < bucketElementCounts[k]; j++) {
arr[index++] = bucket[k][j];
}
}
bucketElementCounts[k]=0;
}
System.out.println("第"+(count++)+"轮 个位 排序后的结果："+ Arrays.toString(arr));
}
System.out.println("基数排序后的结果："+Arrays.toString(arr));
}
/**
* 信息打印
* 第一轮 个位 排序后的结果：[542, 53, 3, 14, 214, 748]
* 第二轮 十位 排序后的结果：[3, 14, 214, 542, 748, 53]
* 第三轮 百位 排序后的结果：[3, 14, 53, 214, 542, 748]
* @param arr
*/
private static void radixSortStep(int[] arr) {
//1 创建一个二维数组 0~9需要0个一维数组 原数组长度避免越界
int[][] bucket = new int[10][arr.length];
//2 将原始数组个位数取余并放入对应的桶中
//记录每个桶实际存放元素的个数
int[] bucketElementCounts = new int[10];
for (int i = 0; i < arr.length; i++) {
//每个元素的个位数
int num = arr[i]%10;
//放入对应的桶中
bucket[num][bucketElementCounts[num]] = arr[i];
bucketElementCounts[num]++;
}
//3 将桶中的元素依次放入原始数组
int index = 0;
for (int i = 0; i <bucket.length; i++) {
for (int j = 0; j < bucketElementCounts[i]; j++) {
arr[index++] = bucket[i][j];
}
//需要对本轮设置元素个数清空，避免多次叠加后数组越界
bucketElementCounts[i]=0;
}
System.out.println("第一轮 个位 排序后的结果："+ Arrays.toString(arr));
//第二轮排序
for (int i = 0; i < arr.length; i++) {
//每个元素的十位数
int num = arr[i]/10%10;
//放入对应的桶中
bucket[num][bucketElementCounts[num]] = arr[i];
bucketElementCounts[num]++;
}
//将桶中的元素依次放入原始数组
index = 0;
for (int i = 0; i <bucket.length; i++) {
for (int j = 0; j < bucketElementCounts[i]; j++) {
arr[index++] = bucket[i][j];
}
//需要对本轮设置元素个数清空，避免多次叠加后数组越界
bucketElementCounts[i]=0;
}
System.out.println("第二轮 十位 排序后的结果："+ Arrays.toString(arr));
//第三轮排序
for (int i = 0; i < arr.length; i++) {
//每个元素的百位数
int num = arr[i]/100%10;
bucket[num][bucketElementCounts[num]] = arr[i];
bucketElementCounts[num]++;
}
//将桶中的元素依次放入原始数组
index = 0;
for (int i = 0; i <bucket.length; i++) {
//加个判断如果，不为0才循环 可以减少循环次数
if(bucketElementCounts[i]!=0){
for (int j = 0; j < bucketElementCounts[i]; j++) {
arr[index++] = bucket[i][j];
}
}
//需要对本轮设置元素个数清空，避免多次叠加后数组越界
bucketElementCounts[i]=0;
}
System.out.println("第三轮 百位 排序后的结果："+ Arrays.toString(arr));
}
}
八大算法对比
堆排序要学了二叉树才能理解（此处跳过）
| 排序算法 | 平均时间复杂度 | 最好情况 | 最坏情况 | 空间复杂度 | 排序方式 | 稳定性 |
|---|---|---|---|---|---|---|
| 冒泡排序 | O(n2) | O(n) | O(n2) | O(1) | in-place | 稳定 |
| 选择排序 | O(n2) | O(n2) | O(n2) | O(1) | in-place | 不稳定 |
| 插入排序 | O(n2) | O(n) | O(n2) | O(1) | in-place | 稳定 |
| 希尔排序 | O(n log2 n) | O(n log2 n) | O(n log2 n) | O(1) | in-place | 不稳定 |
| 归并排序 | O(n log n) | O(n log n) | O(n log n) | O(n) | out-place | 稳定 |
| 快速排序 | O(n log n) | O(n log n) | O(n2) | O(log n) | in-place | 不稳定 |
| 堆排序 | O(n log n) | O(n log n) | O(n log n) | O(1) | in-place | 不稳定 |
| 计数排序 | O(n + k) | O(n + k) | O(n + k) | O(k) | out-place | 稳定 |
| 桶排序 | O(n + k) | O(n + k) | O(n2) | O(n + k) | out-place | 稳定 |
| 基数排序 | O(n x k) | O(n x k) | O(n x k) | O(n + k) | out-place | 稳定 |
术语说明：
- 稳定：如果a原本在b前面，而a=b,排序后a任然在b的前面；
- 不稳定：如果a原本在b前面，而a=b,排序后a可能会出现在b的后面；
- 内排序：所有排序操作都在内存中完成
- 外排序：由于数据太大，因为把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
- 时间复杂度：一个算法执行锁消耗的时间
- 空间复杂度：运行完一个程序所需内存的大小
- n:数据规模
- k:“桶”的个数
- in-place：不占用额外内存
- out-place:占用额外内存
1441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
