LeetCode-912、排序数组-中等

LeetCode-912、排序数组-中等

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

示例 1：

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

示例 2：

输入：nums = [5,1,1,2,0,0]
输出：[0,0,1,1,2,5]

提示：

1 <= nums.length <= 50000
-50000 <= nums[i] <= 50000

 

代码：

1、快速排序：使用分治法（Divide and conquer）策略。挑选基准值，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面，递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

时间复杂度：O(Nlog2(N))

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        def partition(n, left, right):
            tmp = n[right]
            ind = left
            for i in range(left, right):
                if n[i] < tmp:
                    n[ind], n[i] = n[i], n[ind]
                    ind += 1
            n[ind], n[right] = n[right], n[ind]
            return ind
        def quicksort(n, left, right):
            if left < right:
                ind = partition(n, left, right)
                quicksort(n, left, ind-1)
                quicksort(n, ind+1, right)
        quicksort(nums, 0, len(nums)-1)
        return nums

2、归并排序：创建在归并操作上的一种有效的排序算法，是采用分治法（Divide and Conquer）的一个非常典型的应用。

时间复杂度：O(Nlog2(N))

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        def merge(n, l, m, r):
            alen = m + 1 - l
            blen = r - m
            a = [0] * alen
            b = [0] * blen
            for i in range(l, m+1):
                a[i-l] = n[i]
            for i in range(m+1, r+1):
                b[i-m-1] = n[i]
            i, j, k = 0, 0, l
            while i < alen and j < blen:
                if a[i] < b[j]:
                    n[k] = a[i]
                    i += 1
                else:
                    n[k] = b[j]
                    j += 1
                k += 1
            while i < alen:
                n[k] = a[i]
                i += 1
                k += 1
            while j < blen:
                n[k] = b[j]
                j += 1
                k += 1
        def mergesort(n, l, r):
            if l < r:
                m = (l + r) // 2
                mergesort(n, l, m)
                mergesort(n, m+1, r)
                merge(n, l, m, r)
        mergesort(nums, 0, len(nums)-1)
        return nums

 

3、堆排序：利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。堆排序可以说是一种利用堆的概念来排序的选择排序。N元素数组，从最后一个节点向根节点建大顶堆，每次交换父节点和子节点的值后都要重新堆化所有子节点，找到最大值后将根节点与最后一个子节点交换，再对前（N-1）个元素重新堆化。

时间复杂度：O(Nlog2(N))

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        def heapify(n, end, i): 
            tmpmaxind = i  
            l = 2 * i + 1
            r = 2 * i + 2
            if l < end and n[tmpmaxind] < n[l]: 
                tmpmaxind = l
            if r < end and n[tmpmaxind] < n[r]: 
                tmpmaxind = r 
            if tmpmaxind != i: 
                n[i], n[tmpmaxind] = n[tmpmaxind], n[i]
                heapify(n, end, tmpmaxind) 
        def heapSort(n): 
            end = len(n) 
            for i in range(end-1, -1, -1): 
                heapify(n, end, i) 
            for i in range(end-1, 0, -1): 
                n[0], n[i] = n[i], n[0]
                heapify(n, i, 0)
        heapSort(nums)
        return nums

4、插入排序：通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。递归地把当前序列平均分割成两半，在保持元素顺序的同时将上一步得到的子序列集成到一起（归并）。

时间复杂度：O(N^2)

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

 

常见排序方法复杂度：

排序方法	时间复杂度(平均)	时间复杂度(最坏)	时间复杂度(最好)	空间复杂度	稳定性	复杂性
直接插入排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定	简单
希尔排序	O(nlog2n)	O(n^2)	O(n^1.3)	O(1)	不稳定	较复杂
直接选择排序	O(n^2)	O(n^2)	O(n^2)	O(1)	不稳定	简单
堆排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(1)	不稳定	较复杂
冒泡排序	O(n^2)	O(n^2)	O(n)	O(1)	稳定	简单
快速排序	O(nlog2n)	O(n^2)	O(nlog2n)	O(nlog2n)	不稳定	较复杂
归并排序	O(nlog2n)	O(nlog2n)	O(nlog2n)	O(n)	稳定	较复杂
基数排序	O(d(n+r))	O(d(n+r))	O(d(n+r))	O(n+r)	稳定	较复杂