常用排序算法总结+源代码

最新推荐文章于 2024-05-08 16:49:45 发布

那一团耀眼的火焰

最新推荐文章于 2024-05-08 16:49:45 发布

阅读量257

点赞数

分类专栏： Algorithm 文章标签：排序算法

本文链接：https://blog.csdn.net/Nujabes/article/details/106202347

版权

Algorithm 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

排序

稳定性：排序前后具有相同关键字的记录的相对顺序不发生改变，则该排序算法是稳定的
适用性：排序算法适用于顺序存储结构还是链式存储结构

1.选择排序

首先，找到数组中最小的那个元素，其次，将它和数组的第一个元素交换位置（如果第一个元素就是最小的元素那么它就和自己交换）。再次，在剩下的元素中找到最小的元素，将它于数组的第二个元素交换位置。如此往复，直到整个数组排序。
对于长度为N的数组，选择排序需要大约n(n-1)/2次比较和n次交换
时间复杂度与初始顺序无关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定

public class Selection {
    public static void sort(Comparable[] a){
        int N = a.length;
        for(int i=0;i<N;i++){
            int min = i;
            for(int j=i+1;j<N;j++){
                if(less(a[j],a[min])) min=j;
            }
            exch(a,i,min);
        }
    }
}

2.插入排序

一个一个元素的来，将每一个元素插入到其他已经有序的元素中的适当位置。
对于随机排列的长度为N的主键不重复的数组，平均情况下插入排序需要n(n-1)/4次比较和n(n-1)/4交换
时间复杂度与初始顺序有关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n^2)	O(n)	O(n^2)	O(1)	稳定

public class Insertion{
	public static void sort(Comparable[] a){
		int N = a.length;
		for(int i=1;i<n;i++){
			for(int j=i;j>0&&less(a[j],a[j-1]);j--){
				exch(a,j,j-1);
			}
		}
	}
}

3.希尔排序

插入排序的改进，交换不相邻的元素以对数组的局部进行排序，并最终用插入排序将局部有序的数组排序
时间复杂度与初始顺序有关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n^1.3)	O(n)	O(n^2)	O(1)	不稳定

public class Shell{
	public static void sort(Comparable[] a){
		int N = a.length;
		int h = 1;
		while(h<N/3) h=h*3+1;
		while(h>=1){
			for(int i=h;i<N;i++){
				for(int j=i;j>=h&&less(a[j],a[j-h]);j-=h){
					exch(a,j,j-h);
				}
			}
			h/=3;
		}
	}
}

4.冒泡排序

对元素依次进行两两比较，将较大的元素放后面，这样每次循环都能将一个较大的元素放在数组最后，经历n-1次循环数组变为有序状态
对于一个长度为N的数组，平均情况下冒泡排序需要进行n(n-1)/2次比较和n(n-1)/4次交换
时间复杂度与初始排序有关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(n^2)	O(n)	O(n^2)	O(1)	稳定

public class Bubble{
	public static void sort(Comparable[] a){
		int N = a.length;
		boolean flag = false;
		for(int i=0;i<N;i++){
			for(int j=0;j<N-1-i;j++){
				if(less(a[j+1],a[j])){exch(a,j,j+1);flag=true;}
			}
			if(!flag) break;
			flag = false;
		}
	}
}

5.归并排序

采用分治法，先使每个子序列有序，再使子序列段间有序
对于一个长度为N的数组，平均情况下归并排序需要进行(nlog2n)/2次比较
时间复杂度与初始排序无关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定

public class Merge{
	private static Comparable[] aux;
	public static void sort(Comparable[] a){
		aux = new Comparable[a.length];
		sort(a,0,a.length-1);
	}
	private static void sort(Comparable[] a,int lo,int hi){
		if(lo>=hi) return;
		int mid = (lo+hi)/2;
		sort(a,lo,mid);
		sort(a,mid+1,hi);
		merge(a,lo,mid,hi);
	}
	private static void merge(Comparable[] a,int lo,int mid,int hi){
		for(int i=lo;i<=hi;i++){aux[i]=a[i];}
		int i,j,k;
		for(k=lo,i=lo,j=mid+1;i<=mid&&j<=hi;){
			if(lessOrEqual(aux[i],aux[j])) a[k++]=aux[i++];
			else a[k++]=aux[j++];
		}
		while(i<=mid){a[k++]=aux[i++];}
		while(j<=hi){a[k++]=aux[j++];}
	}
	private static boolean lessOrEqual(Comparable v,Comparable w){return v.compareTo(w)<=0;}
}

6.快速排序

采用分治法，将一个数组分成两个子数组，将两部分独立地排序，重复上述步骤
对于一个长度为N的数组，平均情况下快速排序需要进行nlog2n次比较
时间复杂度与初始排序有关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	最好空间复杂度	最坏空间复杂度	稳定性
O(nlog2n)	O(nlog2n)	O(n^2)	O(log2n)	O(n)	不稳定

public class Quick{
    public static void sort(Comparable[] a,int lo,int hi){
        if(lo>=hi) return;
        int j = partition(a,lo,hi);
        sort(a,lo,j-1);
        sort(a,j+1,hi);
    }
    private static int partition(Comparable[] a,int lo,int hi){
        int i=lo,j=hi+1;
        Comparable stan = a[lo];
        while(true){
            while(less(a[++i],stan)) if(i>=hi) break;
            while(less(stan,a[--j])) if(j<=lo) break;
            if(i>=j) break;
            exch(a,i,j);
        }
        exch(a,j,lo);
        return j;
    }
    private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}
    private static void exch(Comparable[] a,int i,int j){Comparable temp=a[i];a[i]=a[j];a[j]=temp;}
}

7.堆排序

将待排序列组成一个大顶堆，不断将根节点与最后一个节点交换然后重新排序，就能得到有序序列
时间复杂度与初始排序无关

平均时间复杂度	最好时间复杂度	最坏时间复杂度	空间复杂度	稳定性
O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定

public class Heap {
    public static void sort(Comparable[] a){
        int N = a.length;
        for(int i=N/2-1;i>=0;i--){sink(a,i,N);}
        for(int j=N-1;j>0;j--){
            exch(a,j,0);
            sink(a,0,j);
        }
    }
    private static void sink(Comparable[] a,int i,int N){
        Comparable temp = a[i];
        for(int k=i*2+1;k<N;k=k*2+1){
            if(k+1<N-1&&less(a[k],a[k+1])) k++;
            if(less(temp,a[k])){exch(a,i,k);i=k;}
            else break;
        }
        a[i] = temp;
    }
    private static void exch(Comparable[] a,int i,int j){Comparable temp=a[i];a[i]=a[j];a[j]=temp;}
    private static boolean less(Comparable v,Comparable w){return v.compareTo(w)<0;}
}