写点什么

Python 实现七大排序算法,Python 中高级面试必知必会

作者:程序媛可鸥
  • 2022 年 3 月 19 日
  • 本文字数:2264 字

    阅读完需:约 7 分钟

描述


时间复杂度是 O(n2), 是稳定排序算法。


它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换,也就



是说该数列已经排序完成。


代码实现

-- coding: UTF-8 --

def bubble_sort(lists):

冒泡排序 时间复杂度是 O(n2)

count = len(lists)


for i in range(0, count - 1):


for j in range(0, count - i - 1):


if lists[j] > lists[j + 1]:


lists[j], lists[j + 1] = lists[j + 1], lists[j]


return lists


if name == "main":


test = [2, 5, 4, 6, 7, 3, 2]


print(bubble_sort(test))


快速排序




描述


快速排序的时间复杂度是 O(n log n), 是不稳定排序算法。


通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。


代码实现

-- coding: UTF-8 --

def quick_sort(lists, left, right):

快速排序 时间复杂度是 O(n log n)

if left >= right:


return lists


key = lists[left]


low = left


high = right


while left < right:


while left < right and lists[right] >= key:


right -= 1


lists[left] = lists[right]


while left < right and lists[left] <= key:


left += 1


lists[right] = lists[left]


lists[right] = key


quick_sort(lists, low, left - 1)


quick_sort(lists, left + 1, high)


return lists


if name == "main":


test = [2, 5, 4, 6, 7, 3, 2]


print(quick_sort(test, 0, len(test) - 1))


直接选择排序




描述


选择排序的时间复杂度是 O(n2), 是不稳定排序算法。


基本思想:第 1 趟,在待排序记录 r1 ~ r[n] 中选出最小的记录,将它与 r1 交换;第 2 趟,在待排序记录 r2 ~ r[n] 中选出最小的记录,将它与 r2 交换;以此类推,第 i 趟在待排序记录 r[i] ~ r[n] 中选出最小的记录,将它与 r[i] 交换,使有序序列不断增长直到全部排序完毕。


代码实现

-- coding: UTF-8 --

def select_sort(lists):

选择排序 时间复杂度是 O(n2)

count = len(lists)


for i in range(0, count):


min = i


for j in range(i + 1, count):


if lists[min] > lists[j]:


min = j


lists[min], lists[i] = lists[i], lists[min]


return lists


if name == "main":


test = [2, 5, 4, 6, 7, 3, 2]


print(select_sort(test))


堆排序




描述


堆排序的时间复杂度是 O(n log n), 是不稳定排序算法。


堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即 A[PARENT[i]] >= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。


代码实现

-- coding: UTF-8 --

from collections import deque


def swap_param(lists, i, j):


lists[i], lists[j] = lists[j], lists[i]


return lists


def heap_adjust(lists, start, end):


temp = lists[start]


i = start


j = 2 * i


while j <= end:


if (j < end) and (lists[j] < lists[j + 1]):


j += 1


if temp < lists[j]:


lists[i] = lists[j]


i = j


j = 2 * i


else:


break


lists[i] = temp


def heap_sort(lists):


length = len(lists) - 1


first_sort_count = length / 2


for i in range(first_sort_count):


heap_adjust(lists, first_sort_count - i, length)


for i in range(length - 1):


lists = swap_param(lists, 1, length - i)


heap_adjust(lists, 1, length - i - 1)


return [lists[i] for i in range(1, len(lists))]


def main():


lists = deque([50, 16, 30, 10, 60, 90, 2, 80, 70])


lists.appendleft(0)


print heap_sort(lists)


if name == 'main':


main()


归并排序




描述


时间复杂度是 O(n log n), 是稳定排序算法。


归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。


归并过程为:比较 a[i]和 a[j]的大小,若 a[i]≤a[j],则将第一个有序表中的元素 a[i]复制到 r[k]中,并令 i 和 k 分别加上 1;否则将第二个有序表中的元素 a[j]复制到 r[k]中,并令 j 和 k 分别加上 1,如此循环下去,直到其中一个有序表取完,然后再将另一个有序表中剩余的元素复制到 r 中从下标 k 到下标 t 的单元。归并排序的算法我们通常用递归实现,先把待排序区间[s,t]以中点二分,接着把左边子区间排序,再把右边子区间排序,最后把左区间和右区间用一次归并操作合并成有序的区间[s,t]。


代码实现

-- coding: UTF-8 --

def merge_sort(lists):

归并排序 时间复杂度是 O(n log n)

if len(lists) <= 1:


return lists


num = int(len(lists) / 2)


left_lists = merge_sort(lists[:num])


right_lists = merge_sort(lists[num:])


return merge(left_lists, right_lists)


def merge(left_lists, right_lists):


left, right = 0, 0


result = []


while left < len(left_lists) and right < len(right_lists):


现在能在网上找到很多很多的学习资源,有免费的也有收费的,当我拿到 1 套比较全的学习资源之前,我并没着急去看第 1 节,我而是去审视这套资源是否值得学习,有时候也会去问一些学长的意见,如果可以之后,我会对这套学习资源做 1 个学习计划,我的学习计划主要包括规划图和学习进度表。


分享给大家这份我薅到的免费视频资料,质量还不错,大家可以跟着学习



用户头像

Python编程资料加Q群免费领取:419829237 2022.03.14 加入

还未添加个人简介

评论

发布
暂无评论
Python 实现七大排序算法,Python中高级面试必知必会_Python_程序媛可鸥_InfoQ写作平台