Python 快速排序

def quick_sort(alist, start, end):
    """快速排序"""

    # 递归的退出条件
    if start >= end:
        return

    # 设定起始元素为要寻找位置的基准元素
    mid = alist[start]

    # low为序列左边的由左向右移动的游标
    low = start

    # high为序列右边的由右向左移动的游标
    high = end

    while low < high:
        # 如果low与high未重合,high指向的元素不比基准元素小,则high向左移动
        while low < high and alist[high] >= mid:
            high -= 1
        # 将high指向的元素放到low的位置上
        alist[low] = alist[high]

        # 如果low与high未重合,low指向的元素比基准元素小,则low向右移动
        while low < high and alist[low] < mid:
            low += 1
        # 将low指向的元素放到high的位置上
        alist[high] = alist[low]

    # 退出循环后,low与high重合,此时所指位置为基准元素的正确位置
    # 将基准元素放到该位置
    alist[low] = mid

    # 对基准元素左边的子序列进行快速排序
    quick_sort(alist, start, low-1)

    # 对基准元素右边的子序列进行快速排序
    quick_sort(alist, low+1, end)

alist = [54,26,93,17,77,31,44,55,20]
quick_sort(alist,0,len(alist)-1)
print(alist)
  • 最优时间复杂度:O(nlogn)
  • 最坏时间复杂度:O(n2)
  • 稳定性:不稳定
  1. 从数列中挑出一个元素,称为"基准"(pivot),
  2. 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。
  3. 递归地(recursive)把小于基准值元素的子数列和大于基准值元素的子数列排序。

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

时间: 2024-12-13 16:54:38

Python 快速排序的相关文章

python快速排序实现

方案一:容易理解的写法 #!/usr/bin/env python arr = [34, 80, 10, 8, 15, 20, 16, 48, 50, 36, 18]size = len(arr) def partion(arr, start, end): k = start i = start j = end while j > i: while j > i and arr[j] >= arr[k]: j = j - 1 if j > i: temp = arr[k] arr[k

python 快速排序的实现

快速排序的基本思想:先随便在无序列表中找一个元素,以这个元素为基准,其他所有元素都跟该元素比,比该元素小的成为一个子序列,比该元素大的成为另一个子序列,接着重复此过程,最终达到排序效果.我们也用递归的方式来实现. def quicksort(list): if len(list) < 2: return list little = [] large = [] # 这里取出列表第一个元素 middle = list.pop(0) for item in list: if item < middl

python --- 快速排序算法

在快速排序中引入递归和分治的概念(关于递归和分治的概念会单独写一篇来进行介绍) 问的解决思路: 快速排序的基本思想本身就是分治法,通过分割,将无序序列分成两部分,其中前一部分的元素值都要小于后一部分的元素值.然后每一部分在各自递归进行上述的过程,直到每一部分的长度都为1为止. 具体的过程就是当前无序区list[1.n]中任意去一个元素x(一般都是取第一个元素)作为比较的“基准”,用这个基准数将当前无序区划分为左右两个较小的无序区 list[1,i- 1]和list[i + 1,n],且左边的无序

python快速排序

1 def quicksort(array): 2 less, greater = [], [] 3 if len(array)<=1: 4 return array 5 elem = array.pop() 6 for i in array: 7 if i <= elem: 8 less.append(i) 9 else: greater.append(i) 10 return quicksort(less) + [elem] + quicksort(greater)

学习python 快速排序

def q(start , end , a): if start>= end : return else : mid = (start+end)/2 i = start+1 j = end key =a[start] while i<j: while i<=end and a[i]<key: i+=1 while j>=start and a[j]>key: j-=1 if i < j: tmp = a[i] a[i]=a[j] a[j]=tmp if a[sta

python 快速排序 完整

两头开始 以第一个为基准,从有往左,找第一个比基准数 大的,然后交换 从左往右,找第一个比基准数晓得,然后交换 遍历剩下的 基准数  左边的数们  以及  基准数 右边的数们 1 def quick_sort(array,left,right): 2 if left > right: 3 return 4 5 low = left 6 high = right 7 key = array[low] 8 9 while left < right: 10 while left <right

基本排序算法的Python实现

本篇主要实现九(八)大排序算法,分别是冒泡排序,插入排序,选择排序,希尔排序,归并排序,快速排序,堆排序,计数排序.希望大家回顾知识的时候也能从我的这篇文章得到帮助. 为了防止误导读者,本文所有概念性内容均截取自对应Wiki 冒泡排序 原理 冒泡排序(Bubble Sort)是一种简单的排序算法.它重复地走访过要排序的数列,一次比较两个元素,如果他们的顺序错误就把他们交换过来.走访数列的工作是重复地进行直到没有再需要交换,也就是说该数列已经排序完成.这个算法的名字由来是因为越小的元素会经由交换慢

javascript快速排序的思考

还记得三个月前,学习过快速排序,示例所讲的python快速排序十分易于理解,然而网上学习的c#的快速排序当时就懵逼的,现在已经全忘了,大概记得个思路 在学习完了一些高级的js方法后,今天用js模拟了python的快速排序方式 function mySort(nums) { if (nums.length < 2) { return nums; } let key = nums[0]; let less = nums.filter(value => value < key); let gr

Python常见排序算法解析

概述 十种常见排序算法可以分为两大类: 非线性时间比较类排序:通过比较来决定元素间的相对次序,由于其时间复杂度不能突破O(nlogn),因此称为非线性时间比较类排序. 线性时间非比较类排序:不通过比较来决定元素间的相对次序,它可以突破基于比较排序的时间下界,以线性时间运行,因此称为线性时间非比较类排序. 基础定义 稳定:如果a原本在b前面,而a=b,排序之后a仍然在b的前面. 不稳定:如果a原本在b的前面,而a=b,排序之后 a 可能会出现在 b 的后面. 时间复杂度:对排序数据的总的操作次数.