各类排序算法的时间复杂度（以及记忆口诀）
-
In-place: 占用常数内存，不占用额外内存（也就是空间复杂度为O(1)）
Out-place: 占用额外内存 【口诀可以在时间复杂度的口诀上，改一下：选炮插，快些归队（没有“快归”，只有“些队”）】 -
关于稳定性之前介绍过了（回忆一下：大白话讲就是排序前有两个相同值的元素v1和v2，且v1在v2前，那么稳定排序可以保证排序后，v1还在v2前面）【记忆方法：快选择一些堆（快排，选择，些==希尔，堆排序）】
-
关于时间复杂度的记忆，我选择考研的时候的记法【选炮插（O(n2)），快些归队（O(nlogn)），统计基♂（O(n+k)）】（解释一下，这个口诀是按照平均时间复杂度，从大到小，分成三组：1.选择冒泡插入；2.快排希尔归并堆排；3.桶排计数基数）
-
在第一次排序后，一定能把数据中最大或最小元素放在最终位置上的排序算法是 ：冒泡排序、选择排序、堆排序【记忆：选炮堆】
下面来看排序算法的详细介绍
冒泡排序
- 冒泡排序，就像汽水中的泡泡从底部往上冒一样，按照数组位置递增，两两元素进行对比，如果不符合顺序要求则交换
- 因为是从最开始进行两两对比并交换，所以每次排序必定会确定一个元素到最终位置上。（上面的口别：“选炮堆”的炮就是冒泡的意思）
-
算法可以将数组排序成：升序，降序；冒泡的方向可以从左到右，也可以从右到左；因此代码的实现方式有很多种，但都逃不掉一些特点：
（1）因为冒泡每次都能确定一个元素的最终位置，那么外层遍历其实控制的排序次数，其实不需要数组元素个数的排序次数，只需要数组长度-1次就可以了，因为剩下的最后一个元素自然就归位了
举个例子：【3,2,1】->第一次排序->【2,1,3】->第二次排序->【1,2,3】
（2）内层for的意义是遍历数组元素到确定数组的边界，处理谨慎一些，小心第一次的数组越界（一般可以尝试一下使用代数法，将第一次的值带入，看看会不会越界） -
下面写了一个从左到右的升序冒泡，仅供参考
public static void main(String[] args) {
int[] arr = new int[]{3,5,3,1,2,6,7,10,0,9};
int tmp = 0;
for (int i = arr.length - 1; i > 0; i--)
for (int j = 0; j < i; j++) {
if (arr[j]>arr[j+1]){
tmp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = tmp;
}
}
}
for (int i : arr) {
System.out.print(i+","); 输出0,1,2,3,3,5,6,7,9,10,
}
}
时间复杂度：
- 时间复杂度为（平均）：O(n2)
- 以上的我写的代码哪怕是最佳情况也只能做到O(n2)，但是其实冒泡排序的最佳情况是O(n)，代码应该下面这么写
public void bubbleSort(int arr[]) {
boolean didSwap;
for(int i = 0, len = arr.length; i < len - 1; i++) {
didSwap = false;
for(int j = 0; j < len - i - 1; j++) {
if(arr[j + 1] < arr[j]) {
swap(arr, j, j + 1);
didSwap = true;
}
}
if(didSwap == false)
return;
}
}
- 大体思路就是：在第一次遍历的时候，边遍历，边检查是不是本身就有序，如果有不按顺序的，则给标志位赋值；第一次遍历完检查标志位有没有改动过，如果没有那么直接返回，时间复杂度为O(n)
选择排序
- 选择排序原理就更简单了，很容易理解，每次选择一个最大or最小的元素，与最终位置的元素进行交换。（可参考以下效果图）
- 选择排序 是表现最稳定的排序算法之一 ，因为无论什么数据进去都是O(n2)的时间复杂度 ，所以用到它的时候，数据规模越小越好。唯一的好处可能就是不占用额外的内存空间了吧。理论上讲，选择排序可能也是平时排序一般人想到的最多的排序方法了吧。
- 代码如下：
public static void main(String[] args) {
int[] arr = new int[]{3,5,3,1,2,6,7,10,0,9};
int tmp = 0,index = 0;
for (int i = 0; i < arr.length; i++) {
index = i;
for (int j = i+1; j < arr.length; j++) {
if (arr[index]>arr[j]){
index = j;
}
}
tmp = arr[i];
arr[i] = arr[index];
arr[index] = tmp;
}
for (int i : arr) {
System.out.print(i+","); 输出：0,1,2,3,3,5,6,7,9,10,
}
}
时间复杂度：
- 时间复杂度比较稳定，不管什么情况都需要O(n2)
插入排序
算法思路：
-
为了形象一点，就按照下面的gif效果图来说
-
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。
-
外层的for主要是控制当前的有序数组边缘，所以可以从i=1开始，不必从0，可以默认有序数组只有一个元素的时候，是有序的。
-
内层可以用for也可以用while循环，主要思路还是进行判断，如果升序条件下，外层arr[i]的元素比它前面的元素还要小，那么就将前面的元素向后移动（参考效果图）
-
内层for的代码具体如下：
public static void main(String[] args) {
int[] arr = new int[]{0, 7, -1, -2, 2, 9, 4, 1};
int tmp = 0;
for (int i = 1; i < arr.length; i++) {
for (int j = i; j > 0; j--) {
if (arr[j] >= arr[j - 1]) {
break;
} else {
tmp = arr[j];
arr[j] = arr[j - 1];
arr[j - 1] = tmp;
}
}
}
for (int i : arr) {
System.out.print(i + ","); 输出 ：-2,-1,0,1,2,4,7,9,
}
}
- 内层使用while的代码如下：
public static void main(String[] args) {
int[] arr = new int[]{0, 7, -1, -2, 2, 9, 4, 1};
int tmp = 0;
int index;
for (int i = 1; i < arr.length; i++) {
tmp = arr[i];
index = i;
while (index - 1 >= 0 && tmp < arr[index - 1]){
arr[index] = arr[index-1];
index--;
}
arr[index] = tmp;
}
for (int i : arr) {
System.out.print(i + ",");
}
}
7、100G的数据，只有2G内存，怎么排序？
用归并排序。当出现数据没办法一次装入内存的情况时，一般采用外部排序。将100G的数据分解为多个能够一次性装入内存中的小部分。然后分别把每一个小部分排序，最后对每一个小部分进行归并排序。
希尔排序
-
希尔排序是希尔（Donald Shell） 于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序，同时该算法是冲破O(n2）的第一批算法之一。它与插入排序的不同之处在于，它会优先比较距离较远的元素。希尔排序又叫缩小增量排序。
-
希尔排序是把记录按下表的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。
-
大白话就是：按照步长将数组分为多个组（起始步长为length/2，之后每次循环 步长= 步长/2），然后再每个分组内局部进行排序；
-
代码如下：
public static int[] ShellSort(int[] array) {
int len = array.length;
int temp, gap = len / 2;
while (gap > 0) {
for (int i = gap; i < len; i++) {
temp = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && array[preIndex] > temp) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = temp;
}
gap /= 2;
}
return array;
}
归并排序
-
和选择排序一样，归并排序的性能不受输入数据的影响，但表现比选择排序好的多，因为始终都是O(nlogn）的时间复杂度。代价是需要额外的内存空间。
-
归并排序 是建立在归并操作上的一种有效的排序算法。该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。归并排序是一种稳定的排序方法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为2-路归并。
-
代码如下：
/**
* 归并排序
*
* @param array
* @return
*/
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));
}
/**
* 归并排序——将两段排序好的数组结合成一个排序数组
*
* @param left
* @param right
* @return
*/
public 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++) {
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;
}
快速排序 （面试常常考）
- 快速排序 的基本思想：通过一趟排序将待排记录分隔成独立的两部分，其中一部分记录的关键字均比另一部分的关键字小，则可分别对这两部分记录继续进行排序，以达到整个序列有序。
- 说人话就是：每一次选一个“基准”（pivot ），第一次就选择第一个元素为基准，然后遍历一遍数组，将所有比基准小的（等于的）都放到基准前，大于的放在基准后（这个时候基准的位置就定了，并将一个数组分成了前后两个分区），之后就是不停的对每个分区中重复上述的动作（挑一个基准元素，然后在分区中将小于等于的放前面，大于的放后面）
- 有两种代码如下：
/**
* 快速排序方法
* @param array
* @param start
* @param end
* @return
*/
public static int[] QuickSort(int[] array, int start, int end) {
if (array.length < 1 || start < 0 || end >= array.length || start > end) return null;
int smallIndex = partition(array, start, end);
if (smallIndex > start)
QuickSort(array, start, smallIndex - 1);
if (smallIndex < end)
QuickSort(array, smallIndex + 1, end);
return array;
}
/**
* 快速排序算法——partition
* @param array
* @param start
* @param end
* @return
*/
public static int partition(int[] array, int start, int end) {
int pivot = (int) (start + Math.random() * (end - start + 1));
int smallIndex = start - 1;
swap(array, pivot, end);
for (int i = start; i <= end; i++)
if (array[i] <= array[end]) {
smallIndex++;
if (i > smallIndex)
swap(array, i, smallIndex);
}
return smallIndex;
}
/**
* 交换数组内两个元素
* @param array
* @param i
* @param j
*/
public static void swap(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
下面这个版本好理解，而且上面的版本，在牛客网的时候，当数组过长，造成了stackOverFlow的报错，尝试一下下面的版本
import java.util.*;
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
* 将给定数组排序
* @param arr int整型一维数组 待排序的数组
* @return int整型一维数组
*/
// 快排序
private static void doSolution4(int[] arr, int start, int end) {
if (arr.length == 0 || start < 0 || end >= arr.length || start > end) {
return;
}
int smallIndex = partition(arr, start, end);
if (smallIndex > start) {
doSolution4(arr, start, smallIndex - 1);
}
if (smallIndex < end) {
doSolution4(arr, smallIndex + 1, end);
}
}
// 5，2，3，1，4
// 第一个 5 为基准
// 4，2，3，1，5
private static int partition(int[] arr, int start, int end) {
//选第一个为基准
int p = arr[start];
while (start < end) {
while (start < end && arr[end] >= p) {
end--;
}
swqp(arr, start, end);
while (start < end && arr[start] <= p) {
start++;
}
swqp(arr, start, end);
}
return start;
}
private static void swqp(int[] arr, int i, int j) {
int tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
}
}
堆排序
-
堆排序（Heapsort） 是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
-
7.1 算法描述
步骤1：将初始待排序关键字序列(R1,R2….Rn)构建成大顶堆，此堆为初始的无序区；
步骤2：将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,……Rn-1)和新的有序区(Rn),且满足R[1,2…n-1]<=R[n]；
步骤3：由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,……Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2….Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。 -
说人话就是：使用大顶堆和小顶堆的性质来找数组中的最值，然后将最值进行固定到有序数组中，之后再通过堆的性质找第二大（或者第二小）的元素，再固定…
-
代码如下
//声明全局变量，用于记录数组array的长度；
static int len;
/**
* 堆排序算法
*
* @param array
* @return
*/
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;
}
/**
* 建立最大堆
*
* @param array
*/
public static void buildMaxHeap(int[] array) {
//从最后一个非叶子节点开始向上构造最大堆
//for循环这样写会更好一点：i的左子树和右子树分别2i+1和2(i+1)
for (int i = (len/2- 1); i >= 0; i--) {
adjustHeap(array, i);
}
}
/**
* 调整使之成为最大堆
*
* @param array
* @param i
*/
public static void adjustHeap(int[] array, int i) {
int maxIndex = i;
//如果有左子树，且左子树大于父节点，则将最大指针指向左子树
if (i * 2 < len && array[i * 2] > array[maxIndex])
maxIndex = i * 2 + 1;
//如果有右子树，且右子树大于父节点，则将最大指针指向右子树
if (i * 2 + 1 < len && array[i * 2 + 1] > array[maxIndex])
maxIndex = i * 2 + 2;
//如果父节点不是最大值，则将父节点与最大值交换，并且递归调整与父节点交换的位置。
if (maxIndex != i) {
swap(array, maxIndex, i);
adjustHeap(array, maxIndex);
}
}
计数排序
-
计数排序 的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。 作为一种线性时间复杂度的排序，计数排序要求输入的数据必须是有确定范围的整数。
-
计数排序(Counting sort) 是一种稳定的排序算法。计数排序使用一个额外的数组C，其中第i个元素是待排序数组A中值等于i的元素的个数。然后根据数组C来将A中的元素排到正确的位置。它只能对整数进行排序。
-
排序步骤：
（1）首先找出待排序的数组中最大和最小的元素；（为了创建统计数组）
（2）统计数组中每个值为i的元素出现的次数，存入数组C的第i项；
（3）对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）；
（4）反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1。 -
注意到其实计数排序是可以有不稳定的写法的，但还是记口诀吧：不稳定的有：“快选择一些堆”
- 代码：
/**
* 计数排序
*
* @param array
* @return
*/
public static int[] CountingSort(int[] array) {
if (array.length == 0) return array;
int bias, min = array[0], 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];
}
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;
}
桶排序
桶排序 是计数排序的升级版。它利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
-
桶排序 (Bucket sort)的工作的原理：
假设输入数据服从均匀分布，将数据分到有限数量的桶里，每个桶再分别排序（有可能再使用别的排序算法或是以递归方式继续使用桶排序进行排 -
算法描述
步骤1：人为设置一个BucketSize，作为每个桶所能放置多少个不同数值（例如当BucketSize==5时，该桶可以存放｛1,2,3,4,5｝这几种数字，但是容量不限，即可以存放100个3）；
步骤2：遍历输入数据，并且把数据一个一个放到对应的桶里去；
步骤3：对每个不是空的桶进行排序，可以使用其它排序方法，也可以递归使用桶排序；
步骤4：从不是空的桶里把排好序的数据拼接起来。
注意，如果递归使用桶排序为各个桶排序，则当桶数量为1时要手动减小BucketSize增加下一循环桶的数量，否则会陷入死循环，导致内存溢出。
基数排序
基数排序也是非比较的排序算法，对每一位进行排序，从最低位开始排序，复杂度为O(kn),为数组长度，k为数组中的数的最大的位数；
-
基数排序是按照低位先排序，然后收集；再按照高位排序，然后再收集；依次类推，直到最高位。有时候有些属性是有优先级顺序的，先按低优先级排序，再按高优先级排序。最后的次序就是高优先级高的在前，高优先级相同的低优先级高的在前。基数排序基于分别排序，分别收集，所以是稳定的。
-
算法描述
步骤1：取得数组中的最大数，并取得位数；
步骤2：arr为原始数组，从最低位开始取每个位组成radix数组；
步骤3：对radix进行计数排序（利用计数排序适用于小范围数的特点）； -
动图演示
————— END —————
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
