Pyton：912. 排序数组 —— 给你一个整数数组 nums，请你将该数组升序排列

@创建于：2021.11.18

LeeCode 912. 排序数组
给你一个整数数组 nums，请你将该数组升序排列。
https://leetcode-cn.com/problems/sort-an-array/submissions/

1、python自带排序

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        return sorted(nums)

3、插入排序

3.1 算法思想

插入排序（Insertion Sort）基本思想：
将整个序列切分为两部分：前 i - 1 个元素是有序序列，后 n - i + 1 个元素是无序序列。每一次排序，将无序序列的首元素，在有序序列中找到相应的位置并插入。
插入排序方法属于稳定性排序方法。
算法时间复杂度： $O(n^2)$
算法空间复杂度：$O(1)$

3.2 步骤与演示

• 将第一个元素作为一个有序序列，将第 2 ~ n - 1 个元素作为无序序列。
• 从头至尾一次扫描无序序列，将扫描到的每个元素插入到有序序列的适当位置上。

3.3 代码实践

LeeCode显示超时！

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        
        for i in range(n):
            tmp = nums[i]
            j = i

            while (j>0) and (nums[j-1]>tmp):
                nums[j] = nums[j-1]
                j -= 1
            nums[j] = tmp
        return nums

4、希尔排序

4.1 算法思想

希尔排序（Shell Sort）基本思想：
将整个序列切按照一定的间隔取值划分为若干个子序列，每个子序列分别进行插入排序。然后逐渐缩小间隔进行下一轮划分子序列和插入排序。直至最后一轮排序间隔为 1，对整个序列进行插入排序。
希尔排序方法是一种不稳定排序算法。
算法时间复杂度：$O(nlo{g}_{2}n)$ 与 $O(n^2)$之间
算法空间复杂度：$O(1)$

4.2 步骤与演示

• 首先确定一个元素间隔数 gap，然后将参加排序的序列按此间隔数从第 1 个元素开始一次分成若干个子序列，即分别将所有位置相隔为 gap 的元素视为一个子序列，在各个子序列中采用某种排序方法进行插入排序。
• 然后减少间隔数，并重新将整个序列按新的间隔数分成若干个子序列，再分别对各个子序列进行排序，如此下去，直到间隔数 gap = 1。

4.3 代码实践

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        gap = n // 1
        
        while gap>0:
            for i in range(gap, n):
                tmp = nums[i]
                j = i

                while (j>0) and (nums[j-gap]>tmp):
                    nums[j] = nums[j-gap]
                    j -= gap
                nums[j] = tmp
            gap = gap // 2
        return nums

5、归并排序

5.1 算法思想

归并排序（Merge Sort）基本思想：
采用经典的分治策略，先递归地将当前序列平均分成两半。然后将有序序列两两合并，最终合并成一个有序序列。
归并排序算法是 稳定排序算法。
算法时间复杂度：$O(nlo{g}_{2}n)$
算法空间复杂度：$O(n)$

5.2 步骤与演示

• 初始时，将待排序序列中的 n 个记录看成 n 个有序子序列（每个子序列总是有序的），每个子序列的长度均为 1。
• 把当前序列组中有序子序列两两归并，完成一遍之后序列组里的排序序列个数减半，每个子序列的长度加倍。
• 对长度加倍的有序子序列重复上面的操作，最终得到一个长度为 n 的有序序列。

5.3 代码实践

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:

        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 merge_sort(arr):
            n = len(arr)
            if n < 2:
                return arr
            mid = n // 2
            left_arr = arr[:mid]
            right_arr = arr[mid:]
            return merge(merge_sort(left_arr), merge_sort(right_arr))
        
        return merge_sort(nums)

6. 快速排序

6.1 算法思想

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

6.2 步骤与演示

• 挑选基准值：从数列中挑出一个元素，称为"基准"（pivot）;
• 分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;
• 递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。

其实动图，我并没有看太明白。下面两个链接，我认为是比较好的。
快速排序算法详解（原理、实现和时间复杂度）
http://data.biancheng.net/view/117.html
快速排序算法
https://www.bilibili.com/video/BV1at411T75o/

6.3 代码实践

下面显示提交超时。参考代码：Python实现快速排序算法。

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        
        def quick_sort(arr, left, right):
            if left