排序就是将一组对象按照某种逻辑顺序重新排列的过程,在数据处理和科学计算中有着重要的作用,下文将会对一些常见的算法进行分析并给出实现(Java):
算法 | 是否稳定 | 原地排序 | 时间复杂度 | 空间复杂度 | |
---|---|---|---|---|---|
冒泡排序 | 稳定 | 是 | N^2 | 1 | |
插入排序 | 是 | 是 | 介于N和N^2之间 | 1 | |
选择排序 | 否 | 是 | N^2 | 1 | |
希尔排序 | 否 | 是 | 大致NlogN | 1 | |
归并排序 | 是 | 否 | NlogN | N | |
快速排序 | 否 | 是 | NlogN | lgN |
1·冒泡排序:
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列,一次比较两个元素,如果它们的顺序错误就把它们交换过 来。走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢“浮”到数列的顶端。
public int[] sort(int[] nums){
int length=nums.length;
for(int i=0;i<length-1;i++){
for(int j=0;j<length-1;j++){
int temp=nums[j+1];
nums[j+1]=nums[j];
nums[j]=temp;
}
}
return nums;
}
2·选择排序:
选择排序的思想:首先找到数组中最小的元素,其次,将它和数组的第一个元素交换位置;再次,在剩下的元素中找到最小的元素,将它与数组的第二个元素交换位置,如此循环往复。
//不断寻找最小的元素,排在数组的前端
public void sort(int[] a){
int n=a.length;
for(int i=0;i<n;i++){
int min=i;
for(int j=i+1;j<n;j++){
if(a[j]<a[min]){
min=j;
}
}
int temp=a[i];
a[i]=a[min];
a[min]=temp;
}
}
3·插入排序:
插入排序的思想与整理扑克牌类似,将一张张扑克牌查到对应的位置;与选择排序一样,当前索引左边的元素顺序是确定的,但它们的最终位置还没有确定,当索引到达数组右端时,排序完成。
//假定数组前端已排序,将未排序的第一个元素插入到已排序数组的对应位置
public void sort(int[] a){
int N=a.length;
for(int i=1;i<N;i++){
for(int j=i;j>0&&a[j]<a[j-1];j--){
int temp=a[j-1];
a[j-1]=a[j];
a[j]=temp;
}
}
}
4·希尔排序:
希尔排序是在插入排序之上的改进,希尔排序通过交换不相邻的元素以对数组的局部进行排序,并最终用插入排序将局部有序的数组排序;希尔排序的思想是使数组中任意间隔为h的元素都是有序的。
public void sort(int[] a){
int N=a.length;
int h=1;
while(h<N/3){
h=3*h+1;
}
while(h>=1){
//将数组变为h有序
for(int i=h;i<N;i++){
for(int j=i;j>=h && a[i]<a[j-h];j=j-h){
int temp=a[j-h];
a[j-h]=a[j];
a[j]=temp;
}
}
h=h/3;
}
}
5·归并排序:
归并排序基于递归实现,其思想是将一个数组分成两半分别排序,然后将结果归并起来;它的优点在于能够保证将任意长度为N的数组排序所需时间和NlogN成正比,缺点是学要额外的存储空间。
package Rank;
public class MergeSort {
private static int[] aux;
public static void sort(int[] a){
aux=new int[a.length];
sort(a,0,a.length-1);
}
//基于递归的思想归并数组
public static void sort(int[] a,int lo,int hi){
if(hi<=lo){
return;
}
int mid=lo+(hi-lo)/2;
sort(a,lo,mid);
sort(a,mid+1,hi);
merge(a,lo,mid,hi);
}
//将子数组a[lo,mid]和a[mid+1,hi]归并成一个有序的数组
public static void merge(int[] a,int lo,int mid,int hi){
int i=lo,j=mid+1;
for(int k=lo;k<=hi;k++){
aux[k]=a[k];
}
//四个条件判断(左半边用尽,右半边用尽,右当前元素小于左当前元素,右当前元素大于左当前元素)
for(int k=lo;k<=hi;k++){
if(i>mid){
a[k]=aux[j++];
}else if(j>hi){
a[k]=aux[i++];
}else if(aux[j]<(aux[i])){
a[k]=aux[j++];
}else{
a[k]=aux[i++];
}
}
}
}
6·快速排序:
快速排序可能是应用最广的算法,它将一个数组分为两个子数组,将两部分独立地排序;快速排序和归并排序是互补的,它的优点是将长度为N的数组排序所需时间和NlgN成正比,并且它是原地排序(只需一个很小的辅助栈)。快速排序在数组较小时比插入排序慢,因此对于小数组,可优先采用插入排序。
package Rank;
public class QuickSort {
public static void sort(int[] a){
sort(a,0,a.length-1);
}
//将数组切分为两个子数组,分别排序
public static void sort(int[] a,int lo,int hi){
if(hi<=lo){
return;
}
int j=partion(a,lo,hi);
sort(a,lo,j-1);
sort(a,j+1,hi);
}
/*切分函数,将数组切分为两部分,左端都比选择数小,
右端都比选择数大,这里以数组的第一个元素作为切分点,将数组分为两个部分*/
private static int partion(int[] a,int lo,int hi){
int i=lo,j=hi+1;
int v=a[lo];
//从左开始扫描大于切分点元素,从右开始扫描小于切分点元素,将找到的元素交换位置
while (true){
while(a[++i]<v){
if(i==hi){
break;
}
}
while(v<=a[--j]){
if(j==lo){
break;
}
}
if(i>=j){
break;
}
int temp=a[j];
a[j]=a[i];
a[i]=temp;
}
//将切分标准元素放入正确的位置
int temp=a[j];
a[j]=a[lo];
a[lo]=temp;
return j;
}
}