排序算法汇总:
时间复杂度 | 空间复杂度 | |
稳定排序 | ||
气泡排序 | 最差、平均都是O(n²),最好是O(n) | 1 |
鸡尾酒排序 | 最差、平均都是O(n²),最好是O(n) | 1 |
插入排序 | 最差、平均都是O(n²),最好是O(n) | 1 |
归并排序 | 最差、平均、最好都是O(nlog n) | O(n) |
桶排序 | O(n) | O(n) |
基数排序 | O(dn) | O(n) |
二叉树排序 | O(nlog n) | O(n) |
图书馆排序 | O(nlog n) | O(n) |
不稳定排序 | ||
选择排序 | 最差、平均都是O(n²) | 1 |
希尔排序 | O(nlog n) | 1 |
堆排序 | 最差、平均、最好都是O(nlog n) | 1 |
快速排序 | 平均是O(nlog n),最坏是O(n²) | O(nlog n)
|
排序算法解释:
1 | 大部分程序的大部分指令之执行一次,或者最多几次。 如果一个程序的所有指令都具有这样的性质,我们说这个程序的执行时间是常数。 |
logN | 如果一个程序的运行时间是对数级的,则随着N的增大程序会渐渐慢下来, 如果一个程序将一个大的问题分解成一系列更小的问题, 每一步都将问题的规模缩减成几分之一,一般就会出现这样的运行时间函数。 在我们所关心的范围内,可以认为运行时间小于一个大的常数。 对数的基数会影响这个常数,但改变不会太大: 当N=1000时,如果基数是10,logN等于3;如果基数是2,logN约等于10. 当N=1 00 000,logN只是前值的两倍。 当N时原来的两倍,logN只增长了一个常数因子: 仅当从N增长到N平方时,logN才会增长到原来的两倍。 |
N | 如果程序的运行时间的线性的,很可能是这样的情况: 对每个输入的元素都做了少量的处理。 当N=1 000 000时,运行时间大概也就是这个数值; 当N增长到原来的两倍时,运行时间大概也增长到原来的两倍。 如果一个算法必须处理N个输入(或者产生N个输出),那么这种情况是最优的。 |
NlogN | 如果某个算法将问题分解成更小的子问题,独立地解决各个子问题, 最后将结果综合起来,运行时间一般就是NlogN。 我们找不到一个更好的形容,就暂且将这样的算法运行时间叫做NlogN。 当N=1 000 000时,NlogN大约是20 000 000。 当N增长到原来的两倍,运行时间超过原来的两倍,但超过不是太多。 |
N平方 | 如果一个算法的运行时间是二次的(quadratic), 那么它一般只能用于一些规模较小的问题。 这样的运行时间通常存在于需要处理每一对输入数据项的算法 (在程序中很可能表现为一个嵌套循环)中, 当N=1000时,运行时间是1 000 000; 如果N增长到原来的两倍,则运行时间将增长到原来的四倍。 |
N三次方 | 类似的,如果一个算法需要处理输入数据想的三元组 (很可能表现为三重嵌套循环), 其运行时间一般就是三次的,只能用于一些规模较小的问题。 当N=100时,运行时间就是1 000 000; 如果N增长到原来的两倍,运行时间将会增长到原来的八倍。 |
2的N次方 | 如果一个算法的运行时间是指数级的(exponential), 一般它很难在实践中使用,即使这样的算法通常是对问题的直接求解。 当N=20时,运行时间是1 000 000; 如果增长到原来的两倍时,运行时间将是原时间的平方! |
排序算法-冒泡排序:
// 冒泡排序
public static void bubbleSort(int[] source) {
if (null != source && source.length > 0)
for (int i = source.length - 1; i > 0; i--)
for (int j = 0; j < i; j++)
if (source[j] > source[j + 1])
swap(source, j, j + 1);
}
// 数组两个位置的值互换
public static void swap(int[] source, int x, int y) {
int temp = source[x];
source[x] = source[y];
source[y] = temp;
}
// 数组打印控制台
public static void print(int[] source) {
for (int i : source)
System.out.print(i+" ");
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
bubbleSort(a);
print(a);
}
排序算法-选择排序:
//选择排序
public static void selectSort(int[] source) {
if (null != source && source.length > 0)
for (int i = 0; i < source.length; i++)
for (int j = i + 1; j < source.length; j++)
if (source[i] > source[j])
swap(source, i, j);
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
selectSort(a);
print(a);
}
排序算法-插入排序:
// 插入排序
public static void insertSort(int[] source) {
if (null != source && source.length > 0)
for (int i = 1; i < source.length; i++)
for (int j = i; (j > 0) && (source[j] < source[j - 1]); j--)
swap(source, j , j - 1);
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
insertSort(a);
print(a);
}
排序算法-Shell排序
// Shell排序
public static void shellSort(int[] source, int index) {
int i, j, k; // 循环计数变量
int temp; // 暂存变量
boolean change; // 数据是否变化
int dataLength; // 分隔集合的间隔长度
int pointer; // 进行处理的位置
dataLength = index / 2; // 初始集合间隔长度
while (dataLength != 0) { // 数列仍可进行分隔
// 对每个集合进行处理
for (j = dataLength; j < index; j++) {
change = false;
temp = source[j]; // 暂存data[j]的值,待交换值时用
pointer = j - dataLength; // 计算进行处理的位置
// 进行集合内数值的比较
while (temp < source[pointer] && pointer >= 0 && pointer <= index) {
source[pointer + dataLength] = source[pointer];
// 计算下一个欲进行处理的位置
pointer = pointer - dataLength;
change = true;
if (pointer < 0 || pointer > index)
break;
}
// 于最后的数值交换
source[pointer + dataLength] = temp;
if (change) {
// 打印目前排序结果
System.out.print("排序中:");
for (k = 0; k < index; k++)
System.out.printf(" %3s ", source[k]);
System.out.println("");
}
}
dataLength = dataLength / 2; //计算下次分割的间隔长度
}
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
shellSort(a, a.length);
print(a);
}
排序算法-二分排序:
// 二分排序 查找
public static int binarySearch(int[] a, int value) {
int size = a.length;
int low = 0, high = size - 1;
int mid;
while (low <= high) {
mid = (low + high) / 2;
if (a[mid] < value) {
low = low + 1;
} else if (a[mid] > value) {
high = high - 1;
} else {
return mid;
}
}
return -1;
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
shellSort(a, a.length);
System.out.println(binarySearch(a,4));
}
排序算法-快速排序
// 快速排序
public static void quickSort(int[] source, int low, int high) {
int i, j, x;
if (low < high) {
i = low;
j = high;
x = source[i];
while (i < j) {
while (i < j && source[j] > x) {
j--;
}
if (i < j) {
source[i] = source[j];
i++;
}
while (i < j && source[i] < x) {
i++;
}
if (i < j) {
source[j] = source[i];
j--;
}
}
source[i] = x;
quickSort(source, low, i - 1);
quickSort(source, i + 1, high);
}
}
public static void main(String[] args) {
int[] a = {4,2,1,6,3,6,0,-5,1,1};
quickSort(a, 0, a.length - 1);
print(a);
}