声明:该文章为个人学习笔记,非完全原创
总结一下各种经典排序算法,这个也算面试常考的东西了,总结出来方便大家回忆回忆,今天还要弄项目,先写到快排,剩下的过几天再写。
一、冒泡排序
1.介绍
基于比较的排序算法,最简单,性能差,即使最好情况时间复杂度也是O(n^2),(可以加一个附加标记改进算法,j),原地排序
2.过程
- 比较相邻的元素。如果第一个比第二个大,就交换他们两个。
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最大的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
3.例题
对于一个int数组,请编写一个冒泡排序算法,对数组元素排序。
给定一个int数组A及数组的大小n,请返回排序后的数组。
测试样例:
[1,2,3,5,2,3],6
[1,2,2,3,3,5]
代码(改良算法,增加了一个标记,当发现序列已经是有序的时直接跳出循环):
import java.util.*;
public class BubbleSort {
public int[] bubbleSort(int[] A, int n) {
// write code here
int temp;
int tag=0;
for(int i =n;i>1;i--){
for(int j = 0;jA[j+1]){
tag=1;
temp=A[j];
A[j]=A[j+1];
A[j+1]=temp;
}
}
if(tag==0)
break;
tag=0;
}
return A;
}
}
二、选择排序
1.介绍
常用于数值大键值小的小文件。优点是容易实现,不需要额外空间。
2.过程
寻找序列中最小值-》交换-》对所有元素重复
最好最坏平均时间复杂度都是O(n^2)
由于在CPU中交换比比较所需时间多,选择排序比较多,但和冒泡排序比,交换次数少,所以更快。不稳定性(相同键值的数据可能顺序会变)
3.代码
public class SelectionSort {
public int[] selectionSort(int[] A, int n) {
for(int i=0;iA[j+1]){
int tmp=A[j];
A[j] = A[j+1];
A[j+1] =tmp;
}
}
return A;
}
}
三、插入排序
1.介绍
一种简单有效的比较排序算法。
优点:实现简单,数据量少时效率高,虽然最坏情况时间复杂度也是O(n^2),但实际运行效率优于前两者(平均比较n²/2,交换n²/4次,最坏情况加倍),稳定性,原地(额外空间O(1)),即时。适合数据几乎都已经排序或输入规模较小时使用。最好情况O(n),对于部分有序的输入来说几乎就是线性排序(如果每个元素调整距离最大为k,即可令序列有序,且k相对序列长度很小,此时可认为几乎有序,此时时间复杂度O(kn))。
public class InsertionSort {
public int[] insertionSort(int[] A, int n) {
int i, j, temp;
for(i = 1; i < n; i++){
temp = A[i];
for(j = i; j > 0 && A[j - 1] > temp; j-- ){
A[j] = A[j - 1];
}
A[j] = temp;
}
return A;
}
}
上述三个算法都是O(n^2)级别算法,下面介绍O(n*logn)级别算法
四、归并排序
时间复杂度最好最坏平均都是O(nlogn),但是空间复杂度O(n),稳定。网上有文章说可以把空间复杂度优化到O(1),但是会牺牲时间效率。其实算法优化也是一种时间和空间的权衡,用空间换时间或用时间换空间。
归并排序使用分治思想,是建立在归并操作(merge)上的一种有效的排序算法。注意下面代码中归并操作的做法,有一些题可能不是归并排序,但是利用归并操作的这个思想可以很好的解决。
大致过程如下:
将待排序序列R[0...n-1]看成是n个长度为1的有序序列,将相邻的有序表成对归并,得到n/2个长度为2的有序表;将这些有序序列再次归并,得到n/4个长度为4的有序序列;如此反复进行下去,最后得到一个长度为n的有序序列。即先把数组分解成n个小序列,再两两组合(二路归并),要求组合后的新序列在序列内有序。
与快排相似,也是通过递归实现。不过是先递归(分解),再归并(组合)。归并过程为:
我们每次从两个列表开头元素选取较小的一个,直到某一个列表到达底部,再将另一个剩下部分顺序取出。看代码更好理解。下面上代码:
import java.util.*;
public class MergeSort {
public int[] mergeSort(int[] A, int n) {
sort(A,0,n-1);
return A;
}
//分割数组
public void sort(int[] A,int l,int r){
if(l
五、快排
基于比较的著名排序算法,是分治的一个实例,计算复杂度需要用分治法主定理。
1.算法:
a,如果数组中仅有一个元素或没有元素需要排序,则返回(递归返回条件)
b,选择一个元素作枢轴(pivot),把数组分为,小于pivot的元素,大于的两部分(划分)
c,对两部分递归调用该算法。(递归)
2.性能
时间复杂度与上面的相比最好,平均O(nlogn);最坏O(n²)(发生在数组已排序且选最后一个元素作枢轴的情况)。空间复杂度O(logn)~O(n²),因为是递归算法,需要利用栈空间保存。不稳定(可举例证明)。
3.枢轴的选择和优化
a、若选择数组最左边或最右边的元素作枢轴,可能由于非均衡划分导致快排最坏情况发生,所以不好。
b、随机选择枢轴元素可以保证每个元素被选中概率相等,确保划分在平均情况下均衡,防止最坏情况发生。
c、随机选枢轴只是令划分在平均情况下均衡。换句话说就是减小了最坏情况发生的概率,但实际上最坏情况时间复杂度还是O(n²)。我们可以想到如果能每次选所有元素的中位数作为枢轴,就能保证每次划分都是均衡的。但显然这样做是不可能的,因为寻找数组所有元素的中位数的时间开销太大了。一个常用的方法是从数组中随机选择3个元素,取其中位数作为枢轴。
4.代码
import java.util.*;
public class QuickSort {
public int[] quickSort(int[] A, int n) {
// write code here
sort(A,0,n-1);
return A;
}
void sort(int[] A,int l,int r){
int pivot;
if(l
六、希尔排序
希尔排序,又叫缩小增量排序(看到后面你就知道为什么这么叫了),由Donnald Shell提出而得名。是个不稳定算法(不理解的话可以举个例子)。
该算法本质上就是一个泛化的插入排序,可以视作直接插入排序的改良。因为插入排序在序列几乎有序时效率很高,希尔排序通过先将整个待排元素序列分割成若干个子序列(由相隔某个“增量”的元素组成的)分别进行直接插入排序,然后依次缩减增量再进行排序,待整个序列中的元素基本有序(增量足够小)时,再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下(接近最好情况),效率是很高的。
希尔排序最好情况时间复杂度为O(n),平均和最坏情况复杂度取决于步长序列(增量序列)的选择。希尔排序最重要的也是步长选择这一步。
Donald Shell 最初建议步长选择为n/2,并且对步长取半直到步长达到 1。虽然这样取可以比O(n^2)类的算法(插入排序)更好,但这样仍然有减少平均时间和最差时间的余地。 可能希尔排序最重要的地方在于当用较小步长排序后,以前用的较大步长仍然是有序的。
| 步长序列 | 最坏情况时间复杂度 |
| ------------- |:-------------:| -----:|
| n/(2^i) | O(n²) |
| 2i*3i | O(nlog²n) |
已知的最好步长序列由Marcin Ciura设计(1,4,10,23,57,132,301,701,1750,…) 这项研究也表明“比较在希尔排序中是最主要的操作,而不是交换。”用这样步长序列的希尔排序比插入排序和堆排序都要快,甚至在小数组中比快速排序还快,但是在涉及大量数据时希尔排序还是比快速排序慢。
另一个在大数组中表现优异的步长序列是(斐波那契数列除去0和1将剩余的数以黄金分割比的两倍的幂进行运算得到的数列):(1, 9, 34, 182, 836, 4025, 19001, 90358, 428481, 2034035, 9651787, 45806244, 217378076, 1031612713, …)
代码(步长选择n/(2^i)):
import java.util.*;
public class ShellSort {
public int[] shellSort(int[] A, int n) {
int h,i,j,temp;
for(h=n/2;h>=1;h=h/2){
for(i=h;i=h&&A[j-h]>temp;){
A[j]=A[j-h];
j=j-h;
}
A[j]=temp;
}
}
return A;
}
}