El número mínimo de K Python

n enteros de entrada, encuentra la más pequeña cantidad K. 4,5,1,6,2,7,3,8 por ejemplo ocho entradas digitales, el número mínimo es de cuatro 1,2,3,4

Encuentra la complejidad del tiempo de los más grandes montón de O (logK)
sustituir la complejidad es también O (logK)
para la matriz espacial de la complejidad es O (K)

Si el cambio es resolver el problema con la matriz, a continuación,
encontrar el tiempo la complejidad es O (logK) (usando la búsqueda binaria)
la complejidad de la sustitución de O (K)
conjunto complejo de espacio auxiliar es O (K)

La principal diferencia entre los dos programas es que la complejidad de la sustitución, por lo que un máximo del montón a resolver el problema. Se encontró una situación similar, la pila más pequeña tiene las mismas ventajas.

# -*-coding:utf-8 -*-
class Solution:
    def GetLeastNumbers_Solutions(self, tinput, k):

        # 创建或者是插入最大堆
        def createMaxHeap(num):
            maxHeap.append(num)
            currentIndex = len(maxHeap) - 1
            while currentIndex != 0:
                parentIndex = (currentIndex - 1) >> 1
                if maxHeap[parentIndex] < maxHeap[currentIndex]:
                    maxHeap[parentIndex], maxHeap[currentIndex] = maxHeap[currentIndex], maxHeap[parentIndex]
                else:
                    break

        # 调整最大堆，头节点发生改变
        def adjustMaxHeap(num):
            if num < maxHeap[0]:
                maxHeap[0] = num
            maxHeapLen = len(maxHeap)
            index = 0
            while index < maxHeapLen:
                leftIndex = index * 2 + 1
                rightIndex = index * 2 + 2
                largerIndex = 0
                if rightIndex < maxHeapLen:
                    if maxHeap[rightIndex] < maxHeap[leftIndex]:
                        largerIndex = leftIndex
                    else:
                        largerIndex = rightIndex
                elif leftIndex < maxHeapLen:
                    largerIndex = leftIndex
                else:
                    break

                if maxHeap[index] < maxHeap[largerIndex]:
                    maxHeap[index], maxHeap[largerIndex] = maxHeap[largerIndex], maxHeap[index]

                index = largerIndex

        maxHeap = []
        inputLen = len(tinput)
        if len(tinput) < k or k <= 0:
            return []

        for i in range(inputLen):
            if i < k:
                createMaxHeap(tinput[i])
            else:
                adjustMaxHeap(tinput[i])
        maxHeap.sort()
        return  maxHeap



if __name__ == '__main__':
    tinput=[1,2,4,6,100,20,9,10]
    s=Solution()
    result = s.GetLeastNumbers_Solutions(tinput,4)
    for i in range(0,4):
        print(result[i])

Resultados de operación como sigue:

1
2
4
6