20220301_datawhale34期_leetcode_9排序

九 排序

1.1 基础

• 基于比较的排序
  通过比较大小来决定元素间的相对次序
  可以证明时间复杂度下界为O(logN)—— 不可能突破这个复杂度达到更快

• 非比较类排序
  不通过比较大小来决定元素间的相对次序
  时间复杂度受元素的范围以及分布等多种因素影响，不单纯取决于元素数量N

1.2 题目

1.2.1 88 . 合并两个有序数组

• 思路: 双指针倒序

class Solution:
    def merge(self, nums1: List[int], m: int, nums2: List[int], n: int) -> None:
        p1, p2 = m - 1, n - 1
        tail = m + n - 1
        while p2 >= 0:
            if p1 < 0 or nums1[p1] <= nums2[p2]:
                nums1[tail] = nums2[p2]
                p2 -= 1
            else:
                nums1[tail] = nums1[p1]
                p1 -= 1
            tail -= 1 
 

1.2.2 912 . 排序数组

• 思路: 希尔排序

class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        gap = n // 2

        while gap:
            for i in range(gap, n):
                j = i
                temp = nums[i]
                while j >= gap and nums[j - gap] > temp:
                    nums[j] = nums[j - gap]
                    j -= gap
                nums[j] = temp
            gap = gap // 2
        return nums

1.2.3 977 . 有序数组的平方

• 思路1: 快排 O(nlogn)

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        return sorted(list(map(lambda x: x*x, nums)))

• 思路2: 双指针

class Solution:
    def sortedSquares(self, nums: List[int]) -> List[int]:
        ans = [0]*len(nums)
        left, right, i = 0, len(nums) - 1, len(nums) - 1
        while left <= right:
            r1 = nums[left] * nums[left]
            r2 = nums[right] * nums[right]
            if r1 >= r2:
                ans[i] = r1
                left += 1
            else:
                ans[i] = r2
                right -= 1
            i -= 1
        return ans

1.2.4 1122 . 数组的相对排序

• 思路: 计数排序

class Solution:
    def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]:
        ans, count = [], [0]*1001
        for arr in arr1:
            count[arr] += 1
        for arr in arr2:
            while count[arr] > 0:
                ans.append(arr)
                count[arr] -= 1

        for arr in range(1001):
            while count[arr] > 0:
                ans.append(arr)
                count[arr] -= 1
        return ans

1.2.5 147 . 对链表进行插入排序

class Solution:
    def insertionSortList(self, head: ListNode) -> ListNode:
        if not head and not head.next:
            return head
        dummy = ListNode(0)
        dummy.next = head
        sorted_link = head
        cur = head.next
        while cur:
            if sorted_link.val <= cur.val:
                sorted_link = sorted_link.next
            else:
                pre = dummy
                while pre.next.val <= cur.val:
                    pre = pre.next
                sorted_link.next = cur.next
                cur.next = pre.next
                pre.next = cur
            cur = sorted_link.next
        return dummy.next