精华内容
下载资源
问答
  • 时间复杂度在O(nlogN)的排序算法是快速排序,堆排序,归并排序。但是快排的最坏时间复杂度是O(n^2),平均时间复杂度为O(nlogn),所以不考虑快速排序。而堆排序太繁琐了。生硬地排除了。对于数组来说占用的空间复杂度...

    在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。

    这就需要分析一下各个排序算法的复杂度了。时间复杂度在O(nlogN)的排序算法是快速排序,堆排序,归并排序。但是快排的最坏时间复杂度是O(n^2),平均时间复杂度为O(nlogn),所以不考虑快速排序。而堆排序太繁琐了。生硬地排除了。对于数组来说占用的空间复杂度为O(1),O(n),O(n)。但是对于链表来说使用归并排序占用空间为O(1).

    所以,其实就是个归并排序题。

    # Definition for singly-linked list.

    # class ListNode(object):

    # def __init__(self, x):

    # self.val = x

    # self.next = None

    class Solution(object):

    def sortList(self, head):

    """

    :type head: ListNode

    :rtype: ListNode

    """

    if head is None or head.next is None:

    return head

    mid = self.get_mid(head)

    l = head

    r = mid.next

    mid.next = None

    return self.merge(self.sortList(l), self.sortList(r))

    def merge(self, p, q):

    tmp = ListNode(0)

    h = tmp

    while p and q:

    if p.val < q.val:

    h.next = p

    p = p.next

    else:

    h.next = q

    q = q.next

    h = h.next

    if p:

    h.next = p

    if q:

    h.next = q

    return tmp.next

    def get_mid(self, node):

    if node is None:

    return node

    fast = slow = node

    while fast.next and fast.next.next:

    slow = slow.next

    fast = fast.next.next

    return slow

    81b831b4a84e

    148. 排序链表 python

    展开全文
  • 自己在一边看算法一边用python实现的时候发现这么个问题:算法导论中的快排:def quick_sort(array, l, r):if l (array, l, r)quick_sort(array, l, q - 1)quick_sort(array, q + 1, r)def partition(array, l, r):x...

    自己在一边看算法一边用python实现的时候发现这么个问题:

    算法导论中的快排:

    def quick_sort(array, l, r):

    if l < r:

    q = partition(array, l, r)

    quick_sort(array, l, q - 1)

    quick_sort(array, q + 1, r)

    def partition(array, l, r):

    x = array[r]

    i = l - 1

    for j in range(l, r):

    if array[j] <= x:

    i += 1

    array[i], array[j] = array[j], array[i]

    array[i + 1], array[r] = array[r], array[i+1]

    return i + 1

    我自己理解后写出来的:

    def quickSort(list):

    if len(list) <= 1: return list

    flag = list[len(list) - 1:]

    left = []

    right = []

    for i in range(len(list) - 1):

    if flag[0] > list[i]:

    left.append(list[i])

    else:

    right.append(list[i])

    return quickSort(left) + flag + quickSort(right)

    如果我写的不是快速排序,那这是个什么(这里使用了额外的内存空间,似乎不是原地排序算法了)

    展开全文
  • # encoding=utf-8"""8.24日快速排序、归并排序应用到链表当中"""class ListNode():"""定于链表节点"""def __init__(self, value):self.value = valueself.next = Noneclass NodeList():"""定义链表"""def __init__...

    # encoding=utf-8

    """

    8.24日

    快速排序、归并排序应用到链表当中

    """

    class ListNode():

    """定于链表节点"""

    def __init__(self, value):

    self.value = value

    self.next = None

    class NodeList():

    """定义链表"""

    def __init__(self):

    self.head = None

    def nodelist_init(self, list0):

    """初始化链表,使用list数据"""

    node_list = []

    for l in list0:

    newnode = ListNode(l)

    node_list.append(newnode)

    for i in range(len(node_list) - 1):

    node_list[i].next = node_list[i + 1]

    node_list[-1].next = None

    self.head = node_list[0]

    def listsort(self):

    """链表排序,可以选择不同的排序方案"""

    # s = Solution()

    # s.quicksorted(self.head, None) # 快排

    s = Solution1() # 归并排序

    self.head = s.mergesort(self.head)

    def printListnode(self):

    """输出链表每个节点值"""

    p = self.head

    while p:

    print(p.value)

    p = p.next

    class Solution():

    """快排类"""

    def __init__(self):

    pass

    def quicksorted(self, head, end):

    if head != end:

    node = self.partition(head, end) # 先挖坑填数

    self.quicksorted(head, node) # 递归调用

    self.quicksorted(node.next, end) # 递归调用

    def partition(self, head, end):

    p1, p2 = head, head.next # p2是遍历指针,p1是小数的指针

    while p2 != end:

    if p2.value < head.value:

    p1 = p1.next

    tmp = p2.value

    p2.value = p1.value

    p1.value = tmp

    p2 = p2.next

    tmp = head.value

    head.value = p1.value

    p1.value = tmp

    return p1

    class Solution1():

    """归并排序类"""

    def __init__(self):

    pass

    def mergesort(self, head):

    if head is None or head.next is None:

    """链表为空或仅有一个节点,直接返回结果"""

    return head

    mid = self.getmid(head)

    right = mid.next

    mid.next = None

    mer1 = self.mergesort(head)

    mer2 = self.mergesort(right)

    result = self.merge(mer1, mer2)

    return result

    def getmid(self, head):

    """使用快慢指针寻找链表中间节点"""

    if head is None or head.next is None:

    return head

    fast = head

    slow = head

    try:

    while fast.next.next is not None and slow.next is not None:

    fast = fast.next.next

    slow = slow.next

    except:

    pass

    return slow

    def merge(self, head1, head2):

    """对两个链表进行归并,比较两个链表当中的值,合并到一个新的链表当中"""

    p1 = head1

    p2 = head2

    if head1.value < head2.value:

    head = head1

    p1 = p1.next

    else:

    head = head2

    p2 = p2.next

    p = head # 新生成的头指针不能动, 由p来进行移动

    while p1 is not None and p2 is not None:

    if p1.value < p2.value:

    p.next = p1

    p1 = p1.next

    p = p.next

    else:

    p.next = p2

    p2 = p2.next

    p = p.next

    if p1 is not None:

    p.next = p1

    else:

    p.next = p2

    return head

    if __name__ == '__main__':

    """代码直接可以跑,python3."""

    nodelist = NodeList()

    nodelist.nodelist_init([3, 5, 7, 3, 2, 5, 1])

    nodelist.listsort()

    nodelist.printListnode()图解排序算法(四)之归并排序 - dreamcatcher-cx - 博客园(侵删)

    自己画了一个快速排序的简单例子示意图,比较粗糙大家凑合看一下吧:

    初始链表值为【3 5 7 3 1 2】

    再附一张各类排序算法的比较列表:

    以上

    展开全文
  • Python中的快速排序算法就像合并排序一样,快速排序算法采用分治法的原理将输入数组分为两个列表,第一个包含小项目,第二个包含大项目。然后,该算法将对两个列表进行递归排序,直到对结果列表进行完全排序为止。...

    c75c10385343fbf234324591e8e5658664388f8c.jpeg?token=0c42d8b2e6aa2a0c0aa71123e21a203e

    Python中的快速排序算法

    就像合并排序一样,快速排序算法采用分治法的原理将输入数组分为两个列表,第一个包含小项目,第二个包含大项目。然后,该算法将对两个列表进行递归排序,直到对结果列表进行完全排序为止。

    划分输入列表称为对列表进行分区。快速排序首先选择一个主元素并围绕这个主元素对列表进行分区,将每个较小的元素放入一个低数组,将每个较大的元素放入一个高数组。

    将低链表中的每个元素放到主链表的左边,将高链表中的每个元素放到主链表的右边,使主链表精确地位于排序后的主链表中所需要的位置。这意味着该函数现在可以递归地对low和high应用相同的过程,直到整个列表被排序。

    在Python中实现Quicksort

    这是quicksort的一个相当紧凑的实现:

    b90e7bec54e736d1beb65112c2cbe0c4d46269a1.jpeg?token=79276096fe1d309be7c77430b6c263f9

    以下是代码摘要:

    如果数组包含的元素少于两个,第6行将停止递归函数。第12行从列表中随机选择主元素,然后对列表进行分区。第19行和第20行将所有小于pivot的元素放入名为low的列表中。第21行和第22行把每一个等于主元素的元素放到这个叫做相同的列表中。第23行和第24行将每个大于pivot的元素放入名为high的列表中。第28行递归地对低链表和高链表进行排序,并将它们与同一链表的内容组合在一起。下面是快速排序对数组进行排序的步骤的说明[8, 2, 6, 4, 5]:

    ca1349540923dd54e1fb76d389921cd89d824827.jpeg?token=c25ffbecdc53162c49f525c044b676f9

    黄线表示阵列的划分成三个列表:low,same,和high。绿线表示排序并将这些列表放在一起。以下是步骤的简要说明:

    主元是随机选择的。在这种情况下,主元是 6第一个传递分区输入数组,low包含[2,4,5],同样包含[6],high包含[8]。然后递归地调用quicksort(),以low作为输入。这将选择一个随机的主元,并将数组分为[2]低、[4]相同和[5]高。这个过程还在继续,但是在这一点上,low和high都有两个以下的项。这就结束了递归,函数将数组重新组合在一起。将排序后的low和high分别添加到同一个列表的任意一端,生成[2、4、5]。另一方面,包含[8]的高链表有少于两个元素,因此算法返回排序后的低数组,它现在是[2,4,5]。将其与same([6])和high([8])合并将生成最终的排序列表。选择主元

    为什么上面的实现会随机选择主元素?一致地选择输入列表的第一个或最后一个元素不是同样的吗?

    由于快速排序算法的工作方式,递归层的数量取决于主元在每个分区中的位置。在最佳情况下,算法始终选择中位数元素作为轴心。这将使每个生成的子问题的大小正好是前一个问题的一半,导致最多达到log2n级别。

    另一方面,如果算法始终选择数组中最小或最大的元素作为主元素,那么生成的分区将尽可能不相等,导致n-1递归级别。这是快速排序最坏的情况。

    正如您所看到的,快速排序的效率通常取决于主选择。如果输入数组是未排序的,那么使用第一个或最后一个元素作为主元素将与随机元素一样工作。但是,如果输入数组是排序的或几乎是排序的,使用第一个或最后一个元素作为主元素可能会导致最坏的情况。随机选择支点使得快速排序更有可能选择一个更接近中位数的值,并且完成得更快。

    选择主元的另一种方法是找到数组的中值,并强制算法使用它作为主元。这可以在O(n)时间内完成。虽然这个过程有点复杂,但是使用中间值作为快速排序的主元素可以确保您得到最好的大O场景。

    a50f4bfbfbedab64193eac22a0ad00c578311e21.jpeg?token=be51c577114dfa57beac6ea42bd982ee

    衡量Quicksort的大复杂性

    使用快速排序,输入列表在线性时间O(n)内进行分区,这个过程递归地重复平均log2n次。这就导致了O(n log2n)的最终复杂度。

    也就是说,还记得关于支点的选择如何影响算法运行时的讨论吗?O(n)最佳情况发生在所选的主元接近数组的中位数时,O(n2)情况发生在主元是数组的最小值或最大值时。

    从理论上讲,如果算法首先集中于寻找中值,然后将其用作主元素,那么最坏情况复杂度将降至O(n log2n)。数组的中位数可以在线性时间内找到,使用它作为轴心可以保证代码的快速排序部分将在O(n log2n)中执行。

    通过使用中值作为主元,最终得到O(n) + O(n log2n)的运行时。可以化简为O(n log2n)因为对数部分的增长速度比线性部分快得多。

    定时实施Quicksort

    到目前为止,您已经熟悉了算法运行时间的计时过程。只需在第8行中更改算法的名称即可:

    00e93901213fb80e3aea63f3614a8028b9389478.jpeg?token=91d824f83ffe0f5a8a46543b3f53093e

    您可以像以前一样执行脚本:

    Shell

    $ python sorting.py

    Algorithm: quicksort. Minimum execution time: 0.11675417600002902

    快速排序不仅在不到一秒内完成,而且比合并排序快得多(0.11秒对0.61秒)。将ARRAY_LENGTH指定的元素数量从10,000增加到1,000,000并再次运行脚本,最终会在97秒内完成合并排序,而快速排序仅在10秒内对列表进行排序。

    分析快速排序的优缺点

    顾名思义,快速排序非常快。虽然理论上最坏的情况是O(n2),但实际上,快速排序的良好实现胜过大多数其他排序实现。另外,就像归并排序一样,快速排序也可以直接并行化。

    快速排序的主要缺点之一是不能保证它将达到平均运行时复杂度。尽管最坏的情况很少出现,但某些应用程序不能冒性能差的风险,因此它们会选择O(n log2n)以内的算法,而不管输入是什么。

    就像归并排序一样,快速排序也需要用内存空间来换取速度。这可能会成为对较大列表进行排序的限制。

    对10个元素的列表进行快速排序,可以得到以下结果:

    Shell

    Algorithm: bubble_sort. Minimum execution time: 0.0000909000000000014

    Algorithm: insertion_sort. Minimum execution time: 0.00006681900000000268

    Algorithm: quicksort. Minimum execution time: 0.0001319930000000004

    结果表明,当列表足够小时,快速排序也要付出递归的代价,完成时间比插入排序和冒泡排序都要长。

    8d5494eef01f3a2928126c96cfbe13375d607c35.jpeg?token=dd6f0cdb11ff426000f7acc06ea3ef8e

    展开全文
  • 一、链表排序1、归并排序(递归版)这个算法要采用递归,空间复杂度没办法达到O(n),时间复杂度为O(nlog(n)# -*- coding: utf-8 -*-'class ListNode(object):def __init__(self, x):self.val = xself.next = None...
  • /usr/bin/pythonfrom sortCommon import swap#分区函数def partition(dataArray, left, right):#把最后一个元素做为基准pivot = right#小于基准的子数组的最后一个元素的下标tail = left - 1for i in range(left, ...
  • args = list(args) for i in range(len(args)-1): flag = 0 s = len(args)-i for j in range(1,s): if args[flag] [j]: flag = j args[flag],args[s-1] = args[s-1],args[flag] print(args) 快速: def paixu(ls,...
  • 正如我们大家所了解的,如果想使用这个算法,就要求我们要去不断的执行,直到找到最佳的效果演示,想必大家在搜索问题之前,也有过基本的了解吧,比如排序之间肯定是要存在对比的,然后进行优先选择,那么接下来,...
  • 展开全部应该是你sorted的使62616964757a686964616fe4b893e5b19e31333366303066用方式不对吧,它可以对name.key这样的形式进行排序的。class m:def __init__(self,name,id):self.name=nameself.id=id@propertydef ...
  • 1.题目描述 在O(nlogn) 时间复杂度和常数级空间复杂度下,对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: ...利用快速排序实现复杂度要求,但是注意...
  • #! /usr/bin/env python # -*-coding:utf-8-*- """ Author: ChileWan...
  • python 单向链表实现快速排序

    千次阅读 多人点赞 2018-11-27 16:23:24
    python 单向链表实现快速排序 快速排序的基本思想: 从序列当中选择一个基准数 在这里我们选择序列当中第一个数作为基准数 将序列当中的所有数依次遍历,比基准数大的位于其右侧,比基准数小的位于其左侧 重复...
  • 链表排序 Python

    2019-08-12 23:07:03
    插入排序 class Solution(object): def insertionSortList(self, head): p = new_s =ListNode(None) #插入的有可能在头结点前面 new_s.next = head cur = head while cur and cur.next: ...
  • 题目23:合并K个排序链表思路1:如何把所有节点放进 r(result link)?怎么对 r 排序?如何修改每个节点的指针?==代码实现==思路2:知识点补充-Python heapq(堆操作)用法详解优先级队列==代码实现==思路3:...
  • 1、创建链表: from random import randint class DLinkedNode(object): def __init__(self, data=None, pre=None, post=None): self.data = data self.pre = pre self.post = ...
  • 一、链表排序1、归并排序(递归版)这个算法要采用递归,空间复杂度没办法达到O(n),时间复杂度为O(nlog(n)# -*- coding: utf-8 -*-"class ListNode(object):def __init__(self, x):self.val = xself.next = ...
  • 排序链表】题目描述在 O(n log n) 时间复杂度和常数级空间复杂度下,对链表进行排序。示例 1:输入: 4->2->1->3输出: 1->2->3->4示例 2:输入: -1->5->3->4->0输出: -1->0->3-&...
  • 使用快速排序链表进行排序 本文代码使用python3语法 #链表节点 class Node(): def __init__(self,val): self.val = val self.prev = None self.next = None #链表 class LinkedList(object): def __...
  • 方法1:归并排序 思路: 1、先处理特殊情况 2、然后从中间切分,用快慢指针找到中间值进行递归 3、合并两个有序的链表 Python代码如下: # Definition for singly-linked list. # class ListNode: # def __init__...
  • 快速排序 a=[5,4,3,2,1,6] def partion(a,low,high): key=a[low] while low while low[high]>=key: high-=1 else: a[low]=a[high] while low[low] low+=1 else: a[high]=a[low] a[low]=key return low...
  • 单向链表python实现

    2019-04-23 11:13:27
    单链表python实现 节点实现 # 节点 class Node(object): def __init__(self,item): # item 存储数据元素 self.item = item # next为下一个节点标识 self.next = None 单链表操作 # 单链表 class SingleLink...
  • 思路 1.选出基准数(第一个或者最后一个数字) 2.小于基准数的为一个数组;小于基准数的为一个数组 3.对两个数组递归,形式如下: quick(arr1)+[base_num]+quick(arr2) def quick(arr): if arr&...
  • 快速排序——Python实现(1)

    千次阅读 2011-06-16 13:31:00
    本作品采用知识共享署名-... 作者:liuyuan_jq2011-06-16 快速排序原理快速排序的基本思想是基于分治策略的。对于输入的子序列L[p..r],如果规模足够小则直接进行排序,否则分三步处理:分解(Divide):将输入的序列L
  • 广告关闭腾讯云11.11云上盛惠 ,精选热门产品助力...遍历整个链表 cur = self._head if cur == none: return count = 0 while cur ! = none:print(cur.elem,end= ) cur = cur.next count += 1 return count defad...
  • 如果没做过练习的,这道题还真没那么容易快速实现。在下拿Python通过50行代码实现一遍,以备各位不时之需。 1)step1:定义节点 class Node: def __init__(self,val): self.val=val #节点值 self.pre=None #上个...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,677
精华内容 4,270
关键字:

快速排序链表python

python 订阅