---

一、引言

问题提出

  给你一个整数数组 nums，请你将该数组升序排列。

示例 1：
输入：nums = [5,2,3,1]
输出：[1,2,3,5]

二、排序算法

1.选择排序（Selection Sort）

  工作原理，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。算法复杂度O(n^2)

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # selection sort 
        n = len(nums)
        for i in range(n):
            for j in range(i,n):
                if nums[i] > nums[j]:
                    nums[i],nums[j] = nums[j],nums[i]
                    #print(nums)
        return nums

2.冒泡排序

  冒泡排序时针对相邻元素之间的比较，可以将大的数慢慢“沉底”(数组尾部)。左边大于右边交换一趟排下来最大的在右边。算法复杂度O(n^2)

def bubble_sort(nums):
    n = len(nums)
    # 进行多次循环
    for c in range(n):
        for i in range(1, n - c):#一轮排好一个。故是n-c
            if nums[i - 1] > nums[i]:
                nums[i - 1], nums[i] = nums[i], nums[i - 1]
    return nums

3.插入排序（Insertion Sort）

  (打扑克抓牌，放入合适位置）：每次将无序区第一个值与有序区作比较，选择合适的插入位置。从有序区最后一个值开始比较，满足条件则进行交换，不断逼近最合适的插入位置。因为在有序区域插入了一个值，所以有序区比待插入值大的值索引都后移了一位。。算法复杂度O(n^2)

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # insert sort 
        n = len(nums)
        for i in range(1,n):
        #从前面排序好的数组找到位置
            while i > 0 and nums[i-1] > nums[i]:
                nums[i-1],nums[i] = nums[i],nums[i-1]
                i -= 1
        return nums

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        for i in range(1,len(nums)):
            tmp=nums[i]                 # 待插入位置的值，即无序区第一位的值
            j=i-1                       # 指针指向待插入位置左边的值，即有序区最后一位
            while tmp<nums[j] and j>-1: # 待插入的值与指针位置的值作比较，更小则插入
                nums[j+1]=nums[j]
                nums[j]=tmp
                j-=1                    # 指针左移，将待插入值与更小的值作比较，不断逼近最合适的插入位置
        return nums     

4.希尔排序（Shell Sort）

  插入排序进阶版。的执行思路是：把数组内的元素按下标增量分组，对每一组元素进行插入排序后，缩小增量并重复之前的步骤，直到增量到达1。

def shell_sort(nums):
    n = len(nums)
    gap = n // 2
    while gap:
        for i in range(gap, n):
            while i - gap >= 0 and nums[i - gap] > nums[i]:
                nums[i - gap], nums[i] = nums[i], nums[i - gap]
                i -= gap
        gap //= 2
    return nums

5.归并排序（Merge Sort）

  归并排序，采用是分治法，先将数组分成子序列，让子序列有序，再将子序列间有序，合并成有序数组。时间复杂度：O(nlogn)。

def merge_sort(nums):
    if len(nums) <= 1:
        return nums
    mid = len(nums) // 2
    # 分
    left = merge_sort(nums[:mid])
    right = merge_sort(nums[mid:])
    # 合并
    return merge(left, right)


def merge(left, right):
    res = []
    i = 0
    j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

6.快速排序（Quick Sort）

  快速排序是选取一个“哨兵”(pivot)，将小于pivot放在左边，把大于pivot放在右边，分割成两部分，并且可以固定pivot在数组的位置，在对左右两部分继续进行排序。

  快速排序使用分治法来把一个串（list）分为两个子串（sub-lists）。具体算法描述如下：

• 步骤1：从数列中挑出一个元素，称为 “基准”（pivot ）；
• 步骤2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 步骤3：递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

def quickSort(nums):
    if len(nums) >= 2:
        mid = nums[len(nums) // 2]
        nums.remove(mid)
        low = []
        high = []
        for num in nums:
            if num <= mid:
                high.append(num)
            else:
                low.append(num)
        return quickSort(high) + [mid] + quickSort(low)
    else:
        return nums

nums=[3,4,1,5,7]
print(quickSort(nums))

import random
 
def partition(left, right, nums):
    tmp = nums[left]
    while left < right:
        while left < right and nums[right] >= tmp:
            right -= 1
        nums[left] = nums[right] #
        while left < right and nums[left] <= tmp:
            left += 1
        nums[right] = nums[left]    
    nums[left] = tmp    
    return left
 
def quick_sort(left,right, nums):
    "左右两侧，各自有序"
    if left < right:
        mid = partition(left, right, nums)
        quick_sort(left, mid-1, nums)
        quick_sort(mid + 1, right, nums)
    return nums
 
if __name__ == "__main__":
    nums = [i for i in range(10)]
    random.shuffle(nums)
    print(nums)
    print(quick_sort(0, len(nums)-1, nums))

7.堆排序（Heap Sort）

  完全二叉树：
  叶子节点只能出现在最下层和次下层，并且最下面一层的节点都集中在该层最左边的若干位置的二叉树。
  堆：一种特殊的完全二叉树结构
  大根堆：一颗完全的二叉树，满足任意节点都比其他孩子节点大
  小根堆：一颗完全的二叉树，满足任意节点都比其他孩子节点小

import random
 #大根堆
def sift(nums, low, high):
    """向下调整"""
    i = low  # 当前根节点
    j = 2 * i + 1   # 根节点对应的左孩子
    tmp = nums[low]
    while j <= high:
        if j+1 <= high and nums[j+1] > nums[j]: # 如果右孩子存在且大于左孩子，那么指针指向右孩子
            j = j+1  
        if nums[j] > tmp: # 如果大孩子比根节点大，则右孩子赋给根节点，指针再向下看一层
            nums[i] = nums[j]
            i = j
            j = 2 * i + 1
        else: # 大孩子<根节点，跳出
            nums[i] = tmp #tmp放在某一级领导位置上
            break   
    else:         # 把tmp放在叶子节点上
        nums[i] = tmp        
 
def heap_sort(nums):
    """建堆，农村包围城市，从堆的下面逐步调用sift"""
    n = len(nums)
    for i in range((n-1-1)//2, -1, -1): # 从最后一个根节点开始调整
        sift(nums, i, n-1)
    for i in range(n-1, -1, -1):  # 从小到大输出
        nums[0], nums[i] = nums[i], nums[0]
        sift(nums, 0, i-1)
    return nums
 
if __name__ == "__main__":
    nums = [_ for _ in range(20)]
    random.shuffle(nums)
    print(nums)
    print(heap_sort(nums))