Kth Largest Element אין אַ סטרים לעעטקאָדע סאַלושאַן  


שוועריקייט לעוועל גרינג
אָפט געבעטן אין אַדאָובי אַמאַזאָן עפּל קאַסטן עבייַ facebook גאָלדמאַן סאַקס גוגל מייקראָסאָפֿט נוטאַניקס
אַלגאָריטהם אַלגערידאַמז קאָדירונג פּלאַן קופּע אינטערוויו interviewprep LeetCode LeetCodeSolutions

פּראָבלעם סטאַטעמענט  

אין דעם פּראָבלעם, מיר האָבן צו פּלאַן אַ קלאַס KthLargest () וואָס טכילעס האט אַ גאַנץ נומער ק און אַן מענגע פון ינטאַדזשערז. מיר דאַרפֿן צו שרייַבן אַ פּאַראַמעטערייזד קאַנסטראַקטער פֿאַר אים ווי אַ גאַנץ נומער k און array נומס זענען דורכגעגאנגען ווי אַרגומענטן. דער קלאַס אויך האט אַ פונקציע לייג (וואַל) אַז מוסיף אַ נייַ עלעמענט מיט ווערט Val אין די טייַך פון ינטאַדזשערז. פֿאַר יעדער לייג צו() מיר דאַרפֿן צו צוריקקומען אַ ינטאַדזשער נומער וואָס איז די Kth גרעסטער עלעמענט אין די פליסנדיק טייַך.

בייַשפּיל

["KthLargest", "add", "add", "add", "add", "add"]
[[3, [4, 5, 8, 2]], [3], [5], [10], [9], [4]]
4 5 5 8 8

דערקלערונג:

Kth Largest Element אין אַ סטרים לעעטקאָדע סאַלושאַןשפּילקע

צוגאַנג (מיני העאַפּס)  

ווען עס קומט צו דער דער קלענסטער / גרעסטער עלעמענט פון Kth, מאַקס / מין הויפנס כּמעט יעדער מאָל דינען דעם ציל. דאָס איז ווייַל פון זייער פלעקסאַבאַל נאַטור צו האַלטן עלעמענטן אין אַ סאָרטעד (פּרייאָראַטייזד) מאָדע. דאָ, מיר קען אויך נוצן אַ מענגע צו אַנטהאַלטן די עלעמענטן ווען אַ אָנפֿרעג איז געמאכט. אָבער, אין סדר צו געפֿינען די Kth גרעסטער עלעמענט אין די מענגע, מיר מוזן האָבן צו נוצן אָ (ען) צייט פֿאַר יעדער אָנפֿרעג. דעריבער, מיר קענען האַלטן אַ מינינג קופּע פון ​​גרייס k, צו געפֿינען די kth גרעסטער עלעמענט אין די O (1) צייט. באַמערקונג אַז זינט מיר נוצן אַ מין-קופּע, דער שפּיץ עלעמענט איז דער קלענסטער אין די קופּע. און זינט מיר האָבן געבונדן די קופּע גרייס צו זיין גלייך צו ק נאָך יעדער אָנפֿרעג, דער שפּיץ עלעמענט וואָלט זיין די Kth גרעסטער אין די קוילעלדיק טייַך (ווייַל די קופּע וואָלט האַלטן ק גרעסטן עלעמענטן בלויז).

זע אויך
סלאָואַסט דורכפֿאַל לעעטקאָדע סאַלושאַן

ימפּלעמענטאַטיאָן פון Kth Largest Element אין אַ סטרים לעעטקאָדע סאַלושאַן

C ++ פּראָגראַם

#include <bits/stdc++.h>

using namespace std;

class KthLargest {
public:
    priority_queue <int , vector <int> , greater <int> > pq;
    int K;

    KthLargest(int k, vector<int>& nums) {
        K = k;
        for(int &x : nums) {
            pq.push(x);
            if(pq.size() > k) {
                pq.pop();
            }
        }
    }

    int add(int val) {
        pq.push(val);
        if(pq.size() > K)
            pq.pop();
        return pq.top();
    }
};

int main() {
    vector <int> nums = {4 , 5 , 8 , 2};
    int k = 3;
    KthLargest stream(k , nums);
    cout << stream.add(3) << " ";
    cout << stream.add(5) << " ";
    cout << stream.add(10) << " ";
    cout << stream.add(9) << " ";
    cout << stream.add(4) << " ";
    cout << endl;
    return 0;
}

Java פּראָגראַם

import java.util.*;
import java.io.*;

class comp implements Comparator<Integer> {
    public int compare(Integer a , Integer b) {
        if(a > b)
            return 1;
        if(a < b)
            return -1;
        return 0;
    }
}

class KthLargest {
    int K;
    PriorityQueue <Integer> pq;

    public KthLargest(int k, int[] nums) {
        K = k;
        pq = new PriorityQueue <Integer> (new comp());
        for(int x : nums) {
            pq.add(x);
            if(pq.size() > k) {
                pq.remove();
            }
        }
    }

    int add(int val) {
        pq.add(val);
        if(pq.size() > K)
            pq.remove();
        return pq.peek();
    }
}

class KthLargestInStream {
    public static void main(String args[]) {
        int k = 3;
        int[] nums = {4 , 5 , 8 , 2};
        KthLargest stream = new KthLargest(k , nums);
        System.out.print(stream.add(3) + " ");
        System.out.print(stream.add(5) + " ");
        System.out.print(stream.add(10) + " ");
        System.out.print(stream.add(9) + " ");
        System.out.print(stream.add(4) + " ");
        System.out.println();
    }
}
4 5 5 8 8

קאַמפּלעקסיטי אַנאַליסיס פון די Kth Largest Element אין אַ סטרים לעעטקאָדע סאַלושאַן

צייט קאַמפּלעקסיטי

אָ (N + Q), ווו N = גרייס פון דער ערשט מענגע (בשעת רופן די קאַנסטראַקטער). Q = נומער פון פֿראגן. דאָס איז ווייַל מיר דורכפאָר די מענגע אַמאָל און ענטפֿערן יעדער אָנפֿרעג אין אָ (1) צייט.

ספעיס קאַמפּלעקסיטי 

אקעי), ווו K איז דער געגעבן אַרגומענט (בשעת פאַך די קאַנסטראַקטער). דאָס איז ווייַל מיר האַלטן די קופּע גרייס פּונקט ק, נאָך קיין אָפּעראַציע.

1