经典排序算法总结
比较类排序：
在排序的最终结果里，元素之间的次序依赖于它们之间的比较。每个数都必须和其他数进行比较，才能确定自己的位置。
非比较类排序：
非比较排序是通过确定每个元素之前，应该有多少个元素来排序。针对数组arr，计算arr[i]之前有多少个元素，则唯一确定了arr[i]在排序后数组中的位置。
算法复杂度：
稳定：
如果a原本在b前面，而a=b，排序之后a仍然在b的前面。
不稳定：
如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
内排序：
所有排序操作都在内存中完成。
外排序：
由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行。
空间复杂度：
主要衡量一个算法所需要的额外空间。
空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度 。空间复杂度不是程序占用了多少bytes 的空间，因为这个也没太大意义，所以空间复杂度算的是变量的个数。
时间复杂度：
一个算法所花费的时间与其中语句的执行次数成正比例
主要衡量的是一个算法的运行速度。
大 O 的渐进表示法：
推导大O阶方法：
1、用常数1取代运行时间中的所有加法常数。
2、在修改后的运行次数函数中，只保留最高阶项。
3、如果最高阶项存在且不是1，则去除与这个项目相乘的常数。得到的结果就是大O阶。
有些算法的时间复杂度存在最好、平均和最坏情况：
最坏情况：任意输入规模的最大运行次数(上界)
平均情况：任意输入规模的期望运行次数
最好情况：任意输入规模的最小运行次数(下界)
在实际中一般情况关注的是算法的最坏运行情况，所以数组中搜索数据时间复杂度为O(N)
| 例子 | 时间复杂度 | 术语 |
|---|---|---|
| 5201314 | O(1) | 常数阶 |
| 3n+4 | O(n) | 线性阶 |
| 3n^2+4n+5 | O(n^2) | 平方阶 |
| slog(2)n+4 | O(logn) | 对数阶 |
| 2n+3nlog(2)n+14 | O(nlogn) | nlogn阶 |
| n^3+2n2+4n+6 | O(n^3) | 立方阶 |
| 2^n | O(2^n) | 指数阶 |
常用的时间复杂度所耗费的时间从小到大依次是：
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
冒泡排序 (BubbleSort)
冒泡排序是一种简单直观的排序算法。
它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
冒泡排序的优化算法：立一个 flag，当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序。
算法步骤：
- 比较相邻的元素。如果第一个比第二个大，就交换他们两个。
- 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素会是最大的数。
- 针对所有的元素重复以上的步骤，除了最后一个。
- 重复步骤1~3，直到排序完成。
public static int[] bubbleSort(int[] array){
if(array.length==0){
return array;
}
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length-1-i; j++) {
if(array[j+1]<array[j]){
int tmp=array[j+1];
array[j+1]=array[j];
array[j]=tmp;
}
}
}
return array;
}
最佳情况：T(n) = O(n)
最差情况：T(n) = O(n^2)
平均情况：T(n) = O(n^2)
选择排序 (SelectSort)
选择排序是一种简单直观的排序算法，无论什么数据进去都是 O(n²) 的时间复杂度。
算法步骤：
- 初始状态：无序区为R[1…n]，有序区为空；
- 第 i 趟排序( i = 1,2,3…n-1) 开始时，当前有序区和无序区分别为R[1…i-1]和R(i…n）。该趟排序从当前无序区中选出关键字最小的记录R[k]，将它与无序区的第1个记录R交换，使R[1…i]和R[i+1…n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
- n-1趟结束，数组有序化了。
public static int[] selectsort(int[] array){
if(array.length==0){
return array;
}
for (int i = 0; i < array.length; i++) { //循环次数
int minIndex=i;
for (int j = i+1; j < array.length; j++) {
// 找到最小数的索引
if(array[j]<array[minIndex]){
// 将最小数的索引保存
minIndex=j;
}
}
int tmp=array[minIndex];
array[minIndex]=array[i];
array[i]=tmp;
}
return array;
}
最佳情况：T(n) = O(n^2)
最差情况：T(n) = O(n^2)
平均情况：T(n) = O(n^2)
插入排序 (InsertSort)
插入排序是一种最简单直观的排序算法，它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
算法步骤：
- 从第一个元素开始，该元素可以认为已经被排序；
- 取出下一个元素，在已经排序的元素序列中从后向前扫描；
- 如果该元素（已排序）大于新元素，将该元素移到下一位置；
- 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
- 将新元素插入到该位置后；
- 重复步骤2~5。
public static int[] insertSort(int[] array){
if(array.length==0){
return array;
}
int current; // 要插入的数
for (int i = 0; i < array.length-1; i++) {
current=array[i+1];
int preIndex=i;
while(preIndex>=0 && current<array[preIndex]){
array[preIndex+1]=array[preIndex];
preIndex--;
}
array[preIndex+1]=current;
}
return array;
}
最佳情况：T(n) = O(n)
最坏情况：T(n) = O(n^2)
平均情况：T(n) = O(n^2)
希尔排序 (ShellSort)
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
算法步骤：
- 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
- 按增量序列个数 k，对序列进行 k 趟排序；
- 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
public static int[] shellSort(int[] array) {
if (array.length == 0) {
return array;
}
int len = array.length;
int tmp, gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
tmp = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > tmp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = tmp;
}
gap /= 2;
}
return array;
}
最佳情况：T(n) = O(nlog2 n)
最坏情况：T(n) = O(nlog2 n)
平均情况：T(n) =O(nlog2n)
归并排序 (MergeSort)
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。
算法步骤：
- 把长度为n的输入序列分成两个长度为n/2的子序列；
- 对这两个子序列分别采用归并排序；
- 将两个排序好的子序列合并成一个最终的排序序列。
public static int[] mergeSort(int[] array){
if(array.length<2){
return array;
}
int mid=array.length/2;
int[] left= Arrays.copyOfRange(array,0,mid);
int[] right=Arrays.copyOfRange(array,mid,array.length);
return merge(mergeSort(left),mergeSort(right));
}
private static int[] merge(int[] left, int[] right) {
int[] result=new int[left.length+right.length];
for (int index = 0,i=0,j=0; index < result.length; index++) {
// i>=length 说明 left 数组已经全部插完
// 只要将 right 数组剩下的插入 result 数组即可
if(i>=left.length){
result[index]=right[j++];
}else if(j>=right.length){
result[index]=left[i++];
}else if(left[i]>right[j]){
result[index]=right[j++];
}else{
result[index]=left[i++];
}
}
return result;
}
最佳情况：T(n) = O(n)
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)
快速排序 (QuickSort)
快速排序的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
算法步骤：
- 从数列中挑出一个元素，称为 “基准”（pivot）；
- 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
- 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
public static void quickSort(int[] array){
if(array.length==0){
return;
}
quickSortInter(array,0,array.length-1);
}
// 待排序空间 [left,right]
private static void quickSortInter(int[] array, int left, int right) {
if(left>=right){
return;
}
// 1.选择基准值 array[left]
// 2.做 partition
int pivotIndex=partition(array,left,right);
// 左边小区间[left,pivotIndex-1]
// 右边小区间[pivotIndex+1,right]
// 3.分别对左右小区间按同样方式处理
quickSortInter(array,left,pivotIndex-1);
quickSortInter(array,pivotIndex+1,right);
}
private static int partition(int[] array, int left, int right) {
int begin=left;
int end=right;
int pivot=array[left];
// [left,begin) <= pivot
// (end,right] >= pivot
while(begin<end){
while(begin<end && array[end]>=pivot){
end--;
}
while(begin<end && array[begin]<= pivot){
begin++;
}
swap(array,begin,end);
}
swap(array,left,begin);
return begin;
}
private static void swap(int[] array,int i,int j){
int tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
最佳情况：T(n) = O(nlogn)
最差情况：T(n) = O(n2)
平均情况：T(n) = O(nlogn)
堆排序 (HeapSort)
堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
- 大顶堆：每个节点的值都大于或等于其子节点的值，在堆排序算法中用于升序排列；
- 小顶堆：每个节点的值都小于或等于其子节点的值，在堆排序算法中用于降序排列；
算法步骤：
- 将初始待排序关键字序列 (R1,R2….Rn) 构建成大顶堆，此堆为初始的无序区；
- 将 堆顶元素R[1] 与 最后一个元素R[n] 交换，得到新的无序区(R1,R2,……Rn-1) 和 新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
- 交换后新的堆顶R[1] 可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。
数组与完全二叉树：
如果从下标从1开始存储，则编号为i的结点的主要关系为：
双亲：下取整 （i/2）
左孩子：2i
右孩子：2i+1
如果从下标从0开始存储，则编号为i的结点的主要关系为：
双亲：下取整 （(i-1)/2）
左孩子：2i+1
右孩子：2i+2
// 声明全局变量，用于记录数组 array的长度
static int len;
public static int[] heapSort(int[] array){
len=array.length;
if(len<1){
return array;
}
// 1.构建一个最大堆
buildMaxHeap(array);
// 2.循环将堆首位（最大值）与末位交换，然后在重新调整最大堆
while(len>0){
swap(array,0,len-1);
len--;
adjustHeap(array,0);
}
return array;
}
// 建立最大堆
private static void buildMaxHeap(int[] array) {
// 从最后一个非叶子节点开始向上构造最大堆
for(int i=(len-1)/2;i>=0;i--){
adjustHeap(array,i);
}
}
// 调整使之成为最大堆
private static void adjustHeap(int[] array, int i) {
int maxIndex=i;
// 如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if(i*2<len && array[i*2]>array[maxIndex]){
maxIndex=i*2;
}
// 如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if(i*2+1<len && array[i*2+1]>array[maxIndex]){
maxIndex=i*2+1;
}
// 如果父节点不是最大值，则将父节点与最大值交换，
// 并且递归调整与父节点交换的位置
if(maxIndex != i){
swap(array,maxIndex,i);
adjustHeap(array,maxIndex);
}
}
private static void swap(int[] array, int i, int j) {
int tmp=array[i];
array[i]=array[j];
array[j]=tmp;
}
最佳情况：T(n) = O(nlogn)
最差情况：T(n) = O(nlogn)
平均情况：T(n) = O(nlogn)
计数排序 (Counting Sort)
计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
算法步骤：
- 找出待排序的数组中最大和最小的元素；
- 统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
- 对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
- 反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。
public static int[] CountingSort(int[] array) {
if (array.length == 0) {
return array;
}
int bias;
int min = array[0];
int max = array[0];
// 找出待排序的数组中最大和最小的元素
for (int i = 1; i < array.length; i++) {
if (array[i] > max) {
max = array[i];
}
if (array[i] < min) {
min = array[i];
}
}
// 统计每个值出现的次数，存在数组bucket中
bias = 0 - min;
int[] bucket = new int[max - min + 1]; // 数组的长度
// 将指定的布尔值分配给数组的每个元素
Arrays.fill(bucket, 0);
for (int i = 0; i < array.length; i++) {
bucket[array[i] + bias]++;
}
int index = 0, i = 0;
while (index < array.length) {
if (bucket[i] != 0) {
array[index] = i - bias;
bucket[i]--;
index++;
} else {
i++;
}
}
return array;
}
最佳情况：T(n) = O(n+k)
最差情况：T(n) = O(n+k)
平均情况：T(n) = O(n+k)
桶排序 (BucketSort)
算法步骤：
- 设置一个BucketSize，作为每个桶所能放置多少个不同数值
例如：当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3； - 遍历输入数据，并且把数据一个一个放到对应的桶里去；
- 对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
- 从不是空的桶里把排好序的数据拼接起来。
如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。
public static ArrayList<Integer> bucketSort(ArrayList<Integer> array,int bucketSize){
if(array==null || array.size()<2){
return array;
}
int max=array.get(0);
int min=array.get(0);
// 找到最大最小值
for (int i = 1; i < array.size(); i++) {
if(array.get(i)>max){
max=array.get(i);
}
if(array.get(i)<min){
min=array.get(i);
}
}
int bucketCount=(max-min)/bucketSize+1;
ArrayList<ArrayList<Integer>> bucketArr=new ArrayList<>(bucketCount);
ArrayList<Integer> resultArr=new ArrayList<>();
for (int i = 0; i < bucketCount; i++) {
bucketArr.add(new ArrayList<Integer>());
}
for (int i = 0; i < array.size(); i++) {
bucketArr.get((array.get(i)-min)/bucketSize).add(array.get(i));
}
for (int i = 0; i < bucketCount; i++) {
if(bucketCount==1){
bucketSize--;
}
ArrayList<Integer> tmp=bucketSort(bucketArr.get(i),bucketSize);
for (int j = 0; j < tmp.size(); j++) {
resultArr.add(tmp.get(j));
}
}
return resultArr;
}
最佳情况：T(n) = O(n+k)
最差情况：T(n) = O(n+k)
平均情况：T(n) = O(n2)
基数排序 (RadixSort)
基数排序是按照低位先排序，然后收集；
再按照高位排序，然后再收集；
依次类推，直到最高位。
算法步骤：
- 取得数组中的最大数，并取得位数；
- arr为原始数组，从最低位开始取每个位组成radix数组；
- 对radix进行计数排序（利用计数排序适用于小范围数的特点）；
public static int[] radixSort(int[] array){
if(array==null||array.length<2){
return array;
}
// 1.先算出最大数的位数
int max=array[0];
for (int i = 1; i <array.length ; i++) {
max=Math.max(max,array[i]);
}
int maxDigit=0;
while(max!=0){
max /= 10;
maxDigit++;
}
int mod=10;
int div=1;
ArrayList<ArrayList<Integer>> bucketList=new ArrayList<ArrayList<Integer>>();
for (int i = 0; i < 10; i++) {
bucketList.add(new ArrayList<Integer>());
}
for (int i = 0; i < maxDigit; i++,mod *= 10,div *= 10) {
for (int j = 0; j < array.length; j++) {
int num=(array[j]%mod)/div;
bucketList.get(num).add(array[j]);
}
int index=0;
for (int j = 0; j < bucketList.size(); j++) {
for (int k = 0; k < bucketList.get(j).size(); k++) {
array[index++]=bucketList.get(j).get(k);
}
bucketList.get(j).clear();
}
}
return array;
}
最佳情况：T(n) = O(n * k)
最差情况：T(n) = O(n * k)
平均情况：T(n) = O(n * k)
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
