常见的排序方法（Python实现）

最新推荐文章于 2024-06-14 09:50:01 发布
最新推荐文章于 2024-06-14 09:50:01 发布
阅读量798 收藏
点赞数
分类专栏： Python 文章标签： python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_38036892/article/details/122705110
版权

主程序如下：

from random import randint
import time
import copy


GA_MAX = 19		#待排序的数据的数量
ga = [randint(0, 199) for i in range(GA_MAX)]	#待排序的数据
ga_copy = []	#用于检测排序结果

def print_ga():
    # print(ga)
    print(''.join(str(i) + ' ' for i in ga))


def random_ga():
    ga = [randint(0,GA_MAX-1) for i in range(20)]


def check_rsult():		#检查排序结果：期望是从大到小排序
    for i in range(GA_MAX):
        if ga_copy[i] not in ga:
            return False
    for i in range(GA_MAX-1):
        if ga[i] < ga[i+1]:
            return False
    return True

def sort_main():
    global ga_copy
    print_ga()
    ga_copy = copy.deepcopy(ga)
    time_start = time.perf_counter()

	# 具体的算法写在这里,从小到大 或者 从大到小
    # bubble_sort()
    # select_sort()
    # insert_sort()
    # insert_sort_half()
    # quick_sort()
    # heap_sort()
    # shell_sort()
    # merge_sort()
    
    time_cost = (time.perf_counter() - time_start) * 1000
    print('time_cost: {:g}ms'.format(time_cost))
    print_ga()
    print('check_rsult = ', check_rsult())
    return time_cost    # ms


if __name__ == '__main__':
    sort_main()

运行结果参考：

27 93 12 43 111 4 67 1 121 118 112 48 170 101 19 119 62 177 23 
time_cost: 0.044ms
177 170 121 119 118 112 111 101 93 67 62 48 43 27 23 19 12 4 1 
check_rsult =  True

#冒泡排序  从小到大和从大到小
def bubble_sort():  # O(n*n)  稳定
    """冒泡排序"""
    # ascend
    for j in range(GA_MAX):
        for i in range(GA_MAX-j-1):
            if ga[i] > ga[i+1]:
                ga[i], ga[i+1] = ga[i+1], ga[i]

def bubble_sort():
    for i in range(GA_MAX-1):
        for j in range(0, GA_MAX-i-1, 1):
            if ga[j] < ga[j+1]:
                ga[j], ga[j+1] = ga[j+1], ga[j]

# 如果向稳定排序，方法一，每次交换改为向后整体移位  方法二，组件新的数组
def select_sort():  # O(n*n)  不稳定
    """选择排序"""
    # ascend
    for j in range(GA_MAX):
        t = j
        for i in range(j + 1, GA_MAX):
            if ga[i] < ga[t]:
                t = i
        ga[j], ga[t] = ga[t], ga[j]
        
def select_sort():
    for i in range(GA_MAX-1):
        t = i
        for j in range(i+1, GA_MAX, 1):
            if ga[j] > ga[t]:
                t = j
        if t != i:
            ga[i], ga[t] = ga[t], ga[i]

def insert_sort():    # O(n*n)  稳定
    """插入排序"""
    # ascend
    for i in range(1, GA_MAX):
        for j in range(i, 0, -1):   # ga[i] 就是本次要插入的数据
            if ga[j] < ga[j-1]:     # 比较次数较多
                ga[j-1], ga[j] = ga[j], ga[j-1]     # 牺牲交换次数，换来代码整洁
            # 前面已经是有序数据，仍然要比较i次


def insert_sort_2():
    for i in range(1, GA_MAX):
        focus = ga[i]
        j = 0
        for j in range(i-1, -1, -1):
            if focus < ga[j]:       # 增加了break，找到即停，但这里使用的是顺序查找，最坏情况要比较i次
                ga[j+1] = ga[j]     # 相比上面算法，这里只做一次赋值
            else:
                j += 1  # 更新为focus的位置
                break   # 找到插入位置，就停止比较
        ga[j] = focus


def insert_sort_half():
    for i in range(1, GA_MAX):
        focus = ga[i]

        # 需要比较[0,i-1], 将顺序查找改为折半查找
        a = 0
        b = i-1
        j = 0
        while b >= a:
            j = int((b - a) / 2) + a
            if focus < ga[j]:
                b = j-1
                if b >= 0 and ga[b] <= focus:
                    break   # j 就是focus的位置
                elif j == 0:
                    break   # j 就是focus的位置
            else:
                a = j+1
                if a <= i-1 and ga[a] > focus:
                    j = a
                    break   # j 就是focus的位置
                elif j == i-1:
                    j = a
                    break   # j 就是focus的位置

        for t in range(i, j, -1):
            ga[t] = ga[t-1]
        ga[j] = focus

#从大到小-------------------------------------
def insert_sort():
    for i in range(1, GA_MAX, 1):
        t = ga[i]
        for j in range(i-1, -1, -1):
            if ga[j] < t:
                ga[j+1] = ga[j]
                if j == 0:
                    ga[j] = t
            else:
                if j+1 != i:
                    ga[j+1] = t
                break


def half_search(start,end,v):
    a = start
    b = end

    while a <= b:
        n = int(a + (b - a)/2)
        if ga[n] >= ga[v]:
            if n == end or ga[n+1] < ga[v]:
                return n+1
            a = n+1
        else:
            if n == start or ga[n-1] >= ga[v]:
                return n
            b = n-1


def insert_sort_half():
    for i in range(1, GA_MAX, 1):
        t = ga[i]
        n = half_search(0, i-1, i)
        for j in range(i, n, -1):
            ga[j] = ga[j-1]
        ga[n] = t

def quick_sort_do(x, y):
    if x >= y:
        return
    base = ga[x]
    i = x
    j = y
    while i < j:
        while j > i:
            if ga[j] < base:
                ga[i] = ga[j]
                i += 1
                break
            j -= 1
        while i < j:
            if ga[i] > base:
                ga[j] = ga[i]
                j -= 1
                break
            i += 1
    ga[i] = base
    quick_sort_do(x, i-1)
    quick_sort_do(i+1, y)


def quick_sort_ResponseGroup(begin, end):
    pass


def quick_sort():
    """快速排序"""
    # ascend
    quick_sort_do(0, GA_MAX-1)
    #quick_sort_ResponseGroup(0, GA_MAX-1)

#从大到小
def quick_sort_do(start, end):
    if start >= end:
        return
    base = ga[start]
    i = start
    j = end
    while i<j:
        while i<j:
            if ga[j]>base:
                ga[i] = ga[j]
                i += 1
                break
            j -= 1
        while i < j:
            if ga[i] < base:
                ga[j] = ga[i]
                j -= 1
                break
            i += 1
    ga[i] = base
    quick_sort_do(start, i-1)
    quick_sort_do(i+1, end)


def quick_sort():
    quick_sort_do(0, GA_MAX-1)

def heap_sort_do(f, sum):
    if sum <= 1 or f >= GA_MAX:
        return
    l = 2 * f + 1
    r = 2 * f + 2

    # 第一版代码
    '''if l < sum and ga[l] > ga[f]:
        ga[l], ga[f] = ga[f], ga[l]
    if r < sum and ga[r] > ga[f]:
        ga[r], ga[f] = ga[f], ga[r]
    if l < sum:
        heap_sort_do(l, sum)
    if r < sum:
        heap_sort_do(r, sum)'''

    # r 有效，则l必有效
    if r < sum and ga[l] < ga[r]:
        l = r
    if l < sum and ga[l] > ga[f]:
        ga[l], ga[f] = ga[f], ga[l]
        heap_sort_do(l, sum)


def heap_sort():
    """大推排序"""
    # ascend
    # print(''.join(str(i) + ' ' for i in range(GA_MAX)))
    for i in range(GA_MAX-1, 0, -2):    # setup
        f = int((i - 1) / 2)
        heap_sort_do(f, GA_MAX)

    for count in range(1, GA_MAX):
        ga[0], ga[GA_MAX-count] = ga[GA_MAX-count], ga[0]
        heap_sort_do(0, GA_MAX-count)

def shell_sort():
    """希尔排序"""
    gap = int(GA_MAX/2)     # 希尔增量
    while gap >= 1:
        for sub in range(gap):
            for i in range(sub+gap, GA_MAX, gap):   # 每个子序列采用插入排序, x x+gap x+2gap x+3gap
                focus = ga[i]
                j = 0
                for j in range(i - gap, -1, -gap):
                    if focus < ga[j]:  # 增加了break，找到即停，但这里使用的是顺序查找，最坏情况要比较i次
                        ga[j + gap] = ga[j]  # 相比上面算法，这里只做一次赋值
                    else:
                        j += gap  # 更新为focus的位置
                        break  # 找到插入位置，就停止比较
                ga[j] = focus
        gap = int(gap/2)

def merge_sort():
    """归并排序"""
    gt = [0 for i in range(GA_MAX)]
    sub_num = 1     # 各子序列成员最大数
    while sub_num < GA_MAX:
        for i in range(0, GA_MAX, 2 * sub_num):
            j = i + sub_num
            imax = i + sub_num
            if imax > GA_MAX:
                imax = GA_MAX
            jmax = j + sub_num
            if jmax > GA_MAX:
                jmax = GA_MAX
            t = i
            while i < imax and j < jmax:
                if ga[i] > ga[j]:
                    gt[t] = ga[j]
                    j += 1
                else:
                    gt[t] = ga[i]
                    i += 1
                t += 1
            if i == t:  # ga[i-j] 无需改变
                continue

            while i < imax:
                gt[t] = ga[i]
                t += 1
                i += 1
            while j < jmax:
                gt[t] = ga[j]
                t += 1
                j += 1
            for i in range(2*sub_num):  # 将数据拷回去
                t -= 1
                if 0 <= t < GA_MAX:
                    ga[t] = gt[t]
        sub_num = 2*sub_num

#从大到小
# 合并两个任意长度的数组/列表
def merge_do(lstart, lend, rstart, rend):
    l=lstart
    r=rstart
    tlist = []
    while l<=lend and r<=rend:
        if ga[l]>=ga[r]:
            tlist.append(ga[l])
            l += 1
        else:
            tlist.append(ga[r])
            r += 1
    if l<=lend:
        tlist += ga[l:lend+1]
    if r<=rend:
        tlist += ga[r:rend+1]

    l=lstart
    for item in tlist:
        ga[l] = item
        l += 1


def merge_divide(start, end):
    # 1分为2
    num = end-start+1
    smiddle = start+ int(num/2) -1
    if smiddle>start:    # 调用2分接口，从而调用合并接口
        merge_divide(start, smiddle)
    if end>smiddle+1:
        merge_divide(smiddle+1, end)
    # 合并
    if end > start:
        merge_do(start, smiddle, smiddle+1, end)

def merge_sort():
    merge_divide(0, GA_MAX-1)
卓耿Drogon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
chatgpt赋能python：Python中的升序（AscendingOrder）
sc17332889342的博客
05-31 257
本文由chatgpt生成，文章没有在chatgpt生成的基础上进行任何的修改。以上只是chatgpt能力的冰山一角。作为通用的Aigc大模型，只是展现它原本的实力。对于颠覆工作方式的ChatGPT，应该选择拥抱而不是抗拒，未来属于“会用”AI的人。🧡AI职场汇报智能办公文案写作效率提升教程 🧡专注于AI+职场+办公方向。下图是课程的整体大纲下图是AI职场汇报智能办公文案写作效率提升教程中用到的ai工具。
Ascend Pytorch算子功能验证
吴建明wujianming_110117
01-26 1092
Ascend Pytorch算子功能验证 编写测试用例 以add算子为例，测试脚本文件命名为：add_testcase.py。以下示例仅为一个简单的用例实现，具体算子的实现，需要根据算子定义进行完整的覆盖才能保证功能的基本正确。 引入依赖库。 import torch import numpy as np import sys import copy from util_test import compare_res 说明： 其中，util_test为测试框架提供的文件，详细实现参考 附录->测试代
python中的排序方法都有哪些_Python 中排序方法的十条用法总结
weixin_39943202的博客
11-23 335
sorted 用于对集合进行排序（这里说的集合是对可迭代对象的一个统称，他们可以是列表、字典、set、甚至是字符串），它的功能非常强大，本文将深入浅出地介绍 sorted 的各种使用场景。1、默认情况，sorted 函数将按列表升序进行排序，并返回一个新列表对象，原列表保持不变，最简单的排序>>> nums = [3,4,5,2,1]>>> sorted(nums)[1, 2, 3, 4, 5]2...
python实现excel排序
weixin_51443598的博客
04-11 2516
# -*- coding:utf-8 -*- """ 作者：sunli 日期：2022年04月06日20:42 """ import pandas as pd df = pd.read_excel('D:/nums.xlsx') df.sort_values(by='accuracy', inplace=True, ascending=False) print(df) df.to_excel('D:/nums_sort.xlsx', index=0)
python用选择法进行排序_Python 冒泡排序和选择法排序
weixin_39640395的博客
11-26 613
１，冒泡排序from random import randint#定义一个函数def paixu(lst):#接收传进来的列表的长度length = len(lst)for i in range(0, length):　＃迭代的次数是列表的长度for j in range(0, length-i-1):　＃迭代的次数是列表长度减去已经冒泡的元素个数减１（减１是为了第j个和j＋１个比较）if lst...
Python实现排序方法
hdxx2022的博客
11-27 1210
在做快速排序时一直各种问题，是因为地柜那里没有考虑清楚，一直把low的值赋值为0了，实际上应该是不固定的low值，他每个子循环不定。4.插入排序：从左向右遍历，依次选取数值，从数值的左侧从右向左遍历，选择第一个比他小的数值的右侧插入该数值，其他数值依次向后赋值。3.快速排序：将子段的第一个元素做为中值，先从右向左遍历，如过比中值大high-1，如果比中值小，将这个值放到low那里。本文给大家分享python四种常见排序方法，每种方法通过实例代码给大家介绍的非常详细，需要的朋友参考下吧。
python列表常见排序方法
热门推荐
m0_69265664的博客
07-10 3万+
python列表常见的四种排序方法
Python实现排序算法
weixin_74313494的博客
05-13 1500
具体实现时，侏儒排序从序列的第一个元素开始，依次比较相邻的两个元素，如果它们是逆序对（即前面的元素比后面的元素大），则交换这两个元素的位置。在每次循环中，首先比较当前位置和前一个位置的元素，如果它们是逆序对，则交换这两个元素的位置，然后将 i 减一，表示回溯到前一个位置；具体实现时，鸡尾酒排序的排序过程类似于摇晃鸡尾酒的过程，即从左到右扫描序列，然后从右到左扫描序列，然后再从左到右扫描序列，如此往复，直到序列已经排好序为止。在每次扫描过程中，都要注意将最大的元素往右边交换，将最小的元素往左边交换。
Python实现冒泡排序
m0_66786097的博客
02-08 1万+
Python实现冒泡排序
常见排序算法python实现
08-31
常见的排序算法python实现，选择排序，插入排序，希尔排序，归并排序，快速排序，堆排序，包括测试用例。
python实现五种常见排序算法
12-21
以下是用Python实现的五种常见排序算法： 1. 冒泡排序（Bubble Sort）： ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+...
python 常见的排序算法实现汇总
09-16
主要介绍了python 常见的排序算法，帮助大家更好的理解和学习python,感兴趣的朋友可以了解下
python实现八大常见排序算法
12-21
文章目录常见的排序算法冒泡排序选择排序插入排序希尔排序归并排序快速排序计数排序基数排序 常见的排序算法 冒泡排序 每次比较相邻两个数的大小，如果不是预期排序就交换顺序。 import random def bubble_sort...
基于JavaScript 如何实现爬山算法以及优化方案
乐闻世界
06-10 1333
爬山算法（Hill Climbing Algorithm）是一种常见的启发式搜索算法，常用于解决优化问题。其核心思想是从一个初始状态出发，通过逐步选择使目标函数值增大的邻近状态来寻找最优解。接下来，我们将通过 JavaScript 实现一个简单的爬山算法，帮助大家理解其原理和应用。从一个初始状态开始。评估当前状态的目标函数值。在当前状态的邻居中选择一个目标函数值更大的状态。如果找到了更优的邻居，则移动到该邻居并重复步骤2和步骤3。如果没有更优的邻居，则算法结束，当前状态即为局部最优解。
2024.6.13刷题记录
最新发布
lshx4658的博客
06-14 404
当时没有想到怎么保证队内全都是窗口内的元素，答案：“当队头元素在窗口的左边的时候，弹出队头”，虽然不能保证队内一直没有窗口外的元素，但是能保证使用到的队内元素（队头）全是窗口内元素。当时是有想到这个方法的，但是以为不行，一下没转过来弯。队列储存索引而不是元素，通过储存索引使我们能够快速判断元素是否出窗口。不会，思路来自题解（
Java——简单图书管理系统
m0_74100417的博客
06-09 1466
数据类型变量iffor数组方法类和对象封装继承多态抽象类和接口今天就是把上述知识点全部都用起来 图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理系统图书管理
Python | Leetcode Python题解之第149题直线上最多的点数
Mopes__的博客
06-14 377
Python | Leetcode Python题解之第149题直线上最多的点数
每日一题42：最小化字符串长度
m0_63227758的博客
06-14 295
创建集合s = set() # 创建一个空集合s = {1, 2, 3} # 创建一个包含元素 1, 2, 3 的集合s = set([1, 2, 3]) # 通过列表创建集合# 添加和删除元素s.add(4) # 向集合中添加元素 4s.remove(3) # 从集合中删除元素 3，如果元素不存在则会引发 KeyErrors.discard(2) # 从集合中删除元素 2，如果元素不存在也不会报错# 集合运算intersection = s1 & s2 # 交集。
Python基础速成
weixin_74163644的博客
06-11 369
文件操作 文件读取 with open语法 文件写入 注意事项 文件追加 异常、模块与包 捕获异常 捕获方法 捕获传递 模块的导入与自定义 定义 导入方式 自定义 测试模块 注意事项 python包 定义 操作 第三方包 定义 pip指令安装包
常见的排序方法 python
09-16
常见的排序方法包括冒泡排序、选择排序、插入排序、快速排序、归并排序和堆排序。下面我会给出它们的简要介绍： 1. 冒泡排序（Bubble Sort）：比较相邻的元素，将较大的元素逐步后移，每一轮都可以将当前未排序部分的最大值放在最后。 2. 选择排序（Selection Sort）：每次从未排序部分选择最小的元素，然后将其放到已排序部分的末尾，逐渐形成有序序列。 3. 插入排序（Insertion Sort）：将数组分为已排序和未排序两部分，每次从未排序部分选择一个元素插入到已排序部分的合适位置。 4. 快速排序（Quick Sort）：选择一个基准元素，将小于基准的元素放在它的左边，大于基准的元素放在它的右边，然后递归地对左右两个子序列进行快速排序。 5. 归并排序（Merge Sort）：将数组拆分成两个子数组，分别对子数组进行归并排序，然后再将两个有序子数组合并成一个有序数组。 6. 堆排序（Heap Sort）：利用堆这种数据结构进行排序，通过构建最大堆或最小堆来实现排序。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值