973. 最接近原点的 K 个点

思路1：排序
按照距离对点进行排序，最后取指定数量的点。
时间复杂度O(NlogN)
空间复杂度O(1)：原地

class Solution:
    def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
        return sorted(points, key=lambda x: x[0] * x[0] + x[1] * x[1])[:K]

思路2：快排
对数据进行快排，不需要进行全部排序，只需要找到第k大的数据就行了,前K个便是答案。并不一定是有序的。

class Solution:
    def kClosest(self, nums: List[List[int]], K: int) -> List[List[int]]:
        def getIndex(nums, low, high, pivot):
            key = nums[pivot]  # 把基准取出放到起点
            nums[pivot] = nums[low]
            while low < high:
                while low < high and self.val(nums[high]) >= self.val(key):  # 右边找小于key的
                    high -= 1
                nums[low] = nums[high]
                while low < high and self.val(nums[low]) <= self.val(key):  # 左边找大于key的
                    low += 1
                nums[high] = nums[low]
            nums[low] = key
            return low

        n = len(nums)
        index = getIndex(nums, 0, n - 1, K-1) # 直接找K可能越界，直接找k-1就行了
        while index != (K-1):
            if index < (K-1):
                index = getIndex(nums, index + 1, n - 1, (K-1))
            else:
                index = getIndex(nums, 0, index - 1, (K-1))
        return nums[:index+1]

    def val(self,p):
        val = p[0] * p[0] + p[1] * p[1]
        return val

思路3：

import heapq
class Solution:
    def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
        # 使用库函数小根堆，直接取前k大的元素
        ans = []
        for p in points:
            heapq.heappush(ans,(self.distance(p),p))
        res = []
        res = heapq.nsmallest(K,ans)
        return [x[1] for x in res]

    def distance(self,p):
        distance = p[0] * p[0] + p[1] * p[1]
        return distance