经典排序算法总结
0.排序算法和时间复杂度简介
0.1 排序算法简介
0.1.1 排序算法定义
排序算法 (Sort Algorithm)是将一组数据按照指定顺序进行排列的过程。
0.1.2排序算法分类
(1) 内部排序:
将需要处理的所有数据都加载到内部存储器(内存)中进行排序。
(2) 外部排序法：
数据量过大，无法全部加载到内存中，需要借助外部存储(文件等)进行排序。
(3)常见排序算法
0.2 时间复杂度简介
0.2.1 时间频度
算法中语句执行次数称为语句频度或时间频度。记为 T(n)
//计算1-100累加
int n=100;
int sum=0;
for(int i=0;i<n;i++)
sum+=i;
// T(n)=n+1 时间复杂度O(n)
0.2.2 时间复杂度
算法中的基本操作语句的重复执行次数是问题规模 n 的某个函数，用 T(n)表示。
若有某个辅助函数 f(n)，使得当 n 趋近于无穷大时，T(n) / f(n) 的极限值为不等于零的常数，则称 f(n)是 T(n)的同数量级函数。
记作 T(n)=Ｏ( f(n) )，称Ｏ( f(n) ) 为算法的渐进时间复杂度，简称时间复杂度。
eg:T(n)=n^2+7n+3 O(n)=n2
0.2.3常见时间复杂度
(1) 常数阶 O(1)
(2) 对数阶 O(logn)
(3) 线性阶 O(n)
(4) 线性对数阶 O(nlogn)
(5) k 次方阶 O(nk )
(6) 指数阶 O(2n )
(7)阶乘阶(n!)
上述时间复杂度逐渐增大
0.3 排序算法比较
术语说明
(1) 稳定：如果 a 原本在 b 前面，且a=b，排序之后 a 仍然在 b 的前面。
(2) 不稳定：如果 a 原本在 b 的前面，且 a=b，排序之后 a 可能会出现在 b 的后面。
(3) 内排序：所有排序操作都在内存中完成。
(4) 外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行。
(5) 时间复杂度： 一个算法执行所耗费的时间。
(6) 空间复杂度：运行完一个程序所需内存的大小。
(7) n: 数据规模。
(8) k: “桶”的个数。
(9) In-place: 不占用额外内存。
(10) Out-place: 占用额外内存
1.冒泡排序
1.1 思路简介
通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就象水底下的气泡一样逐渐向上冒。
1.2 图解
1.3 代码实现(优化版本)
public static void bubble(int arr[])
{
int len=arr.length;
boolean flag=true;
for(int i=0;i<len-1;i++) //第i趟 将相应的值放在相应的位置
{
for(int j=0;j<len-1-i;j++)
{
int temp=0;
if(arr[j]>arr[j+1])
{
flag=false;
temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
if(flag) //某趟排序后 如果没有发生排序 则说明当前顺序是正确的
{
break;
}
else //如果某趟排序发生了交换 flag=false 再将flag 置为true 便于下趟循环判断
flag=true;
}
}
2.选择排序
2.1 思路简介
第一次从 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]交换，第 n-1 次从 arr[n-2]~arr[n-1]中选取最小值，与 arr[n-2]交换，总共通过 n-1 次，得到一个按排序码从小到大排列的有序序列。
2.2 图解
2.3 代码实现
public static void select(int []arr)
{
int len=arr.length;
int temp=0;
for(int i=0;i<len-1;i++)
{
int MinNum=arr[i];
int MinIndex=i;
for(int j=i+1;j<len;j++)//一次循环后 找出最小值和最小值对应的下标 (注意 j=i+1)
{
if(arr[j]<MinNum)
{
MinNum=arr[j];
MinIndex=j;
}
}
if(MinIndex!=i) //如果MinIndex==i 说明不用交换 否则将最小值赋值给相应的位置
{
arr[i]=MinNum;
arr[MinIndex]=temp;
}
}
}
3.插入排序
3.1 思路简介
把 n 个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有 n-1 个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。
3.2 图解
3.3 代码实现
public static void insert(int []arr)
{
int len=arr.length;
for(int i=1;i<len;i++)
{
int InsertValue = arr[i]; //待插入的数据
int InsertIndex = i - 1; //初始化待插入数据的初始下标
if (InsertValue < arr[InsertIndex])
{
while (InsertIndex >= 0 && InsertValue < arr[InsertIndex])
{
arr[InsertIndex + 1] = arr[InsertIndex];
InsertIndex--;
}
if (InsertIndex + 1 != i)
{
arr[InsertIndex + 1] = InsertValue;
}
}
}
}
4.Shell(希尔)排序
4.1 思路简介
希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至 1 时，整个文件恰被分成一组，算法便终止。
4.2 图解
4.3.1 代码实现(交换法)
public static void shell_exchange(int []arr)
{
int len=arr.length;
int temp=0;
for(int size=len/2;size>0;size/=2) //步长
{
for(int i=size;i<len;i++) //从步长开始到数组长度
{
for(int j=i-size;j>=0;j-=size) //插入排序
{
if(arr[j]>arr[j+size])
{
temp=arr[j+size];
arr[j+size]=arr[j];
arr[j]=temp;
}
}
}
}
4.3.2 代码实现(移位法)
public static void shell_move(int[]arr)
{
int len=arr.length;
int InsertNum=0;
int InsertIndex=0;
for(int size=len/2;size>0;size/=2)
{
for (int i = size; i < len; i++)
{
InsertNum = arr[i];
InsertIndex = i-size;
if (InsertNum < arr[InsertIndex])
{
while (InsertIndex >= 0 && InsertNum < arr[InsertIndex])
{
arr[InsertIndex+size] = arr[InsertIndex];
InsertIndex -= size;
}
arr[InsertIndex+size]=InsertNum;
}
}
}
}
5.快速排序
5.1 思路简介
通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
5.2 图解
5.3 代码实现
public static void quickSort(int[] arr, int left, int right)
{
int l = left; // 左下标
int r = right; // 右下标
int pivot = arr[(left + right) / 2]; // pivot 中轴值
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);
}
}
6.归并排序
6.1 思路简介
采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
6.2 图解
6.3 代码实现
public static void mergrSort(int []arr,int left,int right,int []temp)
{
//递归具体运行示意图请往后翻
if(left<right)
{
int mid=(left+right)/2;
mergrSort(arr, left, mid, temp);//左递归
mergrSort(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)
{
int i=left;
int j=mid+1;
int t=0;
//1.
//先把左右两边(有序)的数据按照规则填充到 temp 数组
//直到左右两边的有序序列，有一边处理完毕为止
while(i<=mid && j<=right)
{
//如果左边的有序序列的当前元素，小于等于右边有序序列的当前元素 就将左边当前元素填充到 temp 数组
//然后将索引++
if(arr[i]<=arr[j])
{
temp[t]=arr[i];
i++;
t++;
}
else
{
temp[t]=arr[j];
j++;
t++;
}
}
//2.
//将剩余数据的一边的数据依次全部填充到 temp
while(i<=mid) //左边的有序序列还有剩余的元素，就全部填充到 temp
{
temp[t]=arr[i];
i++;
t++;
}
while(j<=right) //右边的有序序列还有剩余的元素，就全部填充到 temp
{
temp[t]=arr[j];
j++;
t++;
}
//3.
//将temp元素copy到arr数组
t=0;
int tempLeft=left;
while(tempLeft<=right)
{
arr[tempLeft]=temp[t];
tempLeft++;
t++;
}
}
7.基数排序
7.1 思路简介
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
7.2 图解
7.3 代码实现
public static void radixSort(int[] arr)
{
// 获取最大位数(先获取最大数 再获取最大数对应的位数)
int len = arr.length;
int max = arr[0]; // 先 假定 max 是数组第一个值
for (int i = 0; i < len; i++)
{
if (arr[i] > max)
{
max = arr[i];
}
}
int maxLength = (max + "").length();// 最大位数
// 定义桶 每个桶是二维数组 为了防止每个桶数据溢出 将每个桶大小设置为数据长度(空间换时间)
final int num = 10; //因为每次获取的数字只有0-9 所以定义10
int[][] bucket = new int[num][len];
int[] bucketIndex = new int[num];// 每个桶放了多少数据的索引
for (int i = 0, n = 1; i < maxLength; i++, n *= 10)
{
for (int j = 0; j < len; j++)
{
int digit = arr[j] / n % 10; // 获取对应的位数(个位 十位 ...)
bucket[digit][bucketIndex[digit]] = arr[j];
bucketIndex[digit]++;
}
// 遍历所有桶 依次取出数据 放回原来数组
int arrIndex = 0;
for (int buck = 0; buck < num; buck++)
{
if (bucketIndex[buck] != 0)
{
for (int k= 0; k < bucketIndex[buck]; k++)
{
arr[arrIndex] = bucket[buck][k];
arrIndex++;
}
bucketIndex[buck] = 0;// 将该桶所有数据放回原数组后 将该桶索引置0 否则下次将数据放回桶的时候 就会继续上次的位置
}
}
}
}