12 ｜ 排序

知识点

在面试的时候面试官经常要求应聘者比较插入排序、冒泡排序、堆排序、计数排序、归并排序和快速排序等不同算法的优劣。因此，应聘者在准备面试的时候一定要对各种排序算法的特点非常熟悉，能够从额外空间消耗、平均时间复杂度和最差时间复杂度等方面比较它们的优点与缺点。

基础练习

1.合并区间

Leecode.56

解体思路

考虑a,b两个区间能合并的三种情况
考虑需要把区间加入结果中的情况

python3答案

class Solution:
    def merge(self, intervals: List[List[int]]) -> List[List[int]]:
        intervals.sort()
        if len(intervals) == 1:
            return intervals
        result = []
        before_left,before_right = intervals[0][0],intervals[0][1]
        for i in range(1,len(intervals)):      
            now_left,now_right = intervals[i][0],intervals[i][1]
            if before_right >= now_left and before_right <= now_right:
                before_right = now_right
                if i == len(intervals) - 1:
                    result.append([before_left,before_right])
            elif before_right < now_left:
                result.append([before_left, before_right])
                before_left,before_right = now_left,now_right
                if i == len(intervals) - 1:
                    result.append([now_left,now_right])
            else:
                if i == len(intervals) - 1:
                    result.append([before_left,before_right])
        return result

2. 数组相对排序

Leetcode.122

解题思路

用哈希表将arr1每个数字出现的次数记录下来，然后遍历arr2，按照arr2数字出现的顺序构造新的列表，然后删除哈希表中的key
对于哈希表剩下的key，先用sorted函数排序，然后添加至结果列表中

python3答案

class Solution:
    def relativeSortArray(self, arr1: List[int], arr2: List[int]) -> List[int]:
        
        dict_1 = {}
        for i in range(len(arr1)):
            if arr1[i] in dict_1:
                dict_1[arr1[i]] += 1
            else:
                dict_1[arr1[i]] = 1

        result = []
        for j in range(len(arr2)):
            tmp = arr2[j]
            if tmp in dict_1:
                value = dict_1[tmp]
                for i in range(value):
                    result.append(tmp)
                del dict_1[tmp]
        if dict_1:
            for k in sorted(dict_1):
                value = dict_1.get(k)
                for i in range(value):
                    result.append(k)
        
        return result

3.数组中的第 k 大的数字

Leetcode.215

思路

使用快排

class Solution:
    def swap(self, nums:List[int],p1:int,p2:int) -> List[int]:
        if p1 != p2:
            nums[p1], nums[p2] = nums[p2], nums[p1]
    
    def partition(self,nums, start, end):
        random_pivot = random.randint(start, end)

        self.swap(nums, random_pivot, end) 

        small = start - 1
        for i in range(start, end):
            if nums[i] < nums[end]:
                small += 1
                self.swap(nums, i, small)    

        small += 1
        self.swap(nums, small, end)

        return small

        

    def quick_sort(self,nums, start, end):
        if end > start:
            pivot = self.partition(nums, start, end)     
            self.quick_sort(nums, start, pivot - 1)
            self.quick_sort(nums, pivot + 1, end)
        

    def findKthLargest(self, nums: List[int], k: int) -> int:
        self.quick_sort(nums,0,len(nums)-1,k)
        return nums[len(nums)-k]

4.链表排序

Leetcode.148

5.合并排序链表

Leetcode.23

答案

扩展练习