C#: Schnelles Sortieren, dieselbe Nummer wird ignoriert, und dann die vorherige Suchrichtung fortsetzen, um die nächste Nummer zu finden, die die Ersetzungsanforderungen erfüllt

Überblick

Graben und füllen + teile und herrsche

Fassen Sie die Anzahl der Grabungen und Füllungen zusammen

1. i = L; j = R; Grabe die Referenznummer aus, um die erste Vertiefung a[i] zu bilden, zum Beispiel ist die erste Referenznummer 0-indiziert
2. j – Finden Sie eine kleinere Zahl von hinten nach vorne und graben Sie diese Zahl aus, um die vorherige Grube a [i] zu füllen, nachdem Sie sie gefunden haben.
3. i++ findet eine Zahl, die von vorne nach hinten größer ist, und gräbt diese Zahl aus, nachdem es sie gefunden hat, und füllt sie in das vorherige Loch a[j].
4. Wiederholen Sie die Schritte 2 und 3 bis i==j, füllen Sie die Referenznummer in a[i] ein und aktualisieren Sie den Index der linken Hälfte und den Index der rechten Hälfte gemäß der Referenz, wenn sie sich treffen
5. quick_sort(s, l, i - 1); quick_sort(s, i + 1, r); rekursiver Aufruf, bis jedes rekursive l gleich r ist, Rekursion beenden

void quick_sort(int s[], int l, int r)
{
    
    
    if (l < r){
    
    
        int i = l, j = r, x = s[l];
        while (i < j){
    
    
            while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
                --j; 
            if(i < j)
               s[i++] = s[j];           
            while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
                ++i; 
            if(i < j)
               s[j--] = s[i];
        }
 
        s[i] = x;
        quick_sort(s, l, i - 1); // 递归调用
        quick_sort(s, i + 1, r);
 
    }
}

Was ist der Prozess der schnellen Sortierung, wenn es die gleichen Nummern gibt?

Dieselbe Nummer wird ignoriert, und dann wird die vorherige Suchrichtung fortgesetzt, um die nächste Nummer zu finden, die die Ersetzungsanforderungen erfüllt

prüfen

int[] array = new int[8] { 5 ,2, 2, 1, 7 ,3, 4, 4 };

zeitliche Komplexität

O (nlogn)

Die O(log n)-Analyse
ist ein weiteres Beispiel für O(log n). Wenn die Daten um das n-fache erhöht werden, dauert es einige Zeit, um das log n-fache zu erhöhen (das log basiert hier auf 2. Zum Beispiel, wenn die Daten sind um das 256-fache erhöht, Der Zeitaufwand wird nur um das 8-fache erhöht, was eine geringere Zeitkomplexität als linear darstellt). Die binäre Suche ist ein O(log n)-Algorithmus.Jede Suche schließt die Hälfte der Möglichkeiten aus, und das Ziel kann durch8-maliges Suchen unter 256 Daten gefunden werden.

Leicht verständliches Beispiel

Das ist, als hätte man hundert Schlüssel. Du denkst plötzlich, ist es zu langsam für mich, von Anfang an zu suchen? Ich suche von der Mitte. Wenn ich zum Beispiel den Zimmerschlüssel von Nr. 23 finden will, schneide ich ihn ab die Mitte, um die Position von Nr. 50 zu finden. Dann ist 23 innerhalb von 150, ich schneide es von der Mitte aus, um 25 zu werden, dann liegt 23 zwischen 125, ich schneide es erneut, um 12,5 zu werden, und dann liegt 23 zwischen 12,5 und 25, und ich suche der Reihe nach, bis ich den Schlüssel finde. Die Komplexität dieser Methode zum Auffinden von Schlüsseln ist O(log^n)

O(n log n)-Analyse
O(n log n) ist dasselbe, dh n wird mit log n multipliziert. Wenn die Daten um das 256-fache erhöht werden, beträgt die zeitaufwendige Erhöhung 256*8=2048-mal. Diese Komplexität ist höher als linear und niedriger als quadratisch. Zusammenführungssortierung ist O(n log n) Zeitkomplexität.

Quellcode

https://github.com/luoyikun/UnityForTest
SortScene-Szene