排序总结

选择排序，外循环每次确定一个最小的，内循环从下一个元素开始比较

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        for i in range(len_nums):
            for j in range(i+1, len_nums):
                if nums[j] < nums[i]:
                    nums[i], nums[j] = nums[j], nums[i]
        return nums

冒泡排序，其中外循环每次确定一个最大的，内循环用于两两比较

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        for i in range(len_nums):
            for j in range(1, len_nums-i):
                if nums[j-1] > nums[j]:
                    nums[j], nums[j-1] = nums[j-1], nums[j]
        return nums

插入排序，外循环用于确保0~i有序

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        for i in range(1, len_nums):
            while i > 0 and nums[i-1] > nums[i]:
                nums[i-1], nums[i] = nums[i], nums[i-1]
                i -= 1
        return nums

希尔排序，又称缩小增量排序，是对插入排序的优化，外循环while保证增量不为0，然后每次增量缩小一半，

内循环是对增量分割的每一部分做插入排序

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        gap = len_nums//2
        while gap:
            for i in range(gap, len_nums):
                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

归并排序，排序整个数组 = 排序左半边 + 排序右半边 + 合并两边，递归出口：数组长度小于等于1

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        if len_nums <= 1:
            return nums
        mid = len_nums // 2
        left = self.sortArray(nums[:mid])
        right = self.sortArray(nums[mid:])
        return self.merge(left, right)
    def merge(self, l_list, r_list):
        res = []
        l_index, r_index = 0, 0
        while l_index < len(l_list) and r_index < len(r_list):
            if l_list[l_index] <= r_list[r_index]:
                res.append(l_list[l_index])
                l_index += 1
            else:
                res.append(r_list[r_index])          
                r_index += 1
        res += l_list[l_index:]
        res += r_list[r_index:]
        return res

快速排序，排序整个数组 = partition为两部分 + 排序左部分 + 排序右部分，

快排1，申请了额外的空间使得partition部分变得简单了

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        len_nums = len(nums)
        if len_nums <= 1:
            return nums
        left = []
        right = []
        for i in range(1, len_nums):
            if nums[i] < nums[0]:
                left.append(nums[i])
            else:
                right.append(nums[i])
        return self.sortArray(left) + [nums[0]] + self.sortArray(right)

快排2，没有申请额外空间，使用交换完成partition部分

def quick_sort(nums):
    n = len(nums)

    def quick(left, right):
        if left >= right:
            return nums
        pivot = left
        i = left
        j = right
        while i < j:
            while i < j and nums[j] > nums[pivot]:
                j -= 1
            while i < j and nums[i] <= nums[pivot]:
                i += 1
            nums[i], nums[j] = nums[j], nums[i]
        nums[pivot], nums[j] = nums[j], nums[pivot]
        quick(left, j - 1)
        quick(j + 1, right)
        return nums

    return quick(0, n - 1)