Leetcode刷题——数组排序

算法简介

• 排序稳定性
  如果排序前序列中x领先于y，排序后x仍领先于y，则称该排序方法是稳定的；反之为不稳定的。
  
  

1. 冒泡排序
   是一种交换排序，两两比较相邻记录，如果反序就交换，直到没有反序的记录为止，使得较小的数字如同气泡般上浮。
   

def bubbleSort(arr):
    for i in range(len(arr)):
    	flag = FLASE
        for j in range(len(arr) - i - 1):
            if arr[j] > arr[j + 1]:
            	arr[j], arr[j + 1] = arr[j + 1], arr[j]
            	flag = TRUE
            if not flag:
            	break   
    return arr

• 算法优化
  • 添加标记变量flag
    当没有任何数据交换时，说明序列已有序，增加flag标记，避免无意义的循环判断。
  • 鸡尾酒排序——在特定条件下减少排序回合数，但代码量增加了。

def cocktail_sort(iterable):
    '''鸡尾酒排序（英语：Cocktail Sort/Shaker Sort）是冒泡排序的轻微变形，
    它还有很多奇怪的名字，双向冒泡排序 (Bidirectional Bubble Sort)、
    波浪排序 (Ripple Sort)、摇曳排序 (Shuffle Sort)、
    飞梭排序 (Shuttle Sort) 和欢乐时光排序 (Happy Hour Sort)
    原理：
     1. 对序列向尾部做升序冒泡排序，最大元素沉落尾部。
     2. 对序列向头部做降序冒泡排序，最小元素升到头部。
     3. 交替重复步骤1、2，逐渐缩小无序元素范围，直到没有无序元素。
    时间复杂度：O(n^2)
    稳定性： 稳定
    '''
    for i in range(len(iterable) - 1, 0, -1):
        bubbled = 0

        for j in range(i):
            if iterable[j] > iterable[j + 1]:
                iterable[j], iterable[j + 1] = iterable[j + 1], iterable[j]
                bubbled = 1
        
        for j in range(i, 0, -1):
            if iterable[j] < iterable[j - 1]:
                iterable[j], iterable[j - 1] = iterable[j - 1], iterable[j]
                bubbled = 1

        if not bubbled: break

    return iterable

2. 选择排序
   每一趟排序中，从剩余未排序元素中选择一个最小的元素，与未排好序的元素最前面的那个元素交换位置。
   

def selectionSort(arr):
    for i in range(len(arr) - 1):
        # 记录未排序序列中最小数的索引
        min_i = i
        for j in range(i + 1, len(arr)):
            if arr[j] < arr[min_i]:
                min_i = j
        # 如果找到最小数，将 i 位置上元素与最小数位置上元素进行交换
        if i != min_i:
            arr[i], arr[min_i] = arr[min_i], arr[i]
            
    return arr

4. 插入排序
   将一个记录插入到已经排好序的有序表中，从而得到一个新的、记录数增1的有序表，需要一个记录的辅助空间。
   

def insertionSort(arr):
    for i in range(1, len(arr)):
        temp = arr[i]
        j = i
        while j > 0 and arr[j - 1] > temp:
            arr[j] = arr[j - 1]
            j -= 1
        arr[j] = temp
        
    return arr

6. 希尔排序
   将整个序列切按照一定的间隔取值划分为若干个子序列，每个子序列分别进行插入排序。然后逐渐缩小间隔进行下一轮划分子序列和插入排序。直至最后一轮排序间隔为 1，对整个序列进行插入排序。
   满足基本有序：小的关键字基本在前面，大的基本在后面，不大不小基本在中间。可以将相距某个“增量”的记录组成一个子序列，这样保证子序列分别进行直接插入排序后得到的结果是基本有序而不是局部有序。
   
   
   

def shellSort(arr):
	size = len(arr)
    gap = size // 2
    
    while gap > 0:
        for i in range(gap, size):
            temp = arr[i]
            j = i
            while j >= gap and arr[j - gap] > temp:
                arr[j] = arr[j - gap]
                j -= gap
            arr[j] = temp
        gap = gap // 2
    return arr

8. 归并排序
   采用经典的分治策略，先递归地将当前序列平均分成两半。然后将有序序列两两合并，最终合并成一个有序序列。
   
   

def merge(left_arr, right_arr):
    arr = []
    while left_arr and right_arr:
        if left_arr[0] <= right_arr[0]:
            arr.append(left_arr.pop(0))
        else:
            arr.append(right_arr.pop(0))
    while left_arr:
        arr.append(left_arr.pop(0))
    while right_arr:
        arr.append(right_arr.pop(0))
    return arr

def mergeSort(arr):
    size = len(arr)
    if size < 2:
        return arr
    mid = len(arr) // 2
    left_arr, right_arr = arr[0: mid], arr[mid:]
    return merge(mergeSort(left_arr), mergeSort(right_arr))

10. 快速排序
    通过一趟排序将无序序列分为独立的两个序列，第一个序列的值均比第二个序列的值小。然后递归地排列两个子序列，以达到整个序列有序。
    

• 优化
  • 优化枢轴选取
  • 优化不必要的交换——采用替换而不是交换的方式进行操作
  • 优化小数组的排序方案——当high-low 不大于7时，就用直接插入排序，综合利用两种优势完成排序
  • 优化递归操作——尾递归优化，采用迭代而不是递归的方式缩减堆栈深度

import random
#随机选取枢纽法优化：pi为low与high之间的随机值；
#还有三数取中、九数取中等方式用于选择pi
def randomPartition(arr: [int], low: int, high: int):
		i = random.randint(low, high)
		arr[i], arr[high] = arr[high], arr[i]
		return partition(arr, low, high)

def partition(arr: [int], low: int, high: int):
	x = arr[high]
	i = low - 1
	for j in range(low, high):
		if arr[j] <= arr[high]:
			i += 1
			arr[i], arr[j] = arr[j], arr[i]
	arr[i + 1], arr[high] = arr[high], arr[i + 1]