排序问题

最新推荐文章于 2023-08-24 09:48:29 发布

梦世

最新推荐文章于 2023-08-24 09:48:29 发布

阅读量2.4k

点赞数 1

分类专栏：数据结构与刷题

本文链接：https://blog.csdn.net/qq_34949782/article/details/107129361

版权

数据结构与刷题专栏收录该内容

18 篇文章 0 订阅

订阅专栏

衡量一个排序算法的优劣，主要会从以下 3 个角度进行分析：

1．时间复杂度，具体包括，最好时间复杂度、最坏时间复杂度以及平均时间复杂度。

2．空间复杂度，如果空间复杂度为 1，也叫作原地排序。

3．稳定性，排序的稳定性是指相等的数据对象，在排序之后，顺序是否能保证不变。

冒泡排序

从第一个数据开始，依次比较相邻元素的大小。如果前者大于后者，则进行交换操作，把大的元素往后交换。通过多轮迭代，直到没有交换操作为止。

冒泡排序最好时间复杂度是 O(n)，也就是当输入数组刚好是顺序的时候，只需要挨个比较一遍就行了，不需要做交换操作，所以时间复杂度为 O(n)。

冒泡排序最坏时间复杂度会比较惨，是 O(n*n)。也就是说当数组刚好是完全逆序的时候，每轮排序都需要挨个比较 n 次，并且重复 n 次，所以时间复杂度为 O(n*n)。

很显然，当输入数组杂乱无章时，它的平均时间复杂度也是 O(n*n)。

冒泡排序不需要额外的空间，所以空间复杂度是 O(1)。冒泡排序过程中，当元素相同时不做交换，所以冒泡排序是稳定的排序算法。

插入排序

选取未排序的元素，插入到已排序区间的合适位置，直到未排序区间为空。插入排序顾名思义，就是从左到右维护一个已经排好序的序列。直到所有的待排数据全都完成插入的动作。

插入排序最好时间复杂度是 O(n)，即当数组刚好是完全顺序时，每次只用比较一次就能找到正确的位置。这个过程重复 n 次，就可以清空未排序区间。

插入排序最坏时间复杂度则需要 O(n*n)。即当数组刚好是完全逆序时，每次都要比较 n 次才能找到正确位置。这个过程重复 n 次，就可以清空未排序区间，所以最坏时间复杂度为 O(n*n)。

插入排序的平均时间复杂度是 O(n*n)。这是因为往数组中插入一个元素的平均时间复杂度为 O(n)，而插入排序可以理解为重复 n 次的数组插入操作，所以平均时间复杂度为 O(n*n)。

插入排序不需要开辟额外的空间，所以空间复杂度是 O(1)。插入排序是稳定的排序算法。

归并排序

归并排序的原理其实就是的分治法。它首先将数组不断地二分，直到最后每个部分只包含 1 个数据。然后再对每个部分分别进行排序，最后将排序好的相邻的两部分合并在一起，这样整个数组就有序了。

public class Solution {

	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 50 };
		System.out.println("原始数据: " + Arrays.toString(arr));
		mergeSort(arr, 0, arr.length - 1);
		System.out.println("归并排序: " + Arrays.toString(arr));
	}

	public static void mergeSort(int[] nums, int low, int hight) {
		if (low < hight) {
			int mid = (low + hight) / 2;
			mergeSort(nums, low, mid);
			mergeSort(nums, mid + 1, hight);
			merge(nums, low, mid, hight);
		}
	}

	public static void merge(int[] nums, int low, int mid, int hight) {
		int[] temp = new int[hight - low + 1];
		int p1 = low, p2 = mid + 1;
		int k = 0;
		while (p1 <= mid && p2 <= hight) {
			if (nums[p1] < nums[p2]) {
				temp[k++] = nums[p1++] ;
			} else {
				temp[k++] = nums[p2++] ;
			}
		}
		while(p1 <= mid) {
			temp[k++] = nums[p1++];
		}
		while(p2 <= hight) {
			temp[k++] = nums[p2++];
		}
		for( int i = low; i <= hight; i ++) {
			nums[i] = temp[i - low] ;
		}
	}
}

对于归并排序，它采用了二分的迭代方式，复杂度是 logn。

每次的迭代，需要对两个有序数组进行合并，这样的动作在 O(n) 的时间复杂度下就可以完成。因此，**归并排序的复杂度就是二者的乘积 O(nlogn)。**同时，它的执行频次与输入序列无关，因此，归并排序最好、最坏、平均时间复杂度都是 O(nlogn)。

空间复杂度方面，由于每次合并的操作都需要开辟基于数组的临时内存空间，所以空间复杂度为 O(n)。归并排序合并的时候，相同元素的前后顺序不变，所以归并是稳定的排序算法。

快速排序

快速排序法的原理也是分治法。它的每轮迭代，会选取数组中任意一个数据作为分区点，将小于它的元素放在它的左侧，大于它的放在它的右侧。再利用分治思想，继续分别对左右两侧进行同样的操作，直至每个区间缩小为 1，则完成排序。

public class Solution {
	public static void main(String[] args) {
		int[] arr = { 49, 38, 65, 97, 76, 13, 27, 50 };
		System.out.println("原始数据: " + Arrays.toString(arr));
		quickSort(arr, 0, arr.length - 1);
		System.out.println("快速排序: " + Arrays.toString(arr));	
	}
	public static void quickSort(int [] nums , int low, int hight) {
		if( low < hight) {
			int p = partition(nums, low, hight); // p位置上的数已经排好
			quickSort(nums, low, p-1) ;
			quickSort(nums, p+1, hight) ;
		}
	}
	
	public static int partition(int[] nums, int low, int hight ) {
		// 选择最高位作为分割值（基准值）nums[hight]
		int i, j ;
		int temp ; // 交换时用
		for(i = low, j = low; j < hight ; j ++) {
			if(nums[j] <= nums[hight]) { // 当前的值比分割值小，就把它放在i指向的位置，循环完成后，i指向的值都比基准值小
//				swap(nums, i ,j) ;
				temp = nums[i] ;
				nums[i] = nums[j] ;
				nums[j] = temp ;
				i ++ ;
			}
		}
		//swap(nums, i, j); //将放置在末尾的基准值放在指针i的位置
		temp = nums[i] ;
		nums[i] = nums[j] ;
		nums[j] = temp ;
		return i ;
	}
}

在快排的最好时间的复杂度下，如果每次选取分区点时，都能选中中位数，把数组等分成两个，那么此时的时间复杂度和归并一样，都是 O(n*logn)。

而在最坏的时间复杂度下，也就是如果每次分区都选中了最小值或最大值，得到不均等的两组。那么就需要 n 次的分区操作，每次分区平均扫描 n / 2 个元素，此时时间复杂度就退化为 O(n*n) 了。

快速排序法在大部分情况下，统计上是很难选到极端情况的。因此它平均的时间复杂度是 O(n*logn)。

快速排序法的空间方面，使用了交换法，因此空间复杂度为 O(1)。

很显然，快速排序的分区过程涉及交换操作，所以快排是不稳定的排序算法。

LetCode215

class Solution {
        public int findKthLargest(int[] nums, int k) {
            return quickSelect(nums, 0, nums.length - 1, nums.length-k) ;
        }
        public int quickSelect(int [] nums, int low, int high, int k){
            int i, j ;
            for( i = low, j = low; j < high ; j ++) {
                if( nums[j] <= nums[high] ){
                    int temp = nums[i] ; 
                    nums[i] = nums[j] ;
                    nums[j] = temp ;
                    i ++ ;
                }
            }
            int temp  = nums[i] ;
            nums[i] = nums[j] ;
            nums[j] = temp ;
            if(i == k){
                return nums[k] ;
            } else if (i > k){
                return quickSelect(nums, low, i -1, k) ;
            } else {
                return quickSelect(nums, i + 1, high, k) ;
            }

    }
}

堆排序

https://blog.csdn.net/eric_sunah/article/details/103081878

时间复杂度：https://blog.csdn.net/qq_34228570/article/details/80024306/

性能分析

对于 n 个元素的数组，只要重复执行 n 次最大值的查找就能完成排序。因此排序最暴力的方法，时间复杂度是 O(n*n)。这恰如冒泡排序和插入排序。

当我们利用算法思维去解决问题时，就会想到尝试分治法。此时，利用归并排序就能让时间复杂度降低到 O(nlogn)。然而，归并排序需要额外开辟临时空间。一方面是为了保证稳定性，另一方面则是在归并时，由于在数组中插入元素导致了数据挪移的问题。

为了规避因此而带来的时间损耗，此时我们采用快速排序。通过交换操作，可以解决插入元素导致的数据挪移问题，而且降低了不必要的空间开销。但是由于其动态二分的交换数据，导致了由此得出的排序结果并不稳定。

总结

包括冒泡排序、插入排序、归并排序以及快速排序。这些经典算法没有绝对的好和坏，它们各有利弊。在工作过程中，需要你根据实际问题的情况来选择最优的排序算法。

如果对数据规模比较小的数据进行排序，可以选择时间复杂度为 O(n*n) 的排序算法。因为当数据规模小的时候，时间复杂度 O(nlogn) 和 O(n*n) 的区别很小，它们之间仅仅相差几十毫秒，因此对实际的性能影响并不大。

但对数据规模比较大的数据进行排序，就需要选择时间复杂度为 O(nlogn) 的排序算法了。

归并排序的空间复杂度为 O(n)，也就意味着当排序 100M 的数据，就需要 200M 的空间，所以对空间资源消耗会很多。

快速排序在平均时间复杂度为 O(nlogn)，但是如果分区点选择不好的话，最坏的时间复杂度也有可能逼近 O(n*n)。而且快速排序不具备稳定性，这也需要看你所面对的问题是否有稳定性的需求。

拓扑排序

梦世

关注

1
点赞
踩
14

收藏

觉得还不错? 一键收藏
0
评论
排序问题

目录冒泡排序插入排序归并排序快速排序堆排序性能分析总结衡量一个排序算法的优劣，主要会从以下 3 个角度进行分析：1．时间复杂度，具体包括，最好时间复杂度、最坏时间复杂度以及平均时间复杂度。2．空间复杂度，如果空间复杂度为 1，也叫作原地排序。3．稳定性，排序的稳定性是指相等的数据对象，在排序之后，顺序是否能保证不变。冒泡排序从第一个数据开始，依次比较相邻元素的大小。如果前者大于后者，则进行交换操作，把大的元素往后交换。通过多轮迭代，直到没有交换操作
复制链接

扫一扫