数据结构与算法:基于比较的排序算法:选择、冒泡、插入、归并的动图演示和java代码,排序时间复杂度、空间复杂度、稳定性总结表格

选择排序

选择排序是先在0~N-1上选择一个最小值排到最前面,然后再在1到N-1上选一个次小的,以此类推。

public static selectionSort(int[] arr){
	if(arr==null||arr.length<2){
		return;
	}
//每次从i n-1 选一个最小的放前面
	for(int i=0;i<=arr.length-2;i++){
		int minIdx = i;
		for(int j=i+1;j<=arr.length-1;j++){
			if(arr[minIdx]>arr[j]) minIdx=j;
		}
		swap(arr,i,minIdx);
	}
}

public static void swap(int[] arr,int i,int j){
	if(i==j) return;
	arr[i]=arr[i]^arr[j];
	arr[j]=arr[i]^arr[j];
	arr[i]=arr[i]^arr[j];
}

冒泡排序

public static selectionSort(int[] arr){
	if(arr==null||arr.length<2){
		return;
	}
//每次遍历0 i
	for(int i=arr.length-1;i>=1;i--){
		for(int j=0;j<i;j++){
			if(arr[j+1]>arr[j]) swap(arr,j,j+1);
		}
	}
}

public static void swap(int[] arr,int i,int j){
	if(i==j) return;
	arr[i]=arr[i]^arr[j];
	arr[j]=arr[i]^arr[j];
	arr[i]=arr[i]^arr[j];
}

插入排序

插入排序是先让0到1变得有序,然后让0到2变得有序,以此类推。

public static void insertionSort(int[] arr){
	if(arr==null||arr.length<2){
		return;
	}
	//0~0 已经有序
	//0~i 想变有序
	for(int i=1;i<arr.length;i++){
		for(int j=i-1;j>=0&&arr[j]>arr[j+1];j--){
			swap(arr,j,j+1);
		}
	}
}

public static void swap(int[] arr, int i, int j){
	if(i==j) return;
	arr[i]=arr[i]^arr[j];
	arr[j]=arr[i]^arr[j];
	arr[i]=arr[i]^arr[j];
}

归并排序

public static void mergeSort(int[] arr){
	process(arr,0,arr.length-1);
}

public static void process(int[] arr,int L,int R){
	if(L==R) return;
	int mid=L+(R-L)>>1;
	process(arr,L,mid);
	process(arr,mid+1,R);
	merge(arr,L,mid,R);
}
public static void merge(int[] arr,int L,int mid,int R){
	int[] temp=new int[R-L+1];
	int i=0;
	int p1=L;
	int p2=R;
	while(p1<=mid&&p2<=R){
		if(arr[p1]<arr[p2]) temp[i++]=arr[p1++];
		else temp[i++]=arr[p2++];
	}
	while(p1<=mid) temp[i++]=arr[p1++];
	while(p2<=R) temp[i++]=arr[p2++];
	for(i=0;i<temp.length;i++){
		arr[L+i]=temp[i++];
	}
}

时间复杂度,用Master主定理算出来是O(N*logN),空间复杂度为O(N)

稳定性

定义

一个排序算法具有稳定性的意思是在排序相同值数据的前后,数据之间的相对顺序不变。
譬如我现在有一个待排序列:3 3 1
那么前两个3是值相等的,我们现在给这个待排序列打上标记:3① 3② 1
排完序后这个序列依旧是3①在3②的左边,那么我们就称这个排序算法具有稳定性。

应用场景

要求稳定性的场景一般是多条件排序,我们需要保留前几轮排序的相对顺序。
譬如一个商品排行榜的比较标准为:质量分高的在前,质量分相同的话看价格,价格低对的在前。这时候我们就需要具有稳定性的算法,因为相当于有两轮条件比较,质量分和价格。我们在比较价格时需要保证质量分排序的相对顺序不变。
体现在数据结构中就是,一般自定义的,复杂的数据结构才需要稳定性的存在。

基于比较的排序对比总结

目前在基于比较的排序算法中,没有找到时间复杂度为O(N*logN) ,空间复杂度为O(1),又稳定的排序。

面试版

以下稳定性为√的意思是该算法可以实现成稳定性的,要看具体的实现逻辑。
但是为×的就是一般情况下该算法是无法实现成稳定性的(但如果)。
且快排是基于随机数实现的快排。

算法 时间复杂度 空间复杂度 稳定性
选择 O(N^2) O(1) ×
冒泡 O(N^2) O(1)
插入 O(N^2) O(1)
归并 O(N*logN) O(N)
快排 O(N*logN) O(logN) ×
O(N*logN) O(1) ×

各个排序算法关于稳定性的细节

一般只要是跨多个值交换位置的算法,就会丧失稳定性。

选择排序

选择排序是先在0~N-1上选择一个最小值排到最前面,然后再在1到N-1上选一个次小的,以此类推。
这种跨多个值交换位置的,很明显没有稳定性。譬如序列:3① 3② 1 3③
最终会变为:1 3② 3① 3③

冒泡排序

因为是相邻位置交换,所以具有稳定性

插入排序

插入排序是先让0到1变得有序,然后让0到2变得有序,以此类推。
那么我们只需要在遍历当前数并往前比较时,碰到一样的不交换,即可保证稳定性。

归并排序

归并排序是先让小区间变得有序,然后合并成大区间。
我们只需要在合并时,左右区间是相等的数,先取左那么就可保证稳定性。

快速排序

快速排序的两个版本,第一个版本是,通过选择一个基准值,将数组分割成两个区,一个区小于等于基准值,一个区大于基准值。然后递归地对两区进行快速排序。
第二个版本是,通过选择一个基准值,将数组分割成三个区,一个区小于基准值,一个区等于基准值,一个区大于基准值。然后递归地对三区进行快速排序。

如果是第一个版本,当遍历到小于等于基准值的数时,就要和小于等于区的下一个数做交换。这一般也是跨多个值进行交换的,所以没有稳定性。
如果是第二个版本,当遍历到小于基准值的数时,就要和小于区的下一个数做交换。这一般也是跨多个值进行交换的,所以没有稳定性。

堆排序

堆排序更不用说,从始至终所有步骤都不能保证稳定性。

详细版

数据结构与算法:基于比较的排序算法:选择、冒泡、插入、归并的动图演示和java代码,排序时间复杂度、空间复杂度、稳定性总结表格_第1张图片

排序算法的优化

归并算法可以利用内部缓存法将空间复杂度优化为O(1),但是代码实现过于复杂,不建议掌握。
同时“原地归并排序”也可以将空间复杂度优化为O(1),但是时间复杂度就变为O(N^2)了。
快速排序可以实现稳定性,但是代码实现过于复杂,不建议掌握。
总而言之,不用去考虑太多这些主流版本之外的优化版本。

工程上对于排序算法的改进

在项目或者工程中一般会考虑以下两点:1、样本量小和大。2、是否需要稳定性
譬如样本量小时,时间复杂度上O(N^2)和O(N*logN)区别不大,但O(N平方)算法的空间复杂度几乎都为O(1),所以小样本其实应该用选择排序、冒泡排序、插入排序等算法。

同时,

本篇文章看不懂的可以去看视频,因为本篇文章是基于此视频做的总结和扩充笔记:https://www.bilibili.com/video/BV13g41157hK?p=6

你可能感兴趣的:(排序算法,java,算法,后端,数据结构)