python简单选择排序_一个Python简单选择排序算法，锻炼编码内功-CSDN博客

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)

[65, 3, 1, 7, 2]

[65, 7, 1, 3, 2]

[65, 7, 3, 1, 2]

[65, 7, 3, 2, 1]