几种排序算法的时间复杂度和空间复杂度

一. 快速排序

参考自:https://blog.csdn.net/A_BlackMoon/article/details/81064712

  1. 快速排序最好的情况下:每次平分子数组,时间复杂度为Nlog2N, 空间复杂度主要为递归调用的开销,为log2N
  2. 快速排序最差的情况下,每次两个子数组的大小都为1,n-1,意味着退化为冒泡排序,时间复杂度为N^2,空间复杂度为N。

二. 冒泡排序

参考 https://blog.csdn.net/weixin_43419883/article/details/88418730

时间复杂度

这个时间复杂度还是很好计算的:外循环和内循环以及判断和交换元素的时间开销;

  1. 最优的情况也就是开始就已经排序好序了,那么就可以不用交换元素了,则时间花销为:((n-1)+(n-2)+……2+1)= [ n(n-1) ] / 2;所以最优的情况时间复杂度为:O( n^2 );

  2. 最差的情况也就是开始的时候元素是逆序的,那么每一次排序都要交换两个元素,则时间花销为:[ 3n(n-1) ] / 2;(其中比上面最优的情况所花的时间就是在于交换元素的三个步骤);所以最差的情况下时间复杂度为:O( n^2 );

  3. **最优的时间复杂度为:O( n^2 ) ;

  4. 最差的时间复杂度为:O( n^2 );

  5. 平均的时间复杂度为:O( n^2 );**

空间复杂度

空间复杂度就是在交换元素时那个临时变量所占的内存空间;

  1. 最优的空间复杂度就是开始元素顺序已经排好了,则空间复杂度为:0;
  2. 最差的空间复杂度就是开始元素逆序排序了,则空间复杂度为:O(n);
  3. 平均的空间复杂度为:O(1);
  • 0
    点赞
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
下面是常用的几种排序算法的Python实现,以及它们的时间复杂度空间复杂度评估: 1. 冒泡排序 ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] return arr ``` 时间复杂度:$O(n^2)$,空间复杂度:$O(1)$ 2. 插入排序 ```python def insertion_sort(arr): n = len(arr) for i in range(1, n): key = arr[i] j = i - 1 while j >= 0 and key < arr[j]: arr[j+1] = arr[j] j -= 1 arr[j+1] = key return arr ``` 时间复杂度:$O(n^2)$,空间复杂度:$O(1)$ 3. 选择排序 ```python def selection_sort(arr): n = len(arr) for i in range(n): min_idx = i for j in range(i+1, n): if arr[j] < arr[min_idx]: min_idx = j arr[i], arr[min_idx] = arr[min_idx], arr[i] return arr ``` 时间复杂度:$O(n^2)$,空间复杂度:$O(1)$ 4. 快速排序 ```python def quick_sort(arr): if len(arr) <= 1: return arr pivot = arr[0] left = [x for x in arr[1:] if x < pivot] right = [x for x in arr[1:] if x >= pivot] return quick_sort(left) + [pivot] + quick_sort(right) ``` 时间复杂度:$O(n\log n)$,空间复杂度:$O(n)$ 5. 归并排序 ```python def merge_sort(arr): if len(arr) <= 1: return arr mid = len(arr) // 2 left = merge_sort(arr[:mid]) right = merge_sort(arr[mid:]) return merge(left, right) def merge(left, right): res = [] i, j = 0, 0 while i < len(left) and j < len(right): if left[i] <= right[j]: res.append(left[i]) i += 1 else: res.append(right[j]) j += 1 res += left[i:] res += right[j:] return res ``` 时间复杂度:$O(n\log n)$,空间复杂度:$O(n)$ 6. 堆排序 ```python def heap_sort(arr): n = len(arr) for i in range(n//2-1, -1, -1): heapify(arr, n, i) for i in range(n-1, 0, -1): arr[i], arr[0] = arr[0], arr[i] heapify(arr, i, 0) return arr def heapify(arr, n, i): largest = i l = 2 * i + 1 r = 2 * i + 2 if l < n and arr[l] > arr[largest]: largest = l if r < n and arr[r] > arr[largest]: largest = r if largest != i: arr[i], arr[largest] = arr[largest], arr[i] heapify(arr, n, largest) ``` 时间复杂度:$O(n\log n)$,空间复杂度:$O(1)$
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值