Schreiben Sie ein Programm, um 100 größte Zahlen aus einem Array von 1 Milliarde Zahlen zu finden

Ich habe kürzlich an einem Interview teilgenommen, in dem ich gebeten wurde, "ein Programm zu schreiben, um 100 größte Zahlen aus einer Reihe von 1 Milliarde Zahlen zu finden".

Ich konnte nur eine Brute-Force-Lösung geben, die darin bestand, das Array in O (nlogn) -Zeitkomplexität zu sortieren und die letzten 100 Zahlen zu verwenden.

Arrays.sort(array);

Der Interviewer suchte nach einer besseren Zeitkomplexität. Ich versuchte ein paar andere Lösungen, antwortete ihm aber nicht. Gibt es eine bessere Lösung für die Zeitkomplexität?

Sie können eine Prioritätswarteschlange mit den 100 größten Zahlen beibehalten und die Milliardenzahlen durchlaufen, wenn Sie auf eine Zahl stoßen, die größer als die kleinste Zahl in der Warteschlange (der Kopf der Warteschlange) ist. Entfernen Sie den Kopf der Warteschlange und fügen Sie die neue Zahl hinzu in die Warteschlange.

BEARBEITEN: Wie Dev bemerkte, ist bei einer mit einem Heap implementierten Prioritätswarteschlange die Komplexität des Einfügens in die Warteschlange komplexO(logN)

Im schlimmsten Fall bekommt man was besser ist alsbillionlog2(100)billionlog2(billion)

Wenn Sie die größten K-Zahlen aus einer Menge von N Zahlen benötigen, ist die Komplexität im Allgemeinen O(NlogK)eher als O(NlogN), dies kann sehr bedeutsam sein, wenn K im Vergleich zu N sehr klein ist.

EDIT2:

Die erwartete Zeit dieses Algorithmus ist ziemlich interessant, da in jeder Iteration eine Einfügung auftreten kann oder nicht. Die Wahrscheinlichkeit, dass die i-te Zahl in die Warteschlange eingefügt wird, ist die Wahrscheinlichkeit, dass eine Zufallsvariable größer ist als mindestens i-KZufallsvariablen aus derselben Verteilung (die ersten k Zahlen werden automatisch zur Warteschlange hinzugefügt). Wir können Auftragsstatistiken (siehe Link ) verwenden, um diese Wahrscheinlichkeit zu berechnen. {0, 1}Nehmen wir zum Beispiel an, die Zahlen wurden zufällig gleichmäßig ausgewählt , der erwartete Wert der (iK) -ten Zahl (von i Zahlen) ist (i-k)/iund die Wahrscheinlichkeit, dass eine Zufallsvariable größer als dieser Wert ist 1-[(i-k)/i] = k/i.

Somit ist die erwartete Anzahl von Einfügungen:

Und die erwartete Laufzeit kann ausgedrückt werden als:

( kZeit zum Generieren der Warteschlange mit den ersten kElementen, dann n-kVergleiche und die erwartete Anzahl von Einfügungen, wie oben beschrieben, dauert jeweils durchschnittlich log(k)/2)

Beachten Sie, dass dieser Ausdruck , wenn er Nim Vergleich zu sehr groß Kist, viel näher ist nals NlogK. Dies ist etwas intuitiv, da im Fall der Frage selbst nach 10000 Iterationen (was im Vergleich zu einer Milliarde sehr klein ist) die Wahrscheinlichkeit, dass eine Zahl in die Warteschlange eingefügt wird, sehr gering ist.

Wenn dies in einem Interview gefragt wird, möchte der Interviewer wahrscheinlich Ihren Problemlösungsprozess sehen, nicht nur Ihr Wissen über Algorithmen.

Die Beschreibung ist recht allgemein gehalten. Vielleicht können Sie ihn nach dem Bereich oder der Bedeutung dieser Zahlen fragen, um das Problem zu verdeutlichen. Dies kann einen Interviewer beeindrucken. Wenn diese Zahlen beispielsweise für das Alter der Menschen in einem Land (z. B. China) stehen, ist dies ein viel einfacheres Problem. Mit der vernünftigen Annahme, dass niemand am Leben älter als 200 Jahre ist, können Sie ein int-Array der Größe 200 (möglicherweise 201) verwenden, um die Anzahl der Personen mit demselben Alter in nur einer Iteration zu zählen. Hier bedeutet der Index das Alter. Danach ist es ein Kinderspiel, die 100 größte Anzahl zu finden. Übrigens heißt dieses Algo Zählsortierung .

Wie auch immer, die Frage spezifischer und klarer zu machen, ist gut für Sie in einem Interview.

Sie können über die Zahlen iterieren, die O (n) annehmen.

Wenn Sie einen Wert finden, der größer als das aktuelle Minimum ist, fügen Sie den neuen Wert einer kreisförmigen Warteschlange mit der Größe 100 hinzu.

Das Minimum dieser kreisförmigen Warteschlange ist Ihr neuer Vergleichswert. Fügen Sie diese Warteschlange weiter hinzu. Wenn voll, extrahieren Sie das Minimum aus der Warteschlange.

Ich habe festgestellt, dass dies mit "Algorithmus" gekennzeichnet ist, aber einige andere Optionen wegwerfen wird, da es wahrscheinlich auch mit "Interview" gekennzeichnet sein sollte.

Woher stammen die 1 Milliarde Zahlen? Wenn es sich um eine Datenbank handelt, würde 'Wert aus Tabellenreihenfolge nach Wert absteigender Grenzwert 100 auswählen' die Aufgabe recht gut erfüllen - es kann Dialektunterschiede geben.

Ist das einmalig oder wird es wiederholt? Wenn wiederholt, wie oft? Wenn es sich um ein Einzelstück handelt und sich die Daten in einer Datei befinden, wird 'cat srcfile | sortieren (Optionen nach Bedarf) | Mit head -100 'erledigen Sie schnell produktive Arbeit, für die Sie bezahlt werden, während der Computer diese triviale Aufgabe erledigt.

Wenn es wiederholt wird, empfehlen wir Ihnen, einen angemessenen Ansatz zu wählen, um die erste Antwort zu erhalten und die Ergebnisse zu speichern / zwischenzuspeichern, damit Sie kontinuierlich die Top 100 melden können.

Schließlich gibt es diese Überlegung. Suchen Sie einen Einstiegsjob und ein Interview mit einem geekigen Manager oder zukünftigen Mitarbeiter? Wenn ja, können Sie alle Arten von Ansätzen herauswerfen, die die relativen technischen Vor- und Nachteile beschreiben. Wenn Sie nach einem eher leitenden Job suchen, gehen Sie wie ein Manager vor, der sich mit den Entwicklungs- und Wartungskosten der Lösung befasst, und sagen Sie "Vielen Dank" und gehen Sie, wenn sich der Interviewer auf CS-Trivia konzentrieren möchte . Es ist unwahrscheinlich, dass er und Sie dort viel Aufstiegspotenzial haben.

Viel Glück beim nächsten Interview.

Meine unmittelbare Reaktion darauf wäre die Verwendung eines Heaps, aber es gibt eine Möglichkeit, QuickSelect zu verwenden, ohne alle Eingabewerte gleichzeitig zur Hand zu haben.

Erstellen Sie ein Array der Größe 200 und füllen Sie es mit den ersten 200 Eingabewerten. Führen Sie QuickSelect aus und verwerfen Sie die niedrigen 100, sodass Sie 100 freie Plätze haben. Lesen Sie die nächsten 100 Eingabewerte ein und führen Sie QuickSelect erneut aus. Fahren Sie fort, bis Sie die gesamte Eingabe in Stapeln von 100 durchlaufen haben.

Am Ende haben Sie die Top 100 Werte. Für N Werte haben Sie QuickSelect ungefähr N / 100 Mal ausgeführt. Jede Quickselect kostet ungefähr das 200-fache einer Konstanten, sodass die Gesamtkosten das 2N-fache einer Konstanten betragen. Dies sieht für mich in der Größe der Eingabe linear aus, unabhängig von der Parametergröße, die ich in dieser Erklärung fest verdrahtet habe, um 100 zu sein.

Sie können den Schnellauswahlalgorithmus verwenden , um die Zahl im (nach Reihenfolge) Index [Milliarde-101] zu finden und dann über die Zahlen zu iterieren und die Zahlen zu finden, die von dieser Zahl abweichen.

array={...the billion numbers...} 
result[100];

pivot=QuickSelect(array,billion-101);//O(N)

for(i=0;i<billion;i++)//O(N)
   if(array[i]>=pivot)
      result.add(array[i]);

Dieser Algorithmus Zeit ist: 2 XO (N) = O (N) (durchschnittliche Fallleistung)

Die zweite Option, wie sie Thomas Jungblut vorschlägt, ist:

Verwenden Sie Heap , um den MAX-Heap zu erstellen. Er nimmt O (N). Die obersten 100 Maximalzahlen befinden sich oben auf dem Heap. Sie müssen sie lediglich aus dem Heap entfernen (100 XO (Log (N)).

Dieser Algorithmus Zeit ist: O (N) + 100 XO (Log (N)) = O (N)

Obwohl die andere Quickselect-Lösung herabgestuft wurde, bleibt die Tatsache bestehen, dass Quickselect die Lösung schneller findet als die Verwendung einer Warteschlange der Größe 100. Quickselect hat in Bezug auf Vergleiche eine erwartete Laufzeit von 2n + o (n). Eine sehr einfache Implementierung wäre

array = input array of length n
r = Quickselect(array,n-100)
result = array of length 100
for(i = 1 to n)
  if(array[i]>r)
     add array[i] to result

Dies erfordert durchschnittlich 3n + o (n) Vergleiche. Darüber hinaus kann es effizienter gestaltet werden, indem bei der Schnellauswahl die 100 größten Elemente im Array an den 100 am weitesten rechts liegenden Stellen verbleiben. Tatsächlich kann die Laufzeit auf 2n + o (n) verbessert werden.

Es gibt das Problem, dass dies die erwartete Laufzeit ist und nicht der schlimmste Fall. Wenn Sie jedoch eine anständige Pivot-Auswahlstrategie verwenden (z. B. 21 Elemente zufällig auswählen und den Median dieser 21 als Pivot auswählen), kann die Anzahl der Vergleiche sein garantiert mit hoher Wahrscheinlichkeit höchstens (2 + c) n für eine beliebig kleine Konstante c.

Tatsächlich kann durch Verwendung einer optimierten Stichprobenstrategie (z. B. zufällige Auswahl von sqrt (n) -Elementen und Auswahl des 99. Perzentils) die Laufzeit für beliebig kleine c auf (1 + c) n + o (n) gesenkt werden (unter der Annahme, dass K die Anzahl der auszuwählenden Elemente o (n) ist).

Andererseits erfordert die Verwendung einer Warteschlange der Größe 100 O (log (100) n) -Vergleiche, und die Protokollbasis 2 von 100 ist ungefähr gleich 6,6.

Wenn wir dieses Problem im abstrakteren Sinne betrachten, indem wir die größten K-Elemente aus einem Array der Größe N auswählen, wobei K = o (N) ist, aber sowohl K als auch N unendlich sind, dann ist die Laufzeit der Schnellauswahlversion O (N) und die Warteschlangenversion sind O (N log K), daher ist die Schnellauswahl in diesem Sinne auch asymptotisch überlegen.

In Kommentaren wurde erwähnt, dass die Warteschlangenlösung in der erwarteten Zeit N + K log N bei einer zufälligen Eingabe ausgeführt wird. Natürlich ist die Annahme einer zufälligen Eingabe niemals gültig, es sei denn, die Frage gibt dies ausdrücklich an. Die Warteschlangenlösung könnte dazu dienen, das Array in zufälliger Reihenfolge zu durchlaufen. Dies verursacht jedoch die zusätzlichen Kosten für N Aufrufe an einen Zufallszahlengenerator sowie die Permutation des gesamten Eingabearrays oder die Zuweisung eines neuen Arrays der Länge N, das das enthält zufällige Indizes.

Wenn das Problem es Ihnen nicht erlaubt, sich in den Elementen des ursprünglichen Arrays zu bewegen, und die Kosten für die Zuweisung von Speicher hoch sind, ist das Duplizieren des Arrays keine Option, das ist eine andere Sache. Aber genau in Bezug auf die Laufzeit ist dies die beste Lösung.

Nehmen Sie die ersten 100 Zahlen der Milliarde und sortieren Sie sie. Jetzt einfach durch die Milliarde iterieren. Wenn die Quellennummer höher als die kleinste von 100 ist, in Sortierreihenfolge einfügen. Was Sie am Ende haben, ist etwas, das O (n) über die Größe des Sets viel näher kommt.

Zwei Optionen:

(1) Heap (priorityQueue)

Pflegen Sie einen Min-Heap mit einer Größe von 100. Durchlaufen Sie das Array. Wenn das Element kleiner als das erste Element im Heap ist, ersetzen Sie es.

InSERT ELEMENT INTO HEAP: O（log100）
compare the first element: O(1)
There are n elements in the array, so the total would be O(nlog100), which is O(n)

(2) Kartenreduzierungsmodell.

Dies ist dem Beispiel für die Wortanzahl in hadoop sehr ähnlich. Kartenjob: Zählen Sie die Häufigkeit oder die Zeiten jedes Elements. Reduzieren: Holen Sie sich das oberste K-Element.

Normalerweise würde ich dem Personalvermittler zwei Antworten geben. Gib ihnen was sie wollen. Natürlich wäre die Codierung zur Kartenreduzierung arbeitsintensiv, da Sie alle genauen Parameter kennen müssen. Kein Schaden, es zu üben. Viel Glück.

Eine sehr einfache Lösung wäre, das Array 100 Mal zu durchlaufen. Welches ist O(n).

Jedes Mal, wenn Sie die größte Zahl herausziehen (und ihren Wert auf den Mindestwert ändern, damit Sie ihn in der nächsten Iteration nicht sehen, oder die Indizes früherer Antworten verfolgen (indem Sie die Indizes verfolgen, die das ursprüngliche Array haben kann) Vielfaches derselben Zahl)). Nach 100 Iterationen haben Sie die 100 größten Zahlen.

Inspiriert von der Antwort von @ron teller, finden Sie hier ein Barebone-C-Programm, mit dem Sie tun können, was Sie wollen.

#include <stdlib.h>
#include <stdio.h>

#define TOTAL_NUMBERS 1000000000
#define N_TOP_NUMBERS 100

int 
compare_function(const void *first, const void *second)
{
    int a = *((int *) first);
    int b = *((int *) second);
    if (a > b){
        return 1;
    }
    if (a < b){
        return -1;
    }
    return 0;
}

int 
main(int argc, char ** argv)
{
    if(argc != 2){
        printf("please supply a path to a binary file containing 1000000000"
               "integers of this machine's wordlength and endianness\n");
        exit(1);
    }
    FILE * f = fopen(argv[1], "r");
    if(!f){
        exit(1);
    }
    int top100[N_TOP_NUMBERS] = {0};
    int sorts = 0;
    for (int i = 0; i < TOTAL_NUMBERS; i++){
        int number;
        int ok;
        ok = fread(&number, sizeof(int), 1, f);
        if(!ok){
            printf("not enough numbers!\n");
            break;
        }
        if(number > top100[0]){
            sorts++;
            top100[0] = number;
            qsort(top100, N_TOP_NUMBERS, sizeof(int), compare_function);
        }

    }
    printf("%d sorts made\n"
    "the top 100 integers in %s are:\n",
    sorts, argv[1] );
    for (int i = 0; i < N_TOP_NUMBERS; i++){
        printf("%d\n", top100[i]);
    }
    fclose(f);
    exit(0);
}

Auf meinem Computer (Core i3 mit einer schnellen SSD) dauert es 25 Sekunden und 1724 sortiert. Ich habe dd if=/dev/urandom/ count=1000000000 bs=1für diesen Lauf eine Binärdatei mit generiert .

Offensichtlich gibt es Leistungsprobleme beim Lesen von jeweils nur 4 Bytes - von der Festplatte, aber dies ist zum Beispiel der Fall. Auf der positiven Seite wird sehr wenig Speicher benötigt.

Die einfachste Lösung besteht darin, das große Array mit Milliardenzahlen zu scannen und die 100 größten bisher gefundenen Werte in einem kleinen Array-Puffer ohne Sortierung zu speichern und sich den kleinsten Wert dieses Puffers zu merken. Zuerst dachte ich, dass diese Methode von fordprefect vorgeschlagen wurde, aber in einem Kommentar sagte er, dass er die 100-Zahlen-Datenstruktur als Heap implementierte. Immer wenn eine neue Zahl gefunden wird, die größer ist, wird das Minimum im Puffer durch den neu gefundenen Wert überschrieben und der Puffer erneut nach dem aktuellen Minimum durchsucht. Wenn die Zahlen im Milliarden-Zahlen-Array die meiste Zeit zufällig verteilt sind, wird der Wert aus dem großen Array mit dem Minimum des kleinen Arrays verglichen und verworfen. Nur für einen sehr sehr kleinen Bruchteil der Zahl muss der Wert in das kleine Array eingefügt werden. Daher kann der Unterschied bei der Manipulation der Datenstruktur, die die kleinen Zahlen enthält, vernachlässigt werden. Für eine kleine Anzahl von Elementen ist es schwierig festzustellen, ob die Verwendung einer Prioritätswarteschlange tatsächlich schneller ist als die Verwendung meines naiven Ansatzes.

Ich möchte die Anzahl der Einfügungen im kleinen 100-Element-Array-Puffer schätzen, wenn das 10 ^ 9-Element-Array gescannt wird. Das Programm scannt die ersten 1000 Elemente dieses großen Arrays und muss höchstens 1000 Elemente in den Puffer einfügen. Der Puffer enthält 100 Elemente der 1000 gescannten Elemente, dh 0,1 der gescannten Elemente. Wir nehmen also an, dass die Wahrscheinlichkeit, dass ein Wert aus dem großen Array größer als das aktuelle Minimum des Puffers ist, etwa 0,1 beträgt. Ein solches Element muss in den Puffer eingefügt werden. Jetzt scannt das Programm die nächsten 10 ^ 4 Elemente aus dem großen Array. Weil sich das Minimum des Puffers jedes Mal erhöht, wenn ein neues Element eingefügt wird. Wir haben geschätzt, dass das Verhältnis der Elemente, die größer als unser aktuelles Minimum sind, ungefähr 0,1 beträgt, und daher müssen 0,1 * 10 ^ 4 = 1000 Elemente eingefügt werden. Tatsächlich ist die erwartete Anzahl von Elementen, die in den Puffer eingefügt werden, kleiner. Nach dem Scannen dieser 10 ^ 4 Elemente beträgt der Bruchteil der Zahlen im Puffer etwa 0,01 der bisher gescannten Elemente. Wenn wir also die nächsten 10 ^ 5 Zahlen scannen, gehen wir davon aus, dass nicht mehr als 0,01 * 10 ^ 5 = 1000 in den Puffer eingefügt werden. In Fortsetzung dieser Argumentation haben wir nach dem Scannen von 1000 + 10 ^ 4 + 10 ^ 5 + ... + 10 ^ 9 ~ 10 ^ 9 Elementen des großen Arrays etwa 7000 Werte eingefügt. Wenn wir also ein Array mit 10 ^ 9 Elementen zufälliger Größe scannen, erwarten wir nicht mehr als 10 ^ 4 (= 7000 aufgerundete) Einfügungen in den Puffer. Nach jedem Einfügen in den Puffer muss das neue Minimum gefunden werden. Wenn der Puffer ein einfaches Array ist, benötigen wir einen Vergleich von 100, um das neue Minimum zu finden. Wenn der Puffer eine andere Datenstruktur ist (wie ein Heap), benötigen wir mindestens einen Vergleich, um das Minimum zu finden. Um die Elemente des großen Arrays zu vergleichen, benötigen wir 10 ^ 9 Vergleiche. Alles in allem benötigen wir also ungefähr 10 ^ 9 + 100 * 10 ^ 4 = 1,001 * 10 ^ 9 Vergleiche, wenn wir ein Array als Puffer verwenden, und mindestens 1.000 * 10 ^ 9 Vergleiche, wenn wir eine andere Art von Datenstruktur verwenden (wie einen Heap). . Die Verwendung eines Heaps bringt also nur einen Gewinn von 0,1%, wenn die Leistung durch die Anzahl der Vergleiche bestimmt wird. Aber was ist der Unterschied in der Ausführungszeit zwischen dem Einfügen eines Elements in einen 100-Element-Heap und dem Ersetzen eines Elements in einem 100-Element-Array und dem Finden seines neuen Minimums? 000 * 10 ^ 9 Vergleiche bei Verwendung einer anderen Art von Datenstruktur (wie ein Heap). Die Verwendung eines Heaps bringt also nur einen Gewinn von 0,1%, wenn die Leistung durch die Anzahl der Vergleiche bestimmt wird. Aber was ist der Unterschied in der Ausführungszeit zwischen dem Einfügen eines Elements in einen 100-Element-Heap und dem Ersetzen eines Elements in einem 100-Element-Array und dem Finden seines neuen Minimums? 000 * 10 ^ 9 Vergleiche bei Verwendung einer anderen Art von Datenstruktur (wie ein Heap). Die Verwendung eines Heaps bringt also nur einen Gewinn von 0,1%, wenn die Leistung durch die Anzahl der Vergleiche bestimmt wird. Aber was ist der Unterschied in der Ausführungszeit zwischen dem Einfügen eines Elements in einen 100-Element-Heap und dem Ersetzen eines Elements in einem 100-Element-Array und dem Finden seines neuen Minimums?

• Auf theoretischer Ebene: Wie viele Vergleiche werden zum Einfügen in einen Heap benötigt? Ich weiß, dass es O (log (n)) ist, aber wie groß ist der konstante Faktor? ich

• Auf Maschinenebene: Welche Auswirkungen haben Caching und Verzweigungsvorhersage auf die Ausführungszeit einer Heap-Einfügung und einer linearen Suche in einem Array?

• Auf Implementierungsebene: Welche zusätzlichen Kosten sind in einer Heap-Datenstruktur verborgen, die von einer Bibliothek oder einem Compiler bereitgestellt wird?

Ich denke, dies sind einige der Fragen, die beantwortet werden müssen, bevor man versuchen kann, den tatsächlichen Unterschied zwischen der Leistung eines 100-Elemente-Heaps oder eines 100-Elemente-Arrays abzuschätzen. Es wäre also sinnvoll, ein Experiment durchzuführen und die tatsächliche Leistung zu messen.

 Although in this question we should search for top 100 numbers, I will 
 generalize things and write x. Still, I will treat x as constant value.

Algorithmus Größte x-Elemente aus n:

Ich werde den Rückgabewert LIST aufrufen . Es ist eine Reihe von x Elementen (meiner Meinung nach sollte die Liste verknüpft werden)

• Die ersten x Elemente werden "wie sie kommen" aus dem Pool entnommen und in LIST sortiert (dies erfolgt in konstanter Zeit, da x als konstante O (x log (x)) Zeit behandelt wird).
• Für jedes Element, das als nächstes kommt, prüfen wir, ob es größer als das kleinste Element in LIST ist, und ob es das kleinste herausspringt und das aktuelle Element in LIST einfügt. Da es sich um eine geordnete Liste handelt, sollte jedes Element seinen Platz in der logarithmischen Zeit finden (binäre Suche), und da es geordnet ist, ist das Einfügen von Listen kein Problem. Jeder Schritt wird auch in konstanter Zeit (O (log (x)) Zeit) ausgeführt.

Was ist der schlimmste Fall?

x log (x) + (nx) (log (x) +1) = nlog (x) + n - x

Das ist also O (n) Zeit für den schlimmsten Fall. Die +1 ist die Überprüfung, ob die Anzahl größer als die kleinste in LIST ist. Die erwartete Zeit für den Durchschnittsfall hängt von der mathematischen Verteilung dieser n Elemente ab.

Mögliche Verbesserungen

Dieser Algorithmus kann für das Worst-Case-Szenario leicht verbessert werden, aber IMHO (ich kann diese Behauptung nicht beweisen) wird das durchschnittliche Verhalten verschlechtern. Das asymptotische Verhalten wird dasselbe sein.

Die Verbesserung dieses Algorithmus besteht darin, dass wir nicht prüfen, ob das Element größer als das kleinste ist. Für jedes Element werden wir versuchen, es einzufügen, und wenn es kleiner als das kleinste ist, werden wir es ignorieren. Obwohl das absurd klingt, wenn wir nur das Worst-Case-Szenario betrachten, das wir haben werden

x log (x) + (nx) log (x) = nlog (x)

Operationen.

Für diesen Anwendungsfall sehe ich keine weiteren Verbesserungen. Sie müssen sich jedoch fragen: Was ist, wenn ich dies mehr als log (n) Mal und für verschiedene x-es tun muss? Offensichtlich würden wir dieses Array in O (n log (n)) sortieren und unser x-Element nehmen, wann immer wir es brauchen.

Diese Frage würde mit N log (100) Komplexität (anstelle von N log N) mit nur einer Zeile C ++ - Code beantwortet.

 std::vector<int> myvector = ...; // Define your 1 billion numbers. 
                                 // Assumed integer just for concreteness 
 std::partial_sort (myvector.begin(), myvector.begin()+100, myvector.end());

Die endgültige Antwort wäre ein Vektor, bei dem die ersten 100 Elemente garantiert die 100 größten Zahlen Ihres Arrays sind, während die verbleibenden Elemente ungeordnet sind

C ++ STL (Standardbibliothek) ist für diese Art von Problemen sehr praktisch.

Hinweis: Ich sage nicht, dass dies die optimale Lösung ist, aber es hätte Ihr Interview gespeichert.

Die einfache Lösung wäre, eine Prioritätswarteschlange zu verwenden, die ersten 100 Nummern zur Warteschlange hinzuzufügen und die kleinste Nummer in der Warteschlange zu verfolgen, dann die anderen Milliarden Nummern zu durchlaufen und jedes Mal eine zu finden, die größer als die größte Nummer ist In der Prioritätswarteschlange entfernen wir die kleinste Nummer, fügen die neue Nummer hinzu und verfolgen erneut die kleinste Nummer in der Warteschlange.

Wenn die Zahlen in zufälliger Reihenfolge wären, würde dies sehr gut funktionieren, da es beim Durchlaufen einer Milliarde Zufallszahlen sehr selten ist, dass die nächste Zahl zu den 100 größten gehört, die es bisher gab. Aber die Zahlen sind möglicherweise nicht zufällig. Wenn das Array bereits in aufsteigender Reihenfolge sortiert war, fügten wir immer ein Element in die Prioritätswarteschlange ein.

Also wählen wir zuerst 100.000 Zufallszahlen aus dem Array aus. Um einen langsamen Direktzugriff zu vermeiden, fügen wir beispielsweise 400 Zufallsgruppen mit 250 aufeinander folgenden Zahlen hinzu. Mit dieser zufälligen Auswahl können wir ziemlich sicher sein, dass nur sehr wenige der verbleibenden Zahlen in den Top 100 liegen, sodass die Ausführungszeit sehr nahe an der einer einfachen Schleife liegt, die eine Milliarde Zahlen mit einem Maximalwert vergleicht.

Das Finden der Top 100 aus einer Milliarde Zahlen erfolgt am besten mit einem Min-Heap von 100 Elementen.

Primen Sie zuerst den Min-Heap mit den ersten 100 gefundenen Zahlen. min-heap speichert die kleinste der ersten 100 Zahlen im Stammverzeichnis (oben).

Wenn Sie nun den Rest der Zahlen entlang gehen, vergleichen Sie sie nur mit der Wurzel (kleinste der 100).

Wenn die neu gefundene Nummer größer als die Wurzel von min-heap ist, ersetzen Sie die Wurzel durch diese Zahl, andernfalls ignorieren Sie sie.

Beim Einfügen der neuen Nummer in min-heap wird die kleinste Nummer im Heap an die Spitze (root) gesetzt.

Sobald wir alle Zahlen durchgegangen sind, haben wir die größten 100 Zahlen im Min-Heap.

Ich habe eine einfache Lösung in Python geschrieben, falls jemand interessiert ist. Es verwendet das bisectModul und eine temporäre Rückgabeliste, die sortiert bleibt. Dies ähnelt einer Implementierung einer Prioritätswarteschlange.

import bisect

def kLargest(A, k):
    '''returns list of k largest integers in A'''
    ret = []
    for i, a in enumerate(A):
        # For first k elements, simply construct sorted temp list
        # It is treated similarly to a priority queue
        if i < k:
            bisect.insort(ret, a) # properly inserts a into sorted list ret
        # Iterate over rest of array
        # Replace and update return array when more optimal element is found
        else:
            if a > ret[0]:
                del ret[0] # pop min element off queue
                bisect.insort(ret, a) # properly inserts a into sorted list ret
    return ret

Verwendung mit 100.000.000 Elementen und Worst-Case-Eingabe, die eine sortierte Liste ist:

>>> from so import kLargest
>>> kLargest(range(100000000), 100)
[99999900, 99999901, 99999902, 99999903, 99999904, 99999905, 99999906, 99999907,
 99999908, 99999909, 99999910, 99999911, 99999912, 99999913, 99999914, 99999915,
 99999916, 99999917, 99999918, 99999919, 99999920, 99999921, 99999922, 99999923,
 99999924, 99999925, 99999926, 99999927, 99999928, 99999929, 99999930, 99999931,
 99999932, 99999933, 99999934, 99999935, 99999936, 99999937, 99999938, 99999939,
 99999940, 99999941, 99999942, 99999943, 99999944, 99999945, 99999946, 99999947,
 99999948, 99999949, 99999950, 99999951, 99999952, 99999953, 99999954, 99999955,
 99999956, 99999957, 99999958, 99999959, 99999960, 99999961, 99999962, 99999963,
 99999964, 99999965, 99999966, 99999967, 99999968, 99999969, 99999970, 99999971,
 99999972, 99999973, 99999974, 99999975, 99999976, 99999977, 99999978, 99999979,
 99999980, 99999981, 99999982, 99999983, 99999984, 99999985, 99999986, 99999987,
 99999988, 99999989, 99999990, 99999991, 99999992, 99999993, 99999994, 99999995,
 99999996, 99999997, 99999998, 99999999]

Es hat ungefähr 40 Sekunden gedauert, um dies für 100.000.000 Elemente zu berechnen, also habe ich Angst, es für 1 Milliarde zu tun. Um fair zu sein, habe ich ihm den Worst-Case-Input zugeführt (ironischerweise ein Array, das bereits sortiert ist).

Ich sehe viele O (N) -Diskussionen, daher schlage ich etwas anderes vor, nur für die Gedankenübung.

Gibt es bekannte Informationen über die Art dieser Zahlen? Wenn es zufälliger Natur ist, gehen Sie nicht weiter und schauen Sie sich die anderen Antworten an. Sie werden keine besseren Ergebnisse erzielen als sie.

Jedoch! Überprüfen Sie, ob der Listenfüllungsmechanismus diese Liste in einer bestimmten Reihenfolge gefüllt hat. Befinden sie sich in einem genau definierten Muster, in dem Sie mit Sicherheit wissen können, dass die größte Anzahl von Zahlen in einem bestimmten Bereich der Liste oder in einem bestimmten Intervall gefunden wird? Es kann ein Muster geben. Wenn dies der Fall ist, z. B. wenn garantiert wird, dass sie sich in einer Art Normalverteilung mit dem charakteristischen Buckel in der Mitte befinden, immer wieder aufwärts gerichtete Trends zwischen definierten Teilmengen aufweisen und zu einem bestimmten Zeitpunkt T in der Mitte der Daten eine verlängerte Spitze aufweisen Wenn Sie beispielsweise die Häufigkeit von Insidergeschäften oder Ausrüstungsfehlern festlegen oder einfach jede N-te Zahl wie bei der Analyse der Streitkräfte nach einer Katastrophe einen "Spike" aufweisen, können Sie die Anzahl der zu überprüfenden Datensätze erheblich reduzieren.

Es gibt sowieso einige Denkanstöße. Vielleicht hilft Ihnen dies, zukünftigen Interviewern eine nachdenkliche Antwort zu geben. Ich weiß, ich wäre beeindruckt, wenn mir jemand eine solche Frage als Antwort auf ein Problem wie dieses stellen würde - es würde mir sagen, dass er über Optimierung nachdenkt. Beachten Sie nur, dass es möglicherweise nicht immer eine Möglichkeit zur Optimierung gibt.

Time ~ O(100 * N)
Space ~ O(100 + N)

1. Erstellen Sie eine leere Liste mit 100 leeren Slots

2. Für jede Nummer in der Eingabeliste:

   • Wenn die Zahl kleiner als die erste ist, überspringen Sie

   • Andernfalls ersetzen Sie es durch diese Nummer

   • Schieben Sie dann die Nummer durch den benachbarten Swap. bis es kleiner als das nächste ist

3. Geben Sie die Liste zurück

Hinweis: Wenn dies der log(input-list.size) + c < 100Fall ist, besteht der optimale Weg darin, die Eingabeliste zu sortieren und die ersten 100 Elemente aufzuteilen.

Die Komplexität ist O (N)

Erstellen Sie zunächst ein Array mit 100 Zoll. Initialisieren Sie das erste Element dieses Arrays als erstes Element der N-Werte. Verfolgen Sie den Index des aktuellen Elements mit einer anderen Variablen und nennen Sie es CurrentBig

Durchlaufen Sie die N-Werte

if N[i] > M[CurrentBig] {

M[CurrentBig]=N[i]; ( overwrite the current value with the newly found larger number)

CurrentBig++;      ( go to the next position in the M array)

CurrentBig %= 100; ( modulo arithmetic saves you from using lists/hashes etc.)

M[CurrentBig]=N[i];    ( pick up the current value again to use it for the next Iteration of the N array)

} 

Wenn Sie fertig sind, drucken Sie das M-Array von CurrentBig 100 mal modulo 100 :-) Für den Schüler: Stellen Sie sicher, dass die letzte Zeile des Codes keine gültigen Daten übertrifft, bevor der Code beendet wird

Ein weiterer O (n) -Algorithmus -

Der Algorithmus findet die größten 100 durch Eliminierung

Betrachten Sie alle Millionen Zahlen in ihrer binären Darstellung. Beginnen Sie mit dem wichtigsten Punkt. Das Finden, ob das MSB 1 ist, kann durch eine Boolesche Operationsmultiplikation mit einer geeigneten Zahl erfolgen. Wenn diese Million mehr als 100 Einsen enthält, eliminieren Sie die anderen Zahlen mit Nullen. Von den verbleibenden Zahlen fahren Sie nun mit dem nächsthöheren Bit fort. Zählen Sie die Anzahl der verbleibenden Nummern nach der Eliminierung und fahren Sie fort, solange diese Anzahl größer als 100 ist.

Die Haupt-Boolesche Operation kann parallel zu GPUs ausgeführt werden

Ich würde herausfinden, wer die Zeit hatte, eine Milliarde Zahlen in ein Array zu stecken und ihn zu feuern. Muss für die Regierung arbeiten. Zumindest wenn Sie eine verknüpfte Liste hätten, könnten Sie eine Zahl in die Mitte einfügen, ohne eine halbe Milliarde zu bewegen, um Platz zu schaffen. Noch besser ermöglicht ein Btree eine binäre Suche. Jeder Vergleich eliminiert die Hälfte Ihrer Gesamtsumme. Ein Hash-Algorithmus würde es Ihnen ermöglichen, die Datenstruktur wie ein Schachbrett zu füllen, aber nicht so gut für spärliche Daten. Da es am besten ist, ein Lösungsarray mit 100 Ganzzahlen zu haben und die niedrigste Zahl in Ihrem Lösungsarray zu verfolgen, können Sie sie ersetzen, wenn Sie auf eine höhere Zahl im ursprünglichen Array stoßen. Sie müssten sich jedes Element im ursprünglichen Array ansehen, vorausgesetzt, es ist zunächst nicht sortiert.

Sie können es O(n)rechtzeitig tun . Durchlaufen Sie einfach die Liste und verfolgen Sie die 100 größten Zahlen, die Sie zu einem bestimmten Zeitpunkt gesehen haben, sowie den Mindestwert in dieser Gruppe. Wenn Sie eine neue Zahl finden, die größer ist als die kleinste Ihrer zehn, ersetzen Sie sie und aktualisieren Sie Ihren neuen Mindestwert von 100 (es kann eine konstante Zeit von 100 dauern, um dies jedes Mal zu bestimmen, dies hat jedoch keinen Einfluss auf die Gesamtanalyse ).

Das Verwalten einer separaten Liste ist zusätzliche Arbeit und Sie müssen jedes Mal, wenn Sie einen anderen Ersatz finden, Dinge in der gesamten Liste verschieben. Sortieren Sie es einfach und nehmen Sie die Top 100.

1. Verwenden Sie das n-te Element, um das 100. Element O (n) zu erhalten.
2. Iterieren Sie das zweite Mal, aber nur einmal, und geben Sie jedes Element aus, das größer als dieses bestimmte Element ist.

Bitte beachten Sie esp. Der zweite Schritt könnte einfach parallel zu berechnen sein! Und es wird auch effizient sein, wenn Sie eine Million größter Elemente benötigen.

Dies ist eine Frage von Google oder anderen Branchenriesen. Möglicherweise ist der folgende Code die richtige Antwort, die von Ihrem Interviewer erwartet wird. Die Zeit- und Platzkosten hängen von der maximalen Anzahl im Eingabearray ab. Für 32-Bit-Int-Array-Eingaben betragen die maximalen Speicherkosten 4 * 125 MByte, die Zeitkosten 5 * Milliarden.

public class TopNumber {
    public static void main(String[] args) {
        final int input[] = {2389,8922,3382,6982,5231,8934
                            ,4322,7922,6892,5224,4829,3829
                            ,6892,6872,4682,6723,8923,3492};
        //One int(4 bytes) hold 32 = 2^5 value,
        //About 4 * 125M Bytes
        //int sort[] = new int[1 << (32 - 5)];
        //Allocate small array for local test
        int sort[] = new int[1000];
        //Set all bit to 0
        for(int index = 0; index < sort.length; index++){
            sort[index] = 0;
        }
        for(int number : input){
            sort[number >>> 5] |= (1 << (number % 32));
        }
        int topNum = 0;
        outer:
        for(int index = sort.length - 1; index >= 0; index--){
            if(0 != sort[index]){
                for(int bit = 31; bit >= 0; bit--){
                    if(0 != (sort[index] & (1 << bit))){
                        System.out.println((index << 5) + bit);
                        topNum++;
                        if(topNum >= 3){
                            break outer;
                        }
                    }
                }
            }
        }
    }
}

Ich habe meinen eigenen Code gemacht, nicht sicher, ob es das ist, wonach der "Interviewer" aussieht

private static final int MAX=100;
 PriorityQueue<Integer> queue = new PriorityQueue<>(MAX);
        queue.add(array[0]);
        for (int i=1;i<array.length;i++)
        {

            if(queue.peek()<array[i])
            {
                if(queue.size() >=MAX)
                {
                    queue.poll();
                }
                queue.add(array[i]);

            }

        }

Mögliche Verbesserungen.

Wenn die Datei 1 Milliarden Nummer enthält, kann das Lesen sehr lang sein ...

Um diese Arbeitsweise zu verbessern, können Sie:

• Teilen Sie die Datei in n Teile auf, erstellen Sie n Threads, lassen Sie n Threads jeweils nach den 100 größten Zahlen in ihrem Teil der Datei suchen (mithilfe der Prioritätswarteschlange) und erhalten Sie schließlich die 100 größten Zahlen aller ausgegebenen Threads.
• Verwenden Sie einen Cluster, um eine solche Aufgabe mit einer Lösung wie hadoop auszuführen. Hier können Sie die Datei noch mehr aufteilen und die Ausgabe für eine Datei mit 1 Milliarde (oder 10 ^ 12) Zahlen schneller ausführen.

Nehmen Sie zuerst 1000 Elemente und fügen Sie sie zu einem maximalen Haufen hinzu. Nehmen Sie nun die ersten maximal 100 Elemente heraus und speichern Sie sie irgendwo. Wählen Sie nun die nächsten 900 Elemente aus der Datei aus und fügen Sie sie zusammen mit den letzten 100 höchsten Elementen im Heap hinzu.

Wiederholen Sie diesen Vorgang, indem Sie 100 Elemente aus dem Heap aufnehmen und 900 Elemente aus der Datei hinzufügen.

Die endgültige Auswahl von 100 Elementen ergibt die maximalen 100 Elemente aus einer Milliarde Zahlen.

Problem: Finden Sie m größte Elemente von n Elementen, wobei n >>> m ist

Die einfachste Lösung, die für jeden offensichtlich sein sollte, besteht darin, einfach m Durchgänge des Blasensortierungsalgorithmus durchzuführen.

Drucken Sie dann die letzten n Elemente des Arrays aus.

Dies erfordert keine externen Datenstrukturen und verwendet einen Algorithmus, den jeder kennt.

Die geschätzte Laufzeit ist O (m * n). Die bisher besten Antworten sind O (n log (m)), daher ist diese Lösung für kleine m nicht wesentlich teurer.

Ich sage nicht, dass dies nicht verbessert werden könnte, aber dies ist bei weitem die einfachste Lösung.