Febrero de 215. El k-ésimo elemento más grande de la matriz y el montón más pequeño

 

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)

Los dos primeros no cumplen con la complejidad de tiempo O (n), y solo el último cumple con la complejidad de tiempo 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]
        

Este problema es problemático. Cuando la frecuencia de aparición es la misma, es necesario clasificarlo en orden alfabético, por lo que todavía usamos dos métodos: ① diccionario + clasificación; ② pila mínima.

• Diccionario + ordenar
  • Use una tabla hash para contar el número de ocurrencias de cada palabra
  • Saque la clave y ordene en orden ascendente. La frase de clasificación es que el valor es un número negativo. Si el valor es el mismo, se clasificará según la palabra.
  • Finalmente devuelva los primeros k elementos, porque agregamos un signo negativo al valor, el valor máximo antes de agregar el negativo se convierte en el valor mínimo, así que devuelva los primeros k elementos
• Montón mínimo
  • Construya un montón mínimo, según -value, si el valor es el mismo, ordenaremos según el segundo elemento
  • Luego, coloque los k elementos en la parte superior de la pila. Estos k elementos son los tres elementos que ocurren con más frecuencia

 

 

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

• Pedido directo
  • Calcule la distancia, ordene directamente y luego seleccione los primeros k elementos
• Construir método de pila mínima
  • Calcula la distancia primero
  • Luego construya un diccionario, la clave es el índice, el valor es la distancia
  • Luego construya el montón más pequeño y saque k elementos de la parte superior del montón más pequeño.
  • Los k elementos que se eliminan son solo índices, y luego eliminan las coordenadas de la lista de acuerdo con el índice.

 Resumen: una aplicación simple del montón más pequeño.