La matrice K de gros éléments (leetcode 215)

A: idées de résolution de problèmes

La meilleure façon de résoudre le problème est que le tableau par ordre décroissant, puis retirez l'élément du k-1. Temps: O (n * log (n)), Espace: O (1)

Nous écrivons les deux types de pratiques suivantes.

Première méthode: On se maintenir un tas de minimum de k supérieure, une fois parcourue la matrice, les éléments de tableau dans un tableau, le dernier élément de la pile est la première K étant donné les gros éléments. Temps: O (n * log (k)) que quicksort, Espace: O (k)

Méthode deux: et est un peu similaire au tri rapide nécessite une division de fonction de partition, sélectionnez d'abord une donnée (la sélection de référence est plus important, la relation entre la complexité temporelle de l'algorithme), alors ce sera plus que les éléments de référence dans le côté gauche du tableau, sera inférieure à celle des éléments de référence sur le côté droit de la matrice. (Ordre peut être modifié, il peut être plus petit que les éléments de référence dans la gauche que les éléments de référence dans le droit.), Et la meilleure complexité temporelle moyenne de l'algorithme est: O (n), le pire (à savoir, un tableau à partir de petit à grand lorsque la complexité temporelle arrangement) est la suivante: O (n ^ 2), la complexité spatiale est O (1) un algorithme stochastique, nous pouvons utiliser les données dans le réseau peut être aléatoire si perturbé. la complexité de temps devient O (n). Dans l'application réelle d'un tel algorithme raison valable est parce que les données réelles sont arrangement essentiellement aléatoire, la complexité temporelle de l'algorithme sont: Temps: O (n), Espace: O (1)

Deux: Complete exemples de code (C ++ et Java version édition),

Méthode une C ++:

classe Solution 
{ 
privée : 
    priority < int , vecteur < int >, plus < int >> minHeap;
publique :
     int findKthLargest (vector < int > & nums, int k) 
    { 
        pour ( int num: nums) 
        { 
            si (minHeap.size () < k) 
            { 
                minHeap.push (num); 
            } 
            Autre  si (num> minHeap.top ()) 
            { 
                minHeap.pop ();
                minHeap.push (num); 
            } 
        } 

        Retourner minHeap.top (); 
    } 
};

Une méthode Java:

classe Solution 
    { 
        privée file d' attente <Entier> = minHeap nouveau PriorityQueue <> (); 

        publique  int findKthLargest ( int [] nums, int k) 
        { 
               pour ( int num: nums) 
               { 
                   si (minHeap.size () < k) 
                   { 
                       minHeap.add (num); 
                   } 
                   Sinon  si (num> minHeap.peek ()) 
                   { 
                       minHeap.poll (); 
                       minHeap.add (num);
                   } 
               } 

               Retour minHeap.peek (); 
        } 
    }

Méthode Deux C ++:

class Solution 
{ 
privée :
     int partition (vector < int > & nums, int bas, int haut) 
    { 
        int pivot = nums [faible], i = faible, j = élevé;
        tandis que (i < j) 
        { 
            pendant que (i <j && nums [j] <pivot) j-- ;
            si (i < j) échange (nums [i], nums [j]);
            tandis que (i <j && nums [i]> = pivot) i ++ ;
            si (i < j) échange (nums [i], nums [j]); 
        } 

        Retour i; 
    }
publique :
     int findKthLargest (vector < int > & nums, int k) 
    { 
        int bas = 0 , high = nums.size () - 1 ;
        tandis que (faible <= élevé) 
        { 
            int p = partition (nums, bas, haut);
            si (p == K - 1 ) retour nums [p];
            d'autre  si (p> k - 1 ) Haut = p - 1 ;
            d'autre bas = p + 1 ; 
        } 

        Retour -1 ; 
    } 
};

 

Méthode Deux Java:

 class Solution 
    { 
        privée  vide swap ( int [] nums, int i, int j) 
        { 
            int temp = nums [i]; 
            NUMS [i] = nums [j]; 
            nums [j] = température; 
        } 

        Privé  int partion ( int [] nums, int bas, int haut) 
        { 
            int pivot = nums [basse], i = faible, j = haut;
            tandis que (i < j) 
            { 
                pendant que (i <j && nums [j] <pivot) j--;
                si (i < j) swap (nums, i, j);
                tandis que (i <j && nums [i]> = pivot) i ++ ;
                si (i < j) swap (nums, i, j); 
            } 

            Retour i; 
        } 

        Publique  int findKthLargest ( int [] nums, int k) 
        { 
              int bas = 0 , high = nums.length- 1 ;
              tandis que (faible <= élevé) 
              { 
                  int p = partion (nums, bas, haut);
                  si (p == k- 1 )retour nums [p];
                  d'autre  si (p> k- 1 ) Haut = p- 1 ;
                  d'autre bas = p + 1 ; 
              } 

              Retour - 1 ; 
        } 
    }