python选择排序算法代码,python3快速排序
本文主要介绍了Python3中自定义比较排序/运算符的实现，具有很好的参考价值。希望对你有帮助。如有错误或不足之处，请不吝赐教。
00-1010自定义比较排序/运算符1.cmp函数2。重写类方法Python3来实现各种排序方法
目录
Python3相比Python2有很多变化。
在Python2中，可以直接写一个cmp函数作为参数传入sort来自定义排序，但是Python3取消了它。
这里总结了用Python3编写自定义排序的两种方法。欢迎补充。
我们把二维空间中的点作为要排序的数据结构，希望先比较X再比较y。
Pos:级
def __init__(self，x=0，y=0):
self.x=x
self.y=y
def __str__(self):
return((% s，%s) % (self.x，self.y))
__repr__=__str__
自定义比较排序/运算符
第一种方法是重写cmp或lambda表达式，类似于Python2。
请注意，此方法无法使用sorted成功排序。
只有在functools的帮助下
导入功能工具
def cmp(a，b):
如果a.x，返回a.x-b.x！=b.x else a.y-b.y # x y按照从小到大的顺序。
if __name__==__main__:
test _ list=[位置(5，1)，位置(2，5)，位置(2，4)]
# test _ list . sort(key=func tools . CMP _ to _ key(lambda a，b: a.x-b.x if a.x！=b.x else a.y-b.y))
test _ list . sort(key=func tools . CMP _ to _ key(CMP))
# sorted (test _ list，key=func tools . CMP _ to _ key(CMP))#此方法无法成功排序。
Print(test_list) #输出结果[(2，4)，(2，5)，(5，1)]
1.cmp函数
在Python2中可以直接重写__cmp__方法来实现比较，但是在Python3中已经取消了。
Python3需要细分每个比较运算符。
__lt__:
__gt__:
__ge__:=
__eq__:==
__le__:=
实施如下
Pos:级
def __init__(self，x=0，y=0):
self.x=x
self.y=y
def __str__(self):
return((% s，%s) % (self.x，self.y))
def __lt__(自己，其他):
打印( lt: str(self))
如果self.x返回self.x other.x！=other . x El self . y other . y
def __gt__(自己，其他):
打印( gt: str(self))
如果self.x返回self.x other.x！=other . x El self . y other . y
def __ge__(自己，其他):
print(ge: str(self))
如果self.x返回self.x=other.x！=other.x else self.y=其他. y
极好的
__eq__(self, other):
print(eq: + str(self))
return self.x == other.x and self.y == other.y
def __le__(self, other):
print(le: + str(self))
return self.x <= other.x if self.x != other.x else self.y <= other.y
__repr__ = __str__
我们实践一下
if __name__ == __main__:if Pos(5,1) <= Pos(2,4):
print(True!)
if Pos(5,1) == Pos(2,4):
print(True!)
if Pos(5,1) > Pos(2,4):
print(True!)
# 输出
# le: (5, 1)
# eq: (5, 1)
# gt: (5, 1)
# True!
最后我们回到排序
if __name__ == __main__:test_list = [Pos(5, 1), Pos(2,5), Pos(2, 4)]
test_list.sort()
print(test_list)
test_list.sort(reverse=True)
print(test_list)
# 输出
# lt: (2, 5)
# lt: (2, 4)
# [(2, 4), (2, 5), (5, 1)]
# lt: (2, 5)
# lt: (2, 4)
# [(5, 1), (2, 5), (2, 4)]
Python3实现各种排序方法
# coding=gbkimport random
from array import array
def swap(lyst,i,j):
temp = lyst[i]
lyst[i] = lyst[j]
lyst[j] = temp
#选择排序，复杂度O(n^2)
def selectionSort(lyst):
i = 0
while i < len(lyst) - 1:
minIndex = i
j = i + 1
while j < len(lyst):
if lyst[j] < lyst[minIndex]:
minIndex = j
j += 1
if minIndex != i:
swap(lyst,minIndex,i)
i += 1
#冒泡排序，复杂的O(n^2)
def bubbleSort(lyst):
n = len(lyst)
while n > 1:
i = 1
while i < n:
if lyst[i] < lyst[i-1]:
swap(lyst,i,i-1)
i += 1
n -= 1
#冒泡排序优化改进最好情况
def bubbleSortWithTweak(lyst):
n = len(lyst)
while n > 1:
swapped = False
i = 1
while i < n:
if lyst[i] < lyst[i-1]:
swap(lyst,i,i-1)
swapped = True
i += 1
if not swapped: return
n -= 1
#插入排序，复杂的O(n^2)
def insertionSort(lyst):
i = 1
while i < len(lyst):
itemToInsert = lyst[i]
j = i - 1
while j >= 0:
if itemToInsert < lyst[j]:
lyst[j+1] = lyst[j]
j -= 1
else:
break
lyst[j+1] = itemToInsert
i += 1
#快速排序,最好情况，复杂的O(n*(log2 n))，最坏情况，复杂的O(n^2)
def quicksort(lyst):
quicksortHelper(lyst,0,len(lyst)-1)
def quicksortHelper(lyst,left,right):
if left < right:
pivotLocation = partition(lyst,left,right)
quicksortHelper(lyst,left,pivotLocation-1)
quicksortHelper(lyst,pivotLocation+1,right)
def partition(lyst,left,right):
middle = (left+right) // 2
pivot = lyst[middle]
lyst[middle] = lyst[right]
lyst[right] = pivot
boundary = left
for index in range(left,right):
if lyst[index] < pivot:
swap(lyst,index,boundary)
boundary += 1
swap(lyst,right,boundary)
return boundary
#合并排序
def mergeSort(lyst):
copyBuffer = [0]*(len(lyst))
mergeSortHelper(lyst,copyBuffer,0,len(lyst)-1)
def mergeSortHelper(lyst,copyBuffer,low,high):
if low < high:
middle = (low+high)//2
mergeSortHelper(lyst,copyBuffer,low,middle)
mergeSortHelper(lyst,copyBuffer,middle+1,high)
merge(lyst,copyBuffer,low,middle,high)
def merge(lyst,copyBuffer,low,middle,high):
i1 = low
i2 = middle + 1
for i in range(low,high+1):
if i1 > middle:
copyBuffer[i] = lyst[i2]
i2 += 1
elif i2 > high:
copyBuffer[i] = lyst[i1]
i1 += 1
elif lyst[i1] < lyst[i2]:
copyBuffer[i] = lyst[i1]
i1 += 1
else :
copyBuffer[i] = lyst[i2]
i2 += 1
for i in range(low,high+1):
lyst[i] = copyBuffer[i]
def main(size = 20,sort = mergeSort):
lyst = []
for count in range(size):
lyst.append(random.randint(1,size+1))
print(lyst)
sort(lyst)
print(lyst)
if __name__ == "__main__":
main()
以上为个人经验，希望能给大家一个参考，也希望大家多多支持盛行IT软件开发工作室。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。