TopK código en cuestión (Python, Java)

Hay dos métodos principales de la misma, llamar a la función no hablar de la entrevista podría estar jugando. . . Principalmente dos algoritmos clásicos, una pila de clasificación, es una fila de versión de actualización rápida: método rápido de elección.

método de selección rápida

El primero es un método rápido de seleccionar, usando el Quicksort se repartirá en dos porciones, así que si la longitud es mayor que la partición izquierda K, puede ser estrecho, si el lado izquierdo de la partición es menor que K, entonces simplemente encontrar el lado derecho de la partición la cantidad restante en él. Si el ayuno la fila familiarizado con el caso, pero todavía es bastante simple, es necesario punto a destacar es la necesidad de una selección al azar.

importar azar
 def partición (nums, izquierda, derecha): 
    target = nums [Izquierda] 
    primas = dejaron 
    dejaron = Izquierda + 1
     mientras izquierda <= derecha:
         mientras izquierda <= derecha y nums [derecha]> objetivo: 
            derecho - = 1
         mientras izquierda <= derecha y nums [izquierdo] < objetivo: 
            izquierda + = 1
         si izquierda <= derecha: # .这个需要注意 
            nums [izquierda], nums [right] = nums [derecha], nums [izquierda] 
    nums [rAW] , nums [Izquierda-1] = nums [izquierda-1 ], nums [cruda]
     retorno dejaron -1 def randomPartition (nums, izquierda, derecha): 
    target = random.randint (izquierda, derecha)
     # 随机取一个数然后交换他们的位置! !不然会出errores 
    nums [objetivo], nums [right] = nums [derecha], nums [objetivo] 
    pivo = partición (nums, izquierda, derecha)
     regresan   pivo definición selectMinNum (nums, izquierda, derecha, k): 
    pivo = randomPartition (nums, izquierda, derecha)
     si k == pivo - izquierdo + 1 :
         retorno ;
    Si k <pivo - izquierdo + 1 
        selectMinNum (nums, izquierda, pivo



 : -1 , k)
     si k> pivo - izquierdo + 1 : 
        selectMinNum (nums, pivo + 1, a la derecha, k-pivo + izquierda-1 ) 

def selectMaxNum (nums, izquierda, derecha, k): 
    pivo = randomPartition (nums, izquierda, derecha)
     si k == derecha pivo + 1 :
         retorno ;
    Si k <derecha pivo + 1 : 
        selectMinNum (nums, pivo 1 , a la derecha, k)
     si k> derecha pivo + 1 : 
        selectMinNum (nums, izquierda, pivo -1, k-derecha + pivo-1)

Esto fue bastante fácil de entender, vistazo al código, que debe ser capaz de entender, este es el código se puede utilizar directamente, el núcleo es que el uso de rápido fila y medio pensamiento, si la complejidad deseada es O (N) No es asombroso lo para más detalles, consulte Introducción a los algoritmos Capítulo IX oh.

Que incluye dos, encontrar el mínimo y el máximo N N. Él es firmar un cambio.

montón

Máximo y mínimo montón montón de ideas, cada uno con una capacidad de k mantener el montón, cada uno vienen en un número de los del montón transformación. Los árboles vienen en el último, entonces la transformación montón de abajo hacia arriba.

 

# Esta función es para ajustar la pila de arriba a abajo 
DEF maxHeapOne (Lista2, index1,):
     IF index1 ,. 1 + 2 * <= len (Lista2) -1 : 
        leftChild = index1 ,. 1 + 2 * 
        rightChild = index1, 2 + 2 *
         IF rightChild> len (Lista2) -1 :
             SI Lista2 [index1,] < Lista2 [leftChild]: 
                Lista2 [index1,], Lista2 [leftChild] = Lista2 [leftChild], Lista2 [index1,]
             retorno 
        IF Lista2 [index1,]> Lista2 [rightChild] y Lista2 [index1,]> Lista2 [leftChild]:
             retorno 
        SI Lista2 [leftChild]>Lista2 [rightChild]:
             SI Lista2 [index1,] < Lista2 [leftChild]: 
                Lista2 [index1,], Lista2 [leftChild] = Lista2 [leftChild], Lista2 [index1,] 
                maxHeapOne (Lista2, leftChild) 
        IF Lista2 [leftChild] < Lista2 [rightChild ]:
             SI Lista2 [index1,] < Lista2 [rightChild]: 
                Lista2 [index1,], Lista2 [rightChild] = Lista2 [rightChild], Lista2 [index1,] 
                maxHeapOne (Lista2, rightChild) 

# esta función es el montón ajustado de abajo hacia arriba , siempre que n-1 es una entrada frontal para el almacenamiento dinámico máximo 
DEF heapUpdate (Lista2): 
    N = len (Lista2) 
    CUR . = 1-N
    faNode = CUR >> 1.
     el mientras faNode> = 0:
         SI Lista2 [faNode]> Lista2 [CUR]:
             retorno 
        IF Lista2 [faNode] < Lista2 [CUR]: 
            Lista2 [faNode], Lista2 [CUR] = Lista2 [CUR], Lista2 [faNode] 
        CUR = faNode 
        faNode = (-faNode 1.) >> 1. # Construcción pila DEF createHeap (Lista2): 
    N = len (Lista2)
     # . CUR-N = 1 
    . Start = (. 1-N) >> 1 el tiempo de inicio > = 0: # de matriz último niño comienza a atravesar. Para cada nodo para construir el mayor montón. # Impresión (Start)




    
        
        maxHeapOne (Lista2, Inicio) 
        Start . - 1 =
 # obtener la máxima 
DEF getMax (Lista2): 
    createHeap (Lista2) 
    Lista2 [0], Lista2 [ -1] = Lista2 [-1 ], Lista2 [0] 
    RES = list2.pop () 
    maxHeapOne (list2,0)    # después de eliminar el valor máximo de la pila se ajusta, de arriba a abajo para ajustar 
    retorno RES 

# minTOPN 

DEF getminTop (Lista2, k): 
    list3 = Lista2 [: k] k # para establecer un máximo pila 
    createHeap (list3) 
    para I en Lista2 [K:]: # en la parte posterior de este elemento de inserción se ajusta pila 
        list3 + = [I]  
        heapUpdate (list3)
        list3 = list3 [-K:]
     retorno list3

 

Lo más importante, las dos primeras funciones, uno es para transformar de arriba a abajo de la pila, y la segunda es la transformación de la pila de abajo a arriba. Las funciones restantes son también relativamente fácil de entender, por supuesto, para la última función getminTop esta función, la optimización es todavía un montón de puntos, no me molestaría a escribir. . . Todo se va a optimizarlo.