刷题日记——排序

今天写排序，排序里面比较有效率的有归并排序，快速排序，写起来简单但时间复杂度较高的有冒泡排序，选择排序，插入排序等。

排序链表
给你链表的头结点 head ，请将其按 升序 排列并返回 排序后的链表 。

 

输入：head = [4,2,1,3]
输出：[1,2,3,4]

 

提示：

• 链表中节点的数目在范围 [0, 5 * 104] 内
• -105 <= Node.val <= 105

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next


class Solution:
    def sortList(self, head: ListNode) -> ListNode:
        h_head = ListNode(-1, head)
        mem = []
        while (head is not None):
            next_h = head.next
            head.next = None
            mem.append(head)
            head = next_h
        mem = sorted(mem, key=lambda x: x.val)
        n = len(mem)
        if n == 0:
            return None
        h_head.next = mem[0]
        for i in range(n - 1):
            mem[i].next = mem[i + 1]

        return h_head.next

搜索旋转排序数组
整数数组 nums 按升序排列，数组中的值 互不相同 。

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了 旋转，使数组变为 [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]（下标 从 0 开始 计数）。例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2] 。

给你 旋转后 的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1 。

输入：nums = [4,5,6,7,0,1,2], target = 0
输出：4
输入：nums = [4,5,6,7,0,1,2], target = 3
输出：-1

提示：

1 <= nums.length <= 5000
-10^4 <= nums[i] <= 10^4
nums 中的每个值都 独一无二
题目数据保证 nums 在预先未知的某个下标上进行了旋转
-10^4 <= target <= 10^4

from typing import Optional, List


class Solution:
    def search(self, nums: List[int], target: int) -> int:
        length = len(nums)
        left = 0
        right = length - 1
        while (left <= right):
            mid = int((left + right) / 2)
            if (nums[mid] == target):
                return mid
            elif (nums[mid] < nums[right]):
                if (nums[mid] < target and target <= nums[right]):
                    left = mid + 1
                else:
                    right = mid - 1
            else:
                if (nums[left] <= target and target < nums[mid]):
                    right = mid - 1
                else:
                    left = mid + 1
        return -1

 先二分，如果中间的数小于最右边的数，则右半段是有序，反之亦然，在有序的区间内判断target是否在范围内，这样就可以确定保留哪半边了

数组中的第K个最大元素
给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。

请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。

输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

提示：

• 1 <= k <= nums.length <= 104
• -104 <= nums[i] <= 104

前方高能：

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        nums = sorted(nums)
        return nums[len(nums)-k]
        

无序的数组要找到最XX的话除了遍历只能排序了，所以没错！这种写法非常河里，库函数不就是写出来给人调的嘛~ 当然，如果认真写的话可以通过刚才第一题的写法排序。