精华内容
下载资源
问答
  • 希尔排序(Shell Sort)是插⼊排序的⼀种。也称缩⼩增量排序,是直接插⼊排序算法的⼀种更⾼效的改进版本。希尔排序是⾮稳定排序算法。 希尔排序是把记录按下标的⼀定增量分组,对每组使⽤直接插⼊排序算法排序;随着...

    希尔排序(Shell Sort)是插⼊排序的⼀种。也称缩⼩增量排序,是直接插⼊排序算法的⼀种更⾼效的改进版本。希尔排序是⾮稳定排序算法。 希尔排序是把记录按下标的⼀定增量分组,对每组使⽤直接插⼊排序算法排序;随着增量逐渐减少,每组包含的关键词越来越多,当增量减⾄1时,整个⽂件恰被分成⼀组,算法便终⽌。

    def shell_sort(alist):
        n = len(alist)
        gap = n // 2
        while gap > 0:
            for i in range(gap, n):
                while (i-gap) >= 0:
                    if alist[i] < alist[i-gap]:
                        alsit[i], alist[i-gap] = alist[i-gap], alist[i]
                    i -= gap
            gap //= 2
    
    
    lis = [54, 26, 93, 17, 77, 31, 44, 55, 20]
    shell_sort(alist)
    print(alist)
    
    
    展开全文
  • 插⼊排序(英语:Insertion Sort)是⼀种简单直观的排序算法。它的⼯作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插⼊。插⼊排序在实现上,在从后向前扫描过程中,需要...

    插⼊排序(英语:Insertion Sort)是⼀种简单直观的排序算法。它的⼯作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插⼊。插⼊排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插⼊空间。

    def insert_sort(alist):
        n = len(alist)	
        # 从第二个位置,即下标为1的元素开始向前插入
        for j in range(1, n): 
        # 从第i个元素开始向前比较,如果小于前一个元素,就交换位置
            for i in range(j, 0, -1): # 
                if alist[i] < alist[i-1]:
                    alist[i], alist[i-1] = alist[i-1], alist[i]
                # 当第i项大于前一项时,就退出当前循环
                else:
                    break
        return alist
    
    
    lis = [8, 5, 7, 4, 2, 9]
    insert_sort(lis)
    print(lis)
    
    
    展开全文
  • 快速排序(Quicksort),又称划分交换排序(partition-exchange sort),通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别...

    快速排序(Quicksort),又称划分交换排序(partition-exchange sort),通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。步骤:1)从数列中挑中一个元素,称为“基准”(pivot)2)重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆放在基准的后面(相同的数可以到任一边)。在这个分区结束之后,该基准就处于数列的中间位置。这个称为分区(partition)操作。3)递归地(recursive)把小于 基准值元素的子数列和大于基准值元素的子数列排序。

    def quick_sort(alist, start, end):
        """快速排序"""
        # 递归的退出条件
        if start >= end:
            return 
        # 设定起始元素为要寻找的基准元素
        mid = alist[start]
        # left为序列左边的由左向右移动的游标
        left = start
        # right为序列右边的由右向左移动的游标
        right = end
        while left < right:
            # 如果left与right未重合,right指向的元素不比基准元素小,则right向左移动
            while left < right and alist[right] >= mid:
                right -= 1
            # 将right指向的元素放到left的位置上
            alist[left] = alist[right]
            # 如果left与right未重合,left指向的元素比基准元素小,则left向右移动
            while left < right and alist[left] < mid:
                left += 1
            # 将left指向的元素放到right的位置上
            alist[right] = alist[left]
        # 退出循环后,left与right重合,此时所指位置为基准元素的正确位置
        # 将基准元素放到该位置
        alist[left] = mid
        # 对基准元素左边的子序列进行快速排序
        quick_sort(alist, start, left-1)
        # 对基准元素右边的子序列进行快速排序
        quick_sort(alist, left+1, end)
    
    
    if __name__ = "__main__":
        lis = [8, 5, 7, 4, 2, 9, 12]
        quick_sort(lis, start, len(lis)-1)
        print(lis)        
    
    
    展开全文
  • python排序sort&sorted

    2020-12-16 13:04:27
    1.语法详解 #list内置sort()方法用来排序 list.sort(key=None, reverse=False) #全局sorted()方法来对可迭代的序列排序生成新的序列 sorted(iterable, key=None, reverse=False) key :主要是用来进行比较的元素,...

    1.语法详解

    #list内置sort()方法用来排序
    list.sort(key=None, reverse=False)
    #全局sorted()方法来对可迭代的序列排序生成新的序列
    sorted(iterable, key=None, reverse=False)
    

    key :主要是用来进行比较的元素,只有一个参数,具体的函数的参数就是取自于可迭代对象中,指定可迭代对象中的一个元素来进行排序。
    reverse: 排序规则,reverse = True 降序, reverse = False 升序(默认)。

    2.排序基础

    1.sorted

    mylist = [4,6,0,1,2,3]
    sort_list = sorted(mylist)
    print(sort_list)    #排序后的序列:[0, 1, 2, 3, 4, 6]
    print(mylist)       #原序列:[4, 6, 0, 1, 2, 3]
    
    

    2.sort

    mylist = [4,6,0,1,2,3]
    mylist.sort()
    print(mylist)    #排序后改变了原序列:[0, 1, 2, 3, 4, 6]
    

    不同点
    list.sort()方法仅被定义在list中,相反地sorted()方法对所有的可迭代序列都有效。

    #dict
    new_list = sorted({1: 'D', 2: 'B', 4: 'B', 3: 'E', 5: 'A'})
    print(new_list)		#[1, 2, 3, 4, 5]
    
    #tuple
    new_list = sorted((4,5,0,1,2,6))
    print(new_list)		#[0, 1, 2, 4, 5, 6]
    

    3.升序和降序

    mylist = [4,5,0,1,2,6]
    mylist.sort()   #默认reverse=False
    print(mylist)   #[0, 1, 2, 4, 5, 6]
    mylist.sort(reverse=True)
    print(mylist)   #[6, 5, 4, 2, 1, 0]
    

    4.key参数/函数

    list.sort()和sorted()函数增加了key参数来指定一个函数,此函数将在每个元素比较前被调用

    1.通过key指定的函数来忽略字符串的大小写

    ll1 = sorted("This is a test string from Andrew".split(), key=str.lower)
    print(ll1)      #['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']
    ll2 = sorted("This is a test string from Andrew".split())
    print(ll2)      #['Andrew', 'This', 'a', 'from', 'is', 'string', 'test']
    

    2.根据特定属性排序
    key参数的值为一个函数,此函数只有一个参数且返回一个值用来进行比较

    student_tuples = [
            ('john', 'A', 15),
            ('jane', 'B', 10),
            ('dave', 'B', 12),
    ]
    #结合lambda, 这里是按照每个元组的第三个元素来排序
    student_tuples.sort(key=lambda s: s[2])
    print(student_tuples)       #[('jane', 'B', 10), ('dave', 'B', 12), ('john', 'A', 15)]
    

    3.根据对象的属性进行对象排序

    class Student:
        def __init__(self, name, grade, age):
            self.name = name
            self.grade = grade
            self.age = age
        def __repr__(self):
            return repr((self.name, self.grade, self.age))
        
    
    student_objects = [
            Student('john', 'A', 15),
            Student('jane', 'B', 12),
            Student('dave', 'B', 10),
    ]
    
    #通过对象的属性age排序
    student_objects.sort(key=lambda student: student.age)
    print(student_objects)      #[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
    
    

    说明:
    repr实例1

    #关于__repr__, __str__是作为字符串打印时调用
    #可能的表示出一个对象来源的类以及继承关系
    #如果不添加方法__repr__
    print(student_objects[0])			
    #<__main__.Student object at 0x000002BA66EDD6A0>
    
    #添加后
    ('dave', 'B', 10)
    

    repr实例2

    import datetime
    today = datetime.datetime.now()
    print(str(today))
    # 2020-12-16 13:46:30.599880
    print(repr(today))
    # datetime.datetime(2020, 12, 16, 13, 46, 30, 599880)
    

    4.多个排序规则
    内置方法:

    # import re
    # 
    student = [{
            'sid': 1,
            'high':176,
            'weight':61
        },
        {
            'sid': 2,
            'high':176,
            'weight':59
        },
        {
            'sid': 3,
            'high':165,
            'weight':62
        },
        {
            'sid': 4,
            'high':180,
            'weight':75
        },
        {
            'sid': 5,
            'high':175,
            'weight':61
        },
        {
            'sid': 6,
            'high':178,
            'weight':61
        },
        {
            'sid': 7,
            'high':165,
            'weight':64
        },
        {
            'sid': 8,
            'high':171,
            'weight':68
        },
        {
            'sid': 9,
            'high':171,
            'weight':68
        },
        ]
    
    #先按照学生的身高排序,如果身高相同,则按照体重排序
    student.sort(key=lambda k: (k["high"],k["weight"]))
    
    
    

    算法实现
    学校举行运动会,学生们按编号(1,2,3……n)进行标识,现需要按照身高由低到高排列,对身高相同的人,按体重由轻到重排列;对于身高体重都相同的人,维持原有的编号顺序关系。请输出排列后的学生编号

    def test():
        n = int(input())
        high = input().split(" ")
        weight = input().split(" ")
        data = []
        for i in range(1,n+1):
            info = {"id":i,
                    "high":int(high[i-1]),
                    "weight":int(weight[i-1])}
            data.append(info)
        
        #冒泡排序
        for i in range(len(data)):
            for j in range(i+1,len(data)):
                if data[j-1]["high"]>data[j]["high"]:
                    data[j-1],data[j] = data[j],data[j-1]
                if data[j-1]["high"]==data[j]["high"]:
                    if data[j-1]["weight"]>data[j]["weight"]:
                        data[j-1],data[j] = data[j],data[j-1]
        for info in data:
            print(info["id"], end=" ")
    test()
    #输入
    5
    172 180 178 172 177
    65 70 62 68 71
    #输出
    1 4 5 3 2 
    
    展开全文
  • python排序sort函数实践

    2019-01-22 10:16:23
    https://blog.csdn.net/bestsort/article/details/79339682
  • 日常用python刷题中,我比较少遇到要比较很多个参数的情况,往往在list中用sort排序一下也就解决问题了 nums.sort()) 实在不行用key指定lambda函数来确定比较是表中第几项也就够用了. nums.sort(key=lambda x:x[1]) #...
  • 大家都知道,python排序有内置的排序函数 sort() 和 高阶函数sorted() 。但是它们有什么区别呢?《转型python数据分析学习路线》《转型python数...
  • sort() 是Python列表的一个内置的排序方法,list.sort() 方法排序时直接修改原列表,返回None; sort() 是Python内置的一个排序函数,它会从一个迭代器返回一个排好序的新列表。 相比于 sort(),sorted() 使用的...
  • Pythonsort排序

    2019-10-21 20:37:50
    1.python中的sort()方法可实现按关键字排序 sort()长用于对原列表进行排序python中的内置方法sorted()是将原列表复制一份,在副本上进行排序,而sort直接对原列表进行操作。 sort()方法的原型是sort([key=func...
  • 主要介绍了python排序函数sort()与sorted()的区别,需要的朋友可以参考下
  • Pythonpythonsort排序使用

    千次阅读 2019-03-15 21:28:45
    本博客原文:【Pythonpython中你所忽视的一个列表sort排序功能 1.前言 昨天一学妹问我一个关于python的问题,当时在外忙碌,没时间细看。今天看一下,咋一看我还真的不知道这个问题,bookinfo.sort(reverse=True...
  • 主要介绍了pythonsort排序使用,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • [python刷题]python排序函数sort和sorted

    万次阅读 2019-01-05 20:00:12
    注意sort()函数只能用在列表list的排序上 ls = list([5, 2, 3, 1, 4]) new_ls = sorted(ls) ##或者使用ls.sort()即可,直接将ls改变 print(new_ls) 2、sorted()函数 sorted()能用在任何可迭代对象的排序上,而且...
  • python排序冒泡排序Here you will learn about Python bubble sort. 在这里,您将了解Python冒泡排序。 In Bubble Sort, all we have to do is pick the first two elements of the array and compare them if ...
  • python sort排序

    2020-12-12 11:17:52
    列表中的元素在内存中可能彼此相邻,也可能不相邻。比如列表的另一种实现方式——链表,它... L.sort() 函数只适用于列表排序,而sorted()函数适用于任意可以迭代的对象排序。 L.sort() 函数排序会改变原有的待...
  • python排序冒泡排序In this tutorial, we will look at how to sort iterables, such as lists, tuples, strings, and dictionaries, based on different criteria.在本教程中,我们将研究如何基于不同的条件对可...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 7,918
精华内容 3,167
关键字:

python排序sort

python 订阅