用一个Python简单选择排序算法，锻炼编码内功

最新推荐文章于 2024-04-30 11:11:45 发布
最新推荐文章于 2024-04-30 11:11:45 发布
阅读量146 收藏 2
点赞数 1
分类专栏： Python算法 文章标签： python python算法 Python选择排序 Python编码 Python优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/pagean/article/details/105689434
版权

Python简单排序算法：

  • 在每一趟的比较过程中（与冒泡不同），只比较，不交换位置；
  • 遍历次数n(n-1)/2；
  • 时间复杂度O(n**2)；
  • 与冒泡相比较，减少了交换次数，性能提高。

1.1 Python简单快速排序的核心算法：

  • 结果可为升序或降序排列，默认升序排列
  • 扩大有序区，减小无序区。图中红色部分就是增大的有序区，反之就是减小的无序区
    以降序为例
  • 相邻元素依次两两比较，获得每一次比较后的最大值，并记住此值的索引
    -每一趟都从无序区中选择出最大值，然后交换到当前无序区最左端
    算法实现
nums = [1,9,8,5]
length = len(nums)

for i in range(length-1): #比较的次数与冒泡排序一样，len(nums)-1 次。
    maxindex = i
    for j in range(i+1,length):
        if nums[j]>nums[maxindex]:
            maxindex = j
    nums[i],nums[maxindex] = nums[maxindex],nums[i]
        
    print(nums,i,maxindex)
#     if i == 0: break
#     if i == 1: break
#     if i == 2: break
#     if i == 3: break
        
    

[9, 1, 8, 5] 0 1
[9, 8, 1, 5] 1 2
[9, 8, 5, 1] 2 3

优化当最大值已经是第一个时候，无需再排序的情况。

nums = [9,1,8,5]
 
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length-1):  
    maxindex = i
    for j in range(i+1,length):
        count_iter += 1
        if nums[j]>nums[maxindex]:
            maxindex = j
    
    if i !=maxindex: # 这说明i自己就是maxindex
        count_swap += 1
        nums[i],nums[maxindex] = nums[maxindex],nums[i]
        
    print("结果{}；比较次数{:>3}，交换次数{:>3}".format(nums,count_iter,count_swap))


结果[9, 1, 8, 5]；比较次数  3，交换次数  0
结果[9, 8, 1, 5]；比较次数  5，交换次数  1
结果[9, 8, 5, 1]；比较次数  6，交换次数  2

1.2 Python简单快速排序的比较次数减少和末次交换减少：

这个方法要注意避免最大值交换后会对最小值交换是的索引产生影响，如何规避这个影响是关键。

nums_list = [[1,9,8,5],[9,1,8,5]]
nums = nums_list[0]

length = len(nums)

count_iter = 0
count_swap = 0
 
for i in range(length // 2):  
    maxindex = i
    minindex = -i -1 
    minoriginal = minindex
 
    for j in range( i+1 ,length -i):
        count_iter += 1
        
        if nums[j]>nums[maxindex]:
            
            maxindex = j
        if nums[minindex]>nums[-j -1]: 
 
            minindex = -j -1 # $从-2开始的倒序取索引

   
    if i !=maxindex: # 这说明i自己就是maxindex
        nums[i],nums[maxindex] = nums[maxindex],nums[i]
        count_swap += 1
        # 客服交换对最小值索引的干扰 
        if i == minindex or i == length + minindex: #>>>>>>>>>>>>>>>>>>>>>
            minindex = maxindex - length #>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
    if minoriginal!=minindex:
        nums[minoriginal],nums[minindex] = nums[minindex],nums[minoriginal]
        count_swap +=1
    print(nums,i,maxindex)
    break

        
print("结果{}；比较次数{:>3}，交换次数{:>3}".format(nums,count_iter,count_swap))


[9, 5, 8, 1] 0 1
结果[9, 5, 8, 1]；比较次数  3，交换次数  2

nums_list = [[1, 9, 8, 5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length):
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #这里的索引变化是会对下面的minindex产生影响的，所以本次的输出是错误的
        count_swap += 1
    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 9, 8, 5]
1 -4 ++
[5, 1, 8, 9] 0 1
3 -3 ++
[5, 8, 9, 1] 1 3
______________________________
[5, 8, 9, 1] 5 4

修正后的版本，这里用到了负索引的技巧：

nums_list = [[1, 9, 8, 5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length):
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #这里的索引变化是会对下面的minindex产生影响的，所以本次的输出是错误的
        count_swap += 1
    if  i == minindex or i == length + minindex:# 解决方案
        minindex = maxindex - length      # 把正索引换位负索引

        if minorigin != minindex:
            nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
            count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 9, 8, 5]
1 -4 ++
[9, 5, 8, 1] 0 1
2 -3 ++
[9, 8, 5, 1] 1 2
______________________________
[9, 8, 5, 1] 5 3

补充校正内循环次数：

nums_list = [[1,8,1,1,1,1,1,9,5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): #每次内循环前后各减少一个
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i] #这里的索引变化是会对下面的minindex产生影响的，所以本次的输出是错误的
        count_swap += 1
    if  i == minindex or i == length + minindex:# 解决方案
        minindex = maxindex - length      # 把正索引换位负索引

    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 8, 1, 1, 1, 1, 1, 9, 5]
7 -3 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 0 7
1 -2 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 1 1
6 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 2 6
3 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 3 3
______________________________
[9, 8, 5, 1, 1, 1, 1, 1, 1] 20 4

最后的优化，当极大值和极小值相遇。

nums_list = [[1,8,1,1,1,1,1,9,5], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): # 
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")
    
    if nums[maxindex] == nums[minindex]:  # 避免 有重复数据的情况的内循环浪费
        break

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i]    
        count_swap += 1
    if  i == minindex or i == length + minindex:#  
        minindex = maxindex - length      #  

    if minorigin != minindex:
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[1, 8, 1, 1, 1, 1, 1, 9, 5]
7 -3 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 0 7
1 -2 ++
[9, 8, 1, 1, 1, 1, 5, 1, 1] 1 1
6 -4 ++
[9, 8, 5, 1, 1, 1, 1, 1, 1] 2 6
3 -4 ++
______________________________
[9, 8, 5, 1, 1, 1, 1, 1, 1] 20 4

最后，通过增加值的判断，完善一种无需排序的情况：

nums_list = [[2,1,1,1,1], [9, 1, 8, 5]]
nums = nums_list[0]
print(nums)
length = len(nums)

count_iter = 0
count_swap = 0

for i in range(length // 2):
    maxindex = i
    minindex = -i - 1
    minorigin = minindex

    for j in range(i + 1, length-i): # 
        count_iter += 1
        if nums[j] > nums[maxindex]:
            maxindex = j
        if nums[minindex] > nums[-j - 1]:
            minindex = -j - 1
    print(maxindex, minindex, "++")
    
    if nums[maxindex] == nums[minindex]:  
        break

    if i != maxindex:  #
        nums[i], nums[maxindex] = nums[maxindex], nums[i]    
        count_swap += 1
    if  i == minindex or i == length + minindex:#  
        minindex = maxindex - length      #  

    if minorigin != minindex and nums[minindex] != num[min]: # 增加条件，如果值相等，就也不交换
        nums[minorigin], nums[minindex] = nums[minindex], nums[minorigin]
        count_swap += 1
    print(nums, i, maxindex)
print("_" * 30)
print(nums, count_iter, count_swap)

[2, 1, 1, 1, 1]
0 -1 ++
[2, 1, 1, 1, 1] 0 0
1 -2 ++
______________________________
[2, 1, 1, 1, 1] 6 0

附 变体

li = [2, 3, 1, 7, 65]
for i in range(len(li) - 1):
    max = li[i]

    for j in range(i + 1, len(li)):

        if max < li[j]:
            max = li[j]
            max_index=j
    li[max_index]=li[i]
    li[i], max = max, li[i]
    print(li)
print(li)




[65, 3, 1, 7, 2]
[65, 7, 1, 3, 2]
[65, 7, 3, 1, 2]
[65, 7, 3, 2, 1]
[65, 7, 3, 2, 1]
曼巴的脚步
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python实现的选择排序算法示例
09-21
主要介绍了Python实现的选择排序算法,结合实例形式分析了Python选择排序的概念、原理及简单实现技巧,需要的朋友可以参考下
python 排序（升序或降序）
热门推荐
MM602388的博客
11-16 1万+
#倒序排列 arr = [1, 3, 99, 32, 22, 34, 4, 67, 5, 78, 88, 2, 56] l = len(arr) for i in range(l-1): minindex = i for j in range(i+1,l,1): if arr[j]>arr[minindex]: minindex = j # arr[minindex],arr[i] = arr[i],arr[minindex] .
Python 降序排序
qq_41911146的博客
03-29 8731
Python降序排序有个小技巧，那就是如果是数组i排序可以直接使用（-i）代表降序排序 如def rank(x): s = -x[1]-x[2] a = -x[1] b = x[0] return s,a,b for li in (l1,l2,l3,l4): li = sorted(li,key=rank) 可知，这是按照key的数字前后来确定其排序优先级。 li 先按照s的数值进行...
python简单选择排序_一个Python简单选择排序算法，锻炼编码内功
weixin_39646107的博客
11-21 87
Python简单排序算法： - 在每一趟的比较过程中（与冒泡不同），只比较，不交换位置； - 遍历次数n(n-1)/2； - 时间复杂度O(n**2)； - 与冒泡相比较，减少了交换次数，性能提高。1.1 Python简单快速排序的核心算法：结果可为升序或降序排列，默认升序排列扩大有序区，减小无序区。图中红色部分就是增大的有序区，反之就是减小的无序区 以降序为例相邻元素依次两两比较，获得每一次比较...
Python｜7本算法攻略书，带你进一步了解Python的算法奥秘
weixin_34384915的博客
08-17 359
关注头条号，私信回复资料会有意外惊喜呦………………最后一张照片有资料呦。作为程序员的内功，算法一直是重要的基石。无论开发工具如何进化，熟识并能灵活运用算法仍然是对程序员的基本要求。编程的本质是算法，算法的本质是解决问题，解决问题的本质是获得成就感。那么，哪本算法书又给你带去了成就感呢？今天就来说说那些图灵出版过的算法书，看看哪些是你翻过次数最多的？哪些是被你无情冷落的？我们按语言对这些书进行了分类...
Python排序算法之选择排序定义与用法示例
09-20
主要介绍了Python排序算法之选择排序定义与用法,简单描述了选择排序的功能、原理,并结合实例形式分析了Python定义与使用选择排序的相关操作技巧,需要的朋友可以参考下
python常用排序算法汇总
02-19
该程序包含7大排序算法: # sort.bubbleSort() #冒泡排序 # sort.shellSort() #希尔排序 # sort.insertionSort() #插入排序 # sort.Selectionsort1() #选择排序 # sort.heapSort() #堆排序 # sort.countSort() ...
python实现 路径排序算法_python_代码_下载
06-08
NELL995_data 是NELL995的works_for关系数据集。 DFS.py 深度优先遍历获取基础...model.py 获取实体路经三元组的特征值，train_data.txt是全量的训练数据，第一位表示正例还是反例，其余维度是不同路经对应的特征值。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 889
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Lambda表达式特点
weixin_57763462的博客
04-24 810
**API 设计**：Lambda 表达式鼓励使用函数式接口的设计模式，这改变了 Java 库的设计，例如 `java.util.function` 包下的一系列函数式接口。- **函数式编程**：Lambda 表达式引入了函数式编程的理念，使得 Java 更接近于函数式编程语言，如 Scala 和 Clojure。- **并发编程**：Lambda 表达式与 Java 8 新增的 Stream API 结合使用，可以简化并发编程，特别是与集合的操作相关。
selenium 4.x 入门（环境搭建、八大元素定位）
u014694915的博客
04-26 763
Web自动化测现状1.属于E2E测试2.过去通过点点点3.好的测试，还需要记录、调试网页的细节。
AttributeError: module ‘numpy‘ has no attribute ‘float‘.的解决方法
最新发布
chen_znn的博客
04-30 324
本文记录了AttributeError: module 'numpy' has no attribute 'float'.的解决方法
Python 二叉树的创建与遍历
youyouxiong的博客
04-24 440
在Python中创建二叉树并进行遍历，我们首先需要定义一个二叉树节点类，然后创建二叉树，最后实现几种基本的遍历方法：前序、中序、后序和层序遍历。以下是具体的实现步骤： 2. 创建二叉树 创建二叉树通常是由用户根据需要输入节点值来构建，或者通过特定的算法生成。这里我们手动创建一个简单的二叉树： 3. 实现二叉树的遍历 前序遍历 (Preorder Traversal) 访问根节点，然后递归地遍历左子树，最后递归地遍历右子树。 中序遍历 (Inorder Traversal) 递归地遍历左子
PySide6 GUI 学习笔记——使用资源文件
Humbunklung的专栏
04-27 538
在界面开发中，我们常常将一些图片、图标等资源统一存放到资源文件中供使用，从而让图形界面表达能力更好，更加丰富，譬如带图标的按钮、菜单、窗口等等。PySide6可以将多个图标、图片等资源文件编译到.py文件中，这样可以被我们的程序直接调用，使得资源的管理更加方便。
python中的元类
weixin_40756114的博客
04-25 912
上面说了类是类的实例的模板，所以你看类的__new__被定义为一个绑定的类方法，类本身是作为方法的第一个参数，一般命名为cls，一般情况下，__new__不需要其他的参数，__new__根据cls来产生一个实例，__new__返回产生的实例，也有tuple等少数例外__new__需要额外的参数，绝大多数情况是不需要的。正如类是类的实例的工厂，元类则是类的工厂。不过这两种关系还是有所不同，类是类的实例的模版，但元类不是类的模版，元类更像一个纯粹的类的组装工厂。
笔记：Python 注释（练习题）
欢迎来到我的CSDN博客！在这里，我将分享关于技术、学习和生活的各种笔记和心得体会。无论你是正在学习编程、探索新技术，还是对生活中的点滴有所感悟，我都希望我的博客能够给你带来启发和帮助。
04-27 876
欢迎来到Python注释练习！在这个练习中，我们将探讨Python中注释的重要性和使用方法。注释在代码中扮演着关键的角色，不仅可以提高代码的可读性，还可以帮助其他人理解你的代码逻辑。通过这些练习，你将学习如何正确地编写注释，以及如何使用注释来解释代码的功能、逻辑和设计。无论你是新手还是有经验的Python开发人员，都可以从这些练习中受益。通过实践，你将更加熟悉Python注释的最佳实践，并且能够将其应用到自己的项目中。让我们开始吧！
在win上运行linux qt的项目
关注工业机器人应用
04-26 203
效果明显， 只是没有UR的远程VNC，不影响运行效果。
POC&EXP编写—模块介绍
剁椒鱼头没剁椒的博客
04-26 568
请求方法requests.方法名()# 常见参数url # 请求的urldata # post请求携带的请求体headers # 请求头timeout # 等待时间allow_redirects # 是否运行重定向 , 默认是允许 trueproxies # 代理 , 参数是字典类型 , 示例 :协议 urlverify # ssl证书校验 , 默认是true这里我们在后期添加的时候，需要一个个手动敲上去，那么这里其实可以使用一个bp插件来代替这个过程。
写一个python选择排序算法。
02-13
选择排序算法是一种简单的排序算法，其基本思想是：每一趟从待排序的数列中选出最小（或最大）的一个元素，存放到序列的起始位置，直到全部待排序的数据元素排完。 下面是 Python 代码实现： ``` def selection_sort(arr): for i in range(len(arr) - 1): # 寻找最小值的索引 min_index = i for j in range(i + 1, len(arr)): if arr[j] < arr[min_index]: min_index = j # 交换最小值和列表第一个元素 arr[i], arr[min_index] = arr[min_index], arr[i] return arr ``` 使用方法： ``` arr = [64, 25, 12, 22, 11] sorted_arr = selection_sort(arr) print(sorted_arr) ``` 输出： ``` [11, 12, 22, 25, 64] ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值