排序算法
一.快速排序
# 递归有返回
def Qsort(L):
if len(L) <= 1: return L
return Qsort([low for low in L[1:] if low < L[0]]) + L[0:1]+ \
Qsort([high for high in L[1:] if high >= L[0]])
# 非递归无返回
def quick_sort(L, low, high):
key = L[low]
while low < high:
while low < high and L[high] >= key:
high -= 1
L[low] = L[high]
while low < high and L[low] <= key:
low += 1
L[high] = L[low]
L[low] = key
return low
def Qsort(L, low, high):
if low < high:
pivotloc = qucksort(L, low, high)
Qsort(L, low, pivotloc-1)
Qsort(L, pivotloc+1, high)
二.冒泡排序
概念:重复走访待排数列,一次比较两个元素,若顺序错误就互相交换,直到走访到末尾,排序完成。(每次走访数列都会将数列中较大的数通过交换'浮'到数列的尾端,故名冒泡排序)。
思路:
1. 遍历列表,对其中每一对相邻的两个元素进行比较,若第一个比第二个大就进行交换。
2.通过第一步将最大的元素交换到列表末尾,然后排除该元素,对前面的所有元素进行第1步操作。
3.重复进行前面两步操作。
# 双重for循环
def bubble_sort(A):
length = len(A)
for index in range(length):
for i in range(1, length-index):
if A[i-1] > A[i]:
A[i-1], A[i] = A[i], A[i-1]
return A
# for循环嵌套while循环
def bubble_sort(A):
length = len(A)
for i in range(length):
j = 1
while j < length-i:
if A[j-1] > A[j]:
A[j-1], A[j] = A[j], A[j-1]
return A
# 反过来排序
def bubble_sort(A):
length = len(A)
for i in range(length):
j = length-1
while j >= i:
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
j -= 1
return A
# 优化算法
def bubble_sort(A):
length = len(A)
for index in range(length):
flag = True
for i in range(1, length-index):
if A[i-1] > A[i]:
A[i-1], A[i] = A[i], A[i-1]
flag = False
if flag:
return A
return A
三.选择排序
概念:从待排数列中选出最大(或最小)的一个元素,存放在数列的起始位置,直至数列排完。
思路:
1.将列表中第一个元素与其后所有元素进行比较,碰到较小的便与之交换。
2.排除第1步中选出的元素,对剩下的元素进行第1步操作。
3.重复上述操作。
# 双重for循环
def select_sort(A):
length = len(A)
for index in range(length):
for i in range(index+1, length):
if A[index] > A[i]:
A[index], A[i] = A[i], A[index]
return A
四.插入排序
概念:第一个元素必有序,将数组中未排序的元素插入到有序的元素中,从而得到一个新的有序数组。
思路:
第一个元素为有序元素,将后面的元素依次记为待插入元素,与前面的有序元素从后至前比较,然后进行插入。
def insert_sort(A):
length = len(A)
for i in range(1, length):
key = A[i]
j = i-1
while j >= 0:
if A[j] > key:
A[j+1] = A[j]
A[j] = key
j -= 1
return A
def insert_sort(A):
length = len(A)
for i in range(1, length):
key = A[i]
j = i
while j >= 1 and A[j-1] > key:
A[j] = A[j-1]
j -= 1
A[j] = key
return A
五.归并排序
概念:将两个有序数组归并为一个有序数组。
思路
1.创建一个新数组,将第一个数组的每个元素与第二个数组的每个元素进行比较,将每次比较中较小的元素添加到新数组中,直至第一个数组的所有元素比较完。
2.若第二个数组的元素未比较完,则将第二个数组剩下的元素添加到新数组中。
def merge_sort(A, B):
len1 = len(A)
len2 = len(B)
C = []
j = 0
for i in range(len1):
while j < len2 and A[i] > B[j]:
C.append(B[j])
j += 1
C.append(A[i])
if j < len2:
C.extend(B[j:]) # C = C + B[j:]
return C
六.希尔排序
优化版插入排序
# 希尔排序
def shell_sort(A):
length = len(A)
gap = length // 2
while gap > 0:
for i in range(gap, length):
temp = A[i]
j = i
while j >= gap and A[j-gap] > temp:
A[j] = A[j-gap]
j -= gap
A[j] = temp
gap //= 2
print(A)
return A
A = [1, 2, 4, 1, 3, 6, 4, 5, 9]
shell_sort(A)
[1, 2, 4, 1, 3, 6, 4, 5, 9]
[1, 1, 3, 2, 4, 5, 4, 6, 9]
[1, 1, 2, 3, 4, 4, 5, 6, 9]
[1, 1, 2, 3, 4, 4, 5, 6, 9]
七.堆排序
八.计数排序
def count_sort(A):
Max = Min = 0
for each in A:
if each < Min:
Min = each
if each > Max:
Max = each
count = [0] * (Max-Min+1)
# 将A中元素出现的次数放入count中
for i in A:
count[i-Min] += 1
index = 0
for j in range(Max-Min+1):
for k in range(count[j]):
A[index] = j+Min
index += 1
return A