2月-215。配列内でk番目に大きい要素と最小のヒープ

class Solution:
    def findKthLargest(self, nums: List[int], k: int) -> int:
        #直接排序，然后找到第k个最大的元素
        nums_res = sorted(nums,reverse=True)
        return nums_res[k-1]


        #构建一个大小为k的最小堆，堆顶元素就是第k个最大的元素
        heap = nums
        heapq.heapify(heap)

        while len(heap)>k:
            heapq.heappop(heap)
        
        return heap[0]

class Solution:
    def thirdMax(self, nums: List[int]) -> int:
        if len(set(nums))<3:
            return max(nums)
        
        #最小堆：插入时间复杂度是log(n)
        heap = list(set(nums))
        heapq.heapify(heap)
 
        while len(heap)>3:
            heapq.heappop(heap)
        
        return heap[0]

        #排序
        nums = list(set(nums))
        nums_res = sorted(nums,reverse=True)
        return nums_res[2]

        #O(n)时间复杂度
        nums = set(nums)
        n = len(nums)
        if n < 3:
            return max(nums)
        max1 = max(nums)
        nums.remove(max1)
        max2 = max(nums)
        nums.remove(max2)

        return max(nums)

最初の2つはO（n）時間計算量を満たしておらず、最後の1つだけがO（n）時間計算量を満たしています。

class Solution:
    def topKFrequent(self, words: List[str], k: int) -> List[str]:
        
        #堆操作
        #时间复杂度：O(Nlogk)
        num_dic = dict(Counter(words))
        import heapq  
        h = []
        res = []
        for key, value in num_dic.items():
            heapq.heappush(h, (-value, key))  # 按第一个键值进行排序，堆顶是最小值，如果第一个元素相同那就按照第二个元素进行排序
        
        for _ in range(k):
            res.append(heapq.heappop(h)[1])
        
        return res
        



        
        #时间复杂度：O(NlogN)
        count = collections.Counter(words)
        candidates = count.keys()
        #先按照value进行排序，如果value排序相同，在按照key进行排序
        candidates = sorted(candidates,key = lambda x:(-count[x],x))
        return candidates[:k]

この問題は厄介です。発生頻度が同じ場合は、アルファベット順に並べ替える必要があるため、①辞書+並べ替え;②最小ヒープの2つの方法を使用します。

辞書+並べ替え
- ハッシュテーブルを使用して、各単語の出現回数をカウントします
- キーを取り出して昇順で並べ替えます。並べ替えの文は、値が負の数であるということです。値が同じ場合は、単語に従って並べ替えられます。
- 最後に最初のk個の要素を返します。値に負の符号を追加したため、負の値を追加する前の最大値が最小値になるため、最初のk個の要素を返します。
最小ヒープ
- -valueに従って最小ヒープを構築します。値が同じ場合は、2番目の要素に従ってソートします。
- 次に、スタックの一番上にあるk個の要素をポップします。これらのk個の要素は、最も頻繁に発生する3つの要素です。

class Solution:
    def kClosest(self, points: List[List[int]], K: int) -> List[List[int]]:
        

        #直接排序法
        points.sort(key=lambda x: (x[0] ** 2 + x[1] ** 2))
        return points[:K]



        #建一个最小堆，然后不断的堆顶的元素。
        distance = []
        for i in range(len(points)):
            x,y = points[i][0],points[i][1]
            distance.append(x*x+y*y)
        dic = defaultdict(int)
        #字典的key是index，value是点到原点之间的距离
        for i in range(len(distance)):
            dic[i]= distance[i]
        heap = []
        res = []
        for key,value in dic.items():
            heapq.heappush(heap,(value,key))
           
        for _ in range(K):
            index = heapq.heappop(heap)[1]
            res.append(points[index])

       

        return res

直接注文
- 距離を計算し、直接並べ替えてから、最初のk個の要素を選択します
最小ヒープメソッドを構築する
- 最初に距離を計算します
- 次に、辞書を作成します。キーはインデックス、値は距離です。
- 次に、最小のヒープを作成し、最小のヒープの上部からk個の要素を取り出します。
- 取り出されたk個の要素は単なるインデックスであり、インデックスに従ってリスト内の座標を取り出します。

概要：最小ヒープの単純なアプリケーション。

2月-215。配列内でk番目に大きい要素と最小のヒープ

おすすめ