本帖记录排序算法的原理和Python实现
持续更新中!!!
选择排序
# 基本排序算法:选择排序、冒泡排序、插入排序
# 一、选择排序
# 思想:搜索整个列表,找到最小项的位置,如果该位置不是列表的第一个位置,就会交换,
# 然后返回到列表第2个位置并重复该位置,重复该方法
def selectionSort(lyst):
for i in range(len(lyst)):
minIndex = i
for j in range(i+1, len(lyst)):
if lyst[minIndex] > lyst[j]:
minIndex = j
lyst[i], lyst[minIndex] = lyst[minIndex], lyst[i]
return lyst
冒泡排序
# 冒泡排序:从列表的开头开始,比较一对数据项,直到移动到列表的末尾,每当成对的两项间顺序不正确的时候,就交换位置,该过程的效果就是将最大的项以冒泡的方式拍到列表的末尾
# 对已经排好序的列表来说,其性能比选择排序的性能要好
def bubbleSort(lyst):
n = len(lyst)
for i in range(n):
for j in range(0, n-1-i):
if lyst[j] > lyst[j+1]:
lyst[j], lyst[j+1] = lyst[j+1], lyst[j]
return lyst
插入排序
# 插入排序:是一种简单直观的排序算法。
# 它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
def insertionSort(lyst):
for i in range(1, len(lyst)):
# 当前需要插入的元素
key = lyst[i]
# 比较元素位置
j = i - 1
while j >= 0 and key < lyst[j]:
# 当比较元素大于当前元素,则把比较元素后移
lyst[j+1] = lyst[j]
# 往前选择下一个比较元素
j -= 1
# 当比较元素小于当前元素,则将当前元素插在其后面
lyst[j+1] = key
return lyst
快速排序
# 更快的排序:快速排序和合并排序 复杂度为O(nlogn)
# 分而治之,将列表分解为更小的子列表,随后将这些子列表再递归地排序
# 快速排序:使用分治法(Divide and conquer)策略来把一个序列(list)分为较小和较大的2个子序列,然后递归地排序两个子序列。
# 1. 在数列之中,选择一个元素作为”基准”(pivot),或者叫比较值。
# 2. 数列中所有元素都和这个基准值进行比较,如果比基准值小就移到基准值的左边,如果比基准值大就移到基准值的右边
# 3. 以基准值左右两边的子列作为新数列,不断重复第一步和第二步,直到所有子集只剩下一个元素为止
def partition(lyst, low, high):
# 最小元素索引,low为起始索引,high为结束索引
i = low - 1
# 基准点
pivot = lyst[high]
for j in range(low, high):
# 当前元素小于或等于pivot
if lyst[j] <= pivot:
i = i + 1
lyst[i], lyst[j] = lyst[j], lyst[i]
lyst[i+1], lyst[high] = lyst[high], lyst[i+1]
return (i + 1)
def quickSortHelper(lyst, low, high):
if low < high:
pivotLocation = partition(lyst, low, high)
quickSortHelper(lyst, low, pivotLocation - 1)
quickSortHelper(lyst, pivotLocation + 1, high)
return lyst
def quickSort(lyst):
quickSortHelper(lyst, 0, len(lyst) - 1)
return lyst
# 快速排序——递归方法
def quicksort(lyst):
if len(lyst) <= 1:
return lyst
pivot = lyst[len(lyst) // 2]
left = [i for i in lyst if i < pivot]
middle = [i for i in lyst if i == pivot]
right = [i for i in lyst if i > pivot]
return quicksort(left) + middle + quicksort(right)
归并排序
# 合并排序或归并排序
#步骤:
# 计算一个列表的中间位置,并且递归地排序其左边和右边的子列表
# 将两个排好序的子列表重新合并为单个的排好序的列表
# 当子列表不再能够划分的时候,停止这个过程
def merge(a,b):
c = []
h = j = 0
while j < len(a) and h < len(b):
if a[j] < b[h]:
c.append(a[j])
j += 1
else:
c.append(b[h])
h += 1
if j == len(a):
for i in b[h:]:
c.append(i)
else:
for i in a[j:]:
c.append(i)
return c
def mergeSort(lyst):
if len(lyst) <= 1:
return lyst
middle = len(lyst) // 2
left = mergeSort(lyst[:middle])
right = mergeSort(lyst[middle:])
return merge(left, right)
全部代码:
# 一、选择排序
# 思想:搜索整个列表,找到最小项的位置,如果该位置不是列表的第一个位置,就会交换,
# 然后返回到列表第2个位置并重复该位置,重复该方法
def selectionSort(lyst):
for i in range(len(lyst)):
minIndex = i
for j in range(i+1, len(lyst)):
if lyst[minIndex] > lyst[j]:
minIndex = j
lyst[i], lyst[minIndex] = lyst[minIndex], lyst[i]
return lyst
# 冒泡排序:从列表的开头开始,比较一对数据项,直到移动到列表的末尾,每当成对的两项间顺序不正确的时候,就交换位置,该过程的效果就是将最大的项以冒泡的方式拍到列表的末尾
# 对已经排好序的列表来说,其性能比选择排序的性能要好
def bubbleSort(lyst):
n = len(lyst)
for i in range(n):
for j in range(0, n-1-i):
if lyst[j] > lyst[j+1]:
lyst[j], lyst[j+1] = lyst[j+1], lyst[j]
return lyst
# 插入排序:是一种简单直观的排序算法。
# 它的工作原理是通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。
def insertionSort(lyst):
for i in range(1, len(lyst)):
# 当前需要插入的元素
key = lyst[i]
# 比较元素位置
j = i - 1
while j >= 0 and key < lyst[j]:
# 当比较元素大于当前元素,则把比较元素后移
lyst[j+1] = lyst[j]
# 往前选择下一个比较元素
j -= 1
# 当比较元素小于当前元素,则将当前元素插在其后面
lyst[j+1] = key
return lyst
# 更快的排序:快速排序和合并排序 复杂度为O(nlogn)
# 分而治之,将列表分解为更小的子列表,随后将这些子列表再递归地排序
# 快速排序:使用分治法(Divide and conquer)策略来把一个序列(list)分为较小和较大的2个子序列,然后递归地排序两个子序列。
# 1. 在数列之中,选择一个元素作为”基准”(pivot),或者叫比较值。
# 2. 数列中所有元素都和这个基准值进行比较,如果比基准值小就移到基准值的左边,如果比基准值大就移到基准值的右边
# 3. 以基准值左右两边的子列作为新数列,不断重复第一步和第二步,直到所有子集只剩下一个元素为止
def partition(lyst, low, high):
# 最小元素索引,low为起始索引,high为结束索引
i = low - 1
# 基准点
pivot = lyst[high]
for j in range(low, high):
# 当前元素小于或等于pivot
if lyst[j] <= pivot:
i = i + 1
lyst[i], lyst[j] = lyst[j], lyst[i]
lyst[i+1], lyst[high] = lyst[high], lyst[i+1]
return (i + 1)
def quickSortHelper(lyst, low, high):
if low < high:
pivotLocation = partition(lyst, low, high)
quickSortHelper(lyst, low, pivotLocation - 1)
quickSortHelper(lyst, pivotLocation + 1, high)
return lyst
def quickSort(lyst):
quickSortHelper(lyst, 0, len(lyst) - 1)
return lyst
# 快速排序——递归方法
def quicksort1(lyst):
if len(lyst) <= 1:
return lyst
pivot = lyst[len(lyst) // 2]
left = [i for i in lyst if i < pivot]
middle = [i for i in lyst if i == pivot]
right = [i for i in lyst if i > pivot]
return quicksort(left) + middle + quicksort(right)
# 合并排序或归并排序
# 计算一个列表的中间位置,并且递归地排序其左边和右边的子列表
# 将两个排好序的子列表重新合并为单个的排好序的列表
# 当子列表不再能够划分的时候,停止这个过程
def merge(a,b):
c = []
h = j = 0
while j < len(a) and h < len(b):
if a[j] < b[h]:
c.append(a[j])
j += 1
else:
c.append(b[h])
h += 1
if j == len(a):
for i in b[h:]:
c.append(i)
else:
for i in a[j:]:
c.append(i)
return c
def mergeSort(lyst):
if len(lyst) <= 1:
return lyst
middle = len(lyst) // 2
left = mergeSort(lyst[:middle])
right = mergeSort(lyst[middle:])
return merge(left, right)
if __name__ == '__main__':
lyst = [5,3,1,2,4]
s_sort = selectionSort(lyst)
print(s_sort)
b_sort = bubbleSort(lyst)
print(b_sort)
i_sort = insertionSort(lyst)
print(i_sort)
q_sort = quickSort(lyst)
print(q_sort)
q_sort1 = quicksort1(lyst)
print(q_sort1)
m_sort = mergeSort(lyst)
print(m_sort)