Die kleinste K-Zahl

Die kleinste K-Zahl

Fragenlink

Niuke.com

Ideen zur Problemlösung

Mindesthaufen der Größe K

• Komplexität: O(NlogK) + O(K)
• Besonders geeignet für die Verarbeitung großer Datenmengen

Der Prozess zum Aufrechterhalten eines minimalen Heaps der Größe K ist wie folgt: Verwenden Sie einen Big-Top-Heap. Wenn nach dem Hinzufügen eines Elements die Größe des Big-Top-Heaps größer als K ist, wird das oberste Element des Big-Top-Heaps entfernt, dh das Element mit dem größten Wert im aktuellen Heap wird entfernt, sodass die Elemente Die im Heap verbleibenden Elemente sind kleiner als die entfernten. Die Elemente sind in kleinen Größen erhältlich.

Um einen minimalen Heap aufrechtzuerhalten, sollte ein großer oberer Heap verwendet werden, anstatt direkt einen kleinen oberen Heap zu erstellen und eine Größe festzulegen, um zu versuchen, die Elemente im kleinen oberen Heap zu minimalen Elementen zu machen.

Javas PriorityQueue implementiert Heap-Funktionen. PriorityQueue verwendet standardmäßig einen kleinen oberen Heap. Sie können den Lambda-Ausdruck (o1, o2) -> o2 - o1 während der Initialisierung verwenden, um einen großen oberen Heap zu implementieren. Andere Sprachen haben ähnliche Heap-Datenstrukturen.

public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
    
    
    if (k > nums.length || k <= 0)
        return new ArrayList<>();
    PriorityQueue<Integer> maxHeap = new PriorityQueue<>((o1, o2) -> o2 - o1);
    for (int num : nums) {
    
    
        maxHeap.add(num);
        if (maxHeap.size() > k)
            maxHeap.poll();
    }
    return new ArrayList<>(maxHeap);
}

schnelle Auswahl

• Komplexität: O(N) + O(1)
• Kann nur verwendet werden, wenn die Änderung von Array-Elementen zulässig ist

Die Partition()-Methode der Schnellsortierung gibt eine Ganzzahl j zurück, sodass a[l...j-1] kleiner oder gleich a[j] und a[j+1...h] größer als ist oder gleich a[j]. Zu diesem Zeitpunkt ist a[j] das j-te größte Element des Arrays. Diese Funktion kann verwendet werden, um das K-te Element des Arrays zu finden. Dieser Algorithmus zum Finden des K-ten Elements wird als schneller Auswahlalgorithmus bezeichnet.

public ArrayList<Integer> GetLeastNumbers_Solution(int[] nums, int k) {
    
    
    ArrayList<Integer> ret = new ArrayList<>();
    if (k > nums.length || k <= 0)
        return ret;
    findKthSmallest(nums, k - 1);
    /* findKthSmallest 会改变数组，使得前 k 个数都是最小的 k 个数 */
    for (int i = 0; i < k; i++)
        ret.add(nums[i]);
    return ret;
}

public void findKthSmallest(int[] nums, int k) {
    
    
    int l = 0, h = nums.length - 1;
    while (l < h) {
    
    
        int j = partition(nums, l, h);
        if (j == k)
            break;
        if (j > k)
            h = j - 1;
        else
            l = j + 1;
    }
}

private int partition(int[] nums, int l, int h) {
    
    
    int p = nums[l];     /* 切分元素 */
    int i = l, j = h + 1;
    while (true) {
    
    
        while (i != h && nums[++i] < p) ;
        while (j != l && nums[--j] > p) ;
        if (i >= j)
            break;
        swap(nums, i, j);
    }
    swap(nums, l, j);
    return j;
}

private void swap(int[] nums, int i, int j) {
    
    
    int t = nums[i];
    nums[i] = nums[j];
    nums[j] = t;
}