冒泡/选择排序

常见python排序

#任意列表的冒泡排序
def sort(lt,key = None,reverse = False):
    n = len(lt)
    for i in range(n-1):
        for j in range(n-1-i):
            if key:
                ret = key(lt[j]) < key(lt[j + 1]) if reverse else key(lt[j]) > key(lt[j+1])
            else:
                ret = lt[j] < lt[j + 1] if reverse else lt[j] > lt[j + 1]

            if ret:
                lt[j], lt[j + 1] = lt[j + 1], lt[j]
    return lt

lt =[{'name':'jim','age':18, 'sort':78},
    {'name':'sun','age':25, 'sort':98},
    {'name':'aer','age':22, 'sort':60},
    {'name':'cid','age':24, 'sort':85}
]
print(sort(lt,key=lambda x:x['sort'],reverse = False))
for i in lt:
    print(i)

#选择排序

def sort_lt(lt,key = None,reverse =False):
    n = len(lt)
    for i in range(n-1):
        for j in range(i+1,n):
            if key:
                ret = key(lt[i]) < key(lt[j ]) if reverse else key(lt[i]) > key(lt[j ])
            else:
                ret = lt[i] < lt[j ] if reverse else lt[i] > lt[j ]
            if ret:
                lt[i], lt[j ] = lt[j ], lt[i]
    return lt

 #快排
 def  sort(lt):
 	if len(lt) < 2:
 		return lt
 	a = []
 	b = []
 	middle = lt.pop()
 	for i in lt:
 		if i < middle:
 			a.append(i)
 		else:
 			b.append(i)
 	return sort(a) + [middle] + sort(b)



#归并排序

def sort(lt):
	if len(lt) < 2:
		return lt
	sortedlist = []
	left = sort(lt[:len(lt/2)])
	right = sort(lt[len(lt/2):])

	while len(left) > 0 and len(right) > 0:
		if left[0]< right[0]:
			sortedlist.append(left.pop(0))
		else:
			sortedlist.append(right.pop(0))
	if len(left) > 0:
		sortedlist.extend(sort(left))
	else:
		sortedlist.extend(sort(right))
	return sortedlist

#二分查找
def binary_chop(alist, data):
    n = len(alist)
    first = 0
    last = n - 1
    while first <= last:
        mid = (last + first) // 2
        if alist[mid] > data:
            last = mid - 1
        elif alist[mid] < data:
            first = mid + 1
        else:
            return True
    return False

if __name__ == '__main__':
    lis = [2,4, 5, 12, 14, 23]
    if binary_chop(lis, 14):
        print('ok')

快速查找


def quick_sort(lt,start,end):
    if start >end:
        return 
    mid = lt[start]
     # low为序列左边的由左向右移动的游标
    low = start
     # high为序列右边的由右向左移动的游标 
    high = end 
    while low < high:
        # 如果low与high未重合，high指向的元素不比基准元素小，则high向左移动
        while low < high and lt[high] >= mid:
            high -=1

            # 将high指向的元素放到low的位置上 
        alist[low] = alist[high]
        # 如果low与high未重合，low指向的元素比基准元素小，则low向右移动
        while low < high and lt[low] < mid:
            low += 1

        alist[high] = alist[low]
    # 退出循环后，low与high重合，此时所指位置为基准元素的正确位置 
    # 将基准元素放到该位
    alist[low] = mid
    # 对基准元素左边的子序列进行快速排
    quick_sort(alist， start， low-1)

    # 对基准元素右边的子序列进行快速排序 
    quick_sort(alist， low+1， end)