python中几种排序的算法思想

1.冒泡排序法

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

#冒泡排序

def bubbling(list):
    n = len(list)
    for i in range(n-1):
        for j in range(n-1-i):
            if list[j] >= list[j+1]:
                list[j],list[j+1] = list[j+1],list[j]
    return list

list3 = [9,3,2,1,7]
# print(bubbling(list3))

#对列表中元素是字典的排序
l = [
    {'name':'xiaowang', 'age':18,'height':150},
    {'name':'xiaogang', 'age':20,'height':140},
    {'name':'xiaohong', 'age':19,'height':145},
]
def sort(l,key=None,reverse=True):  #封装函数  函数名sort 参数：列表l ，键的初始值定为空，默认排序为逆序
    n = len(l)                    #获取列表长度
    for i in range(n-1):         #遍历列表元素  外层循环控制循环次数
        for j in range(n-1-i ):  #内层循环  两两比较（冒泡排序）
            if key == None:  # 即键值对不存在执行下面程序
                # 首先判断reverse的真假
                # 这是对上面的简写  即：如果reverse为真执行(l[j] <l[j + 1])
                # 如果reverse为假执行(l[j]>l[j + 1])
                is_swap = (l[j] < l[j + 1]) if reverse else (l[j] > l[j + 1])

            else:  # 即key存在
                # 如果key存在执行下面命令
                # 存在键值对，即字典不能直接比较大小，要选取其中元素的值进行比较大小
                is_swap = (key(l[j]) < key(l[j + 1])) if reverse else (key(l[j]) > key(l[j + 1]))

                if is_swap:  # 如果is_swap存在，要交换元素的位置
                    l[j], l[j + 1] = l[j + 1], l[j]
#保持原列表不变，生成一个新列表 用到函数sorted
l1 = sorted(l,key=lambda d:d['age'] ,reverse=True)   # lambda匿名函数。
                                             # 格式：lambda 参数1，参数2、、、：表达式
                                             # 在字典中参数d为字典中的元素，表达式为元素的键d['age']
                        # key存在通过匿名函数使用字典中的键值对比较大小
for i in l1:            #遍历新列表
 print(i)

2.快速排序（概念见百科）

通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
快速排序是对冒泡排序的一种本质改进，快速排序通过一趟扫描，就能确保某个数的左边各数都比它小，右边各数都比它大

def quickSort(L,low,high):
    i=low 
    j=high     
    if i>=j:         
        return L      
    key=L[i]     
    while i<j:         
        while i<j and L[j]>=key:             
            j=j-1         
        L[i]=L[j]         
        while i<j and L[i]<=key:             
            i=i+1         
        L[j]=L[i]     
    L[i]=key     
    quickSort(L,low,i-1)     
    quickSort(L,j+1,high)     
    return L 
    
li = [9,3,2,6,1,0]
print(quickSort(li,0,len(li)-1))

#写法2（见百科）
def quickSort2(array):
    if len(array) < 2:  # 基线条件（停止递归的条件）
        return array
    else:  # 递归条件
        baseValue = array[0]  # 选择基准值
        # 由所有小于基准值的元素组成的子数组
        less = [m for m in array[1:] if m < baseValue]
        # 包括基准在内的同时和基准相等的元素，在上一个版本的百科当中，并没有考虑相等元素
        equal = [w for w in array if w == baseValue]
        # 由所有大于基准值的元素组成的子数组
        greater = [n for n in array[1:] if n > baseValue]
    return quickSort2(less) + equal + quickSort2(greater)

list = [2,3,4,1,6,3,0]
print(quickSort2(list))

3.插入排序（选择排序）

如将第一个数分别与后面的所有数比较，不合适交换，交换后紧接着再与后面的数比较，不合适在交换，直到比较到最后一个，每次能够确定一个最大的数

def sor(lis):
    n = len(lis)
    for i in range(n):
        for j in range(i+1,n):
            if lis[i]>lis[j]:
                lis[i],lis[j] = lis[j],lis[i]
    return lis
l = sor([2,1,4,6,3,0])

print(l)

python中几种排序的算法思想

猜你喜欢