python算法：排序

最新推荐文章于 2025-05-29 18:50:16 发布

这不小天嘛

最新推荐文章于 2025-05-29 18:50:16 发布

阅读量1k

点赞数 25

CC 4.0 BY-SA版权

文章标签： python 开发语言

本文链接：https://blog.csdn.net/2402_84466011/article/details/147271210

一、内置排序函数

ls.sort(key=lambda x: x[1], reverse=True)

这行代码对列表 ls 进行排序。sort() 方法是列表对象的一个内置方法，用于对列表中的元素进行排序。这里使用了两个参数：

key=lambda x: x[1]：这是一个排序的键函数。lambda 是一个匿名函数，这里 lambda x: x[1] 表示一个函数，它接受一个参数 x（在这里是一个元组），并返回这个元组的第二个元素（即字典中的值）。这个参数告诉 sort() 方法根据列表中每个元组的第二个元素（即字典的值）来排序。

reverse=True：这个参数告诉 sort() 方法按照降序进行排序。默认情况下，sort() 方法是按照升序排序的，但在这里我们希望按照值的降序排列，即频率最高的词排在前面。

二、冒泡排序（LB）

1.列表每两个相邻的数，如果前面比后面大，则交换这两个数。

2.一趟排序完成后，则无序区减少一个数，有序区增加一个数。

3.代码关键点：趟、无序区范围（箭头移动范围）

import random
def bubble_sort(lt):
    for i in range(len(lt)-1):   #趟数
        for i in range(len(lt)-i-1):    #箭头
            if lt[i]>lt[i+1]:
                lt[i],lt[i+1]=lt[i+1],lt[i]

ls =[random.randint(0,1000) for i in range(10)]
print(ls)
bubble_sort(ls)
print(ls)
#[851, 873, 240, 700, 659, 330, 732, 510, 298, 463]
#[240, 298, 330, 463, 510, 659, 700, 732, 851, 873]

三、选择排序（LB）

1.遍历一遍最小的数，拿出来，再遍历一遍最小的.....

2.简单的选择排序

import random
def select_sort_simple(ls):
    ls_new = []
    for i in range(len(ls)):
        min_a=min(ls)
        ls_new.append(min_a)
        ls.remove(min_a)    #按元素删，从左到右只删一个
    return ls_new
ls=[random.randint(0,1000) for i in range(10)]
print(ls)
print(select_sort_simple(ls))
#[255, 713, 141, 352, 936, 996, 58, 668, 652, 297]
#[58, 141, 255, 297, 352, 652, 668, 713, 936, 996]

四、插入排序（LB）

1.类似于摸牌插牌

import random

def insert_sort(ls):    # 分成两个列表，第0个初始牌是一个列表，其他是一个列表
    for i in range(1,len(ls)):
        j = i-1         #j是已有手牌的最右边的index
        key = ls[i]     #新抽了一张牌
        while j>=0:
            if ls[j]>key:
                ls[j+1]=ls[j]
                ls[j]=key
            j-=1
    return ls
  
ls=[random.randint(0,1000) for i in range(10)]
print(ls)
print(insert_sort(ls))
#[941, 302, 878, 598, 862, 290, 734, 132, 822, 711]
#[132, 290, 302, 598, 711, 734, 822, 862, 878, 941]

五、快速排序（NB）

1.取一个元素p，使p归位。列表被p分为两部分，左都比p小，右都比p大，递归完成排序。

2.代码

import random

def partition(ls,left,right):
    tmp = ls[left]              #拿出左边第一个元素，左坑出现
    while right>left:           #从右开始
        while right>left and ls[right]>=tmp:
            right-=1            #左移
        ls[left]=ls[right]      #填左坑,右坑出现
        while right>left and ls[left]<=tmp:
            left+=1             #右移动
        ls[right]=ls[left]      #填右坑，左坑出现
        ls[left]=tmp            #归位
    return left

def quick_sort(ls,left,right):
    if left<right:
        mid = partition(ls,left,right)
        quick_sort(ls,left,mid-1)
        quick_sort(ls,mid+1,right)
    return ls
ls=[random.randint(0,1000) for i in range(10)]
print(ls)
print(quick_sort(ls,0,len(ls)-1))
#[678, 233, 432, 435, 920, 914, 729, 871, 8, 205]
#[8, 205, 233, 432, 435, 678, 729, 871, 914, 920]

六、堆排序

1.树：一种可以递归定义的数据结构

树是由n个节点组成的集合

n=0，是一颗空树

n>0，那存在1个节点作为树的根节点，其他节点可以分为m个集合，每个集合本身又是一棵树。

2.二叉树：度不超过2的树，每个节点最多有两个孩子节点

满二叉树：一个二叉树，每个节点都达到最大值

完全二叉树：最下面的左边都满，最下面右边可以缺

3.二叉树的储存方式（表示方式）

（1）链式存储

以后学

（2）顺序存储

用列表表示

父节点与左孩子节点编号的关系：

0—1、1—3，3—5

i—2i+1

父节点和右孩子节点编号的关系：

0—2，1—4，2—6

i—2i+2

4.堆排序：一种特殊的完全二叉树

大根堆：父亲比孩子都打

小跟堆：父亲比孩子都小

5.堆的性质：向下调整性

假设跟节点的左右子树都是堆，但根节点不满足堆的性质，可以通过一次向下调整来将其变成一个堆

6.堆排序过程

（1）建立堆（2）得到堆顶元素，为最大元素（3）去掉堆顶，将堆最后一个元素放到堆顶，此时可以通过一次调整时堆有序（4）堆顶元素为第二大元素（5）重复步骤3，直到堆变空。

7.堆排序内置库heapq

import heapq
import random
ls=[random.randint(0,1000) for i in range(10)]
print(ls)
heapq.heapify(ls)#建立堆
for i in range(len(ls)):
    print(heapq.heappop(ls),end=',')#跳出最小值
    
#[126, 12, 776, 725, 820, 500, 555, 341, 344, 34]
#12,34,126,341,344,500,555,725,776,820,

heapq.heappush(heap, item)：将新元素 item 加入到堆 heap 中。
heapq.heappop(heap)：从堆 heap 中弹出并返回最小的元素。
heapq.heappushpop(heap, item)：将 item 加入到堆 heap 中，然后弹出并返回最小的元素。
heapq.heapify(x)：将列表 x 转换成堆。
heapq.heapreplace(heap, item)：弹出并返回堆 heap 中最小的元素，同时将 item 加入到堆中。
heapq.nlargest(n, iterable, key=None)：返回 iterable 中最大的 n 个元素。
heapq.nsmallest(n, iterable, key=None)：返回 iterable 中最小的 n 个元素。

七、归并排序

八、希尔排序

九、计数排序

十、桶排序

十一、基数排序

1.多关键字排序

#按十位升序，如果十位相同按个位降序
a = [10,66,67,89,87,99,98]
def shu(a):
    tens = a//10
    ones = a%10
    return (tens,-ones)
a.sort(key = shu)
print(a)

#按列表第一位升序，如果第一位相同按第二位降
b=  [[1,2],[1,3],[2,3],[2,2]]
def biao(x):
    return (x[0],-x[1])
b.sort(key=biao)
print(b)

十二、习题

给两个字符串s和t，判断t是否为s的重新排列后组成的单词

s='anagran',t='nagaram'

s='anagram'
t='nagaram'
if len(s)==len(t):
    dic1 = {}
    dic2 = {}
    for i in s:
        dic1[i] = dic1.get(i,0)+1
    for j in t:
        dic2[j] = dic2.get(j,0)+1
    if dic1==dic2:
        print('yes')
    else:
        print('No')
else:
    print("No")
#yes