Zählen Sie die Sortierkomplexität

Was ist die Zählung Sort?

Die Zählsart ist am besten mit der Sortierung von Ganzzahlen illustriert. In C/C ++ und Java sind die Charaktere Ganzzahlen und können so sortiert werden, wie die Ganzzahlen sortiert sind. Betrachten Sie die folgende unortheilte Liste von Ganzzahlen:

16, 20, 12, 10, 18, 8, 12, 18, 12, 14

Diese Liste ist in aufsteigender Reihenfolge sortiert. Es kann (von dem Sortierprogramm empfangen) als Array gegeben werden. Es besteht aus positiven Zahlen, die größer oder gleich 0 sind.

Beachten Sie hier, dass die höchste Ganzzahl 20 ist. Also müssen 20 + 1 = 21 Neuarray -Standorte zur Verfügung gestellt werden. Das Extra 1 ist für die Möglichkeit, dass eine der zu sortierten Zahlen 0 ist. Denken Sie daran, dass das Sortierprogramm die Zahlen nicht kennt, die im Voraus sortiert werden sollen. Die Möglichkeit, 0 zu haben, sollte also gemacht werden.

Für jeden Index des Neuarrays, der einem Wert in der angegebenen Liste entspricht, wird die Anzahl der Auftritte des Wertes in der angegebenen Liste als Wert für diese neue Array -Zelle zugewiesen. Das heißt, das neue Array besteht aus Zählern. Die vorherige unsortierte Liste wird wie folgt dargestellt:

0	0	0	0	0	0	0	0	1	0	1	0	3	0	1	0	1	0	2	0	1
0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20

Diese Tabelle repräsentiert ein Array, das das neue Array von Zählern ist. In diesem Stadium gibt es zwei Arrays: das angegebene Array der unsortierten Liste und das Array der Zähler, die als Count Array bezeichnet werden.

In der Tabelle hat die zweite Zeile die Indizes. Die erste Reihe hat die Zählungen. Jede Anzahl ist die Anzahl des Auftretens des entsprechenden Index, der als Wert in der ungeortierten Liste gefunden wurde.

Für die Indizes 0 bis 7 (inklusive) beträgt die Anzahl 0. Dies liegt daran. Der Index 8 tritt einmal in der Liste auf, so dass seine Anzahl 1 beträgt. Der Index 9 tritt in der Liste Nullzeiten auf, sodass seine Anzahl 0 beträgt. Der Index 10 tritt einmal in der Liste auf, so dass seine Anzahl 1 beträgt. Der Index 12 tritt in der Liste dreimal auf, so dass seine Anzahl 3 beträgt. Der Index 13 tritt in der Liste Nullzeiten auf, so dass seine Anzahl 0 beträgt. Dies dauert bis zum Index 20 mit einer Anzahl von 1, während der Index 18 eine Anzahl von 2 hat.

Die sortierte Liste lautet wie folgt:

8, 10, 12, 12, 12, 14, 16, 18, 18, 20

Dies kann aus dem Grafen -Array (neu) wie folgt erhalten werden:

Wenn Sie von links nach rechts wechseln, liegt der Wert nicht in der angegebenen unsortierten Liste (Array), wenn der Wert eines Index 0 beträgt. Wenn der Wert 1 ist, geben Sie den Index einmal ein. Wenn der Wert 2 ist, geben Sie den Index zweimal ein. Wenn der Wert 3 ist, geben Sie den Index dreimal ein. Wenn der Wert 4 ist, geben Sie den Index 4 Mal ein und so weiter. All dies kann wieder auf dem angegebenen unsortierten Array durchgeführt werden (Liste).

Zählen Sie Sortal -Algorithmus

• Geben Sie ein Array an, dessen Länge die maximale Zahl in der ungeortierten Liste plus 1 ist (um eine mögliche 0 in der Liste zu berücksichtigen). Der Index dieses Arrays ist ein möglicher Wert in der unsortierten Liste.
• Lesen Sie das Zählarray von links nach rechts und geben Sie den Index ein, dessen Wert nicht 0 beträgt, und die Anzahl der Male für den Zellwert des Index.

Operationen

Der Algorithmus hat zwei Schritte. Für die vorherige Liste hat der erste Schritt 10 Hauptvorgänge, da die Anzahl der Elemente in der ungeortierten Liste 10 beträgt. Der zweite Schritt hat 21 Hauptvorgänge, da der Höchstwert in der ungeortierten Liste 20 beträgt (die zusätzliche 1 für einen möglichen 0 -Wert). Die Anzahl der Hauptoperationen wird also wie folgt betrachtet:

O (10 + 20)

Wobei 10 die Anzahl der Elemente in der ungeortierten Liste und 20 der Höchstwert in der ungeortierten Liste ist. Die hinzugefügten 1 bis 20 wird an dieser Stelle ignoriert, aber denken Sie daran, dass es codiert werden muss.

Zeitkomplexität zum Zählen der Sortierung

Zeitkomplexität ist die ungefähre Anzahl der Hauptvorgänge für einen Code. Die Zeitkomplexität zeigt die Geschwindigkeit des Codes an. Die zeitliche Komplexität für das Zählen wird wie folgt angegeben:

O (n + m)

Wobei n die Anzahl der Elemente (Länge oder Größe) des angegebenen unsortierten Arrays ist, und M ist der Maximalwert in dem angegebenen unsortierten Array. Der hinzugefügte 1 zu m wird an diesem Punkt ignoriert. Die Big-O mit seinen Klammern und Inhalten wird als Big-O-Notation bezeichnet.

Beachten Sie, dass, um den Höchstwert im Array zu erhalten, einige Vorgänge im Code erfolgen müssen. Diese Operationen werden jedoch ignoriert, wenn die zeitliche Komplexität zitiert.

Das Count -Array muss alle seine Elemente ursprünglich als Null gemacht haben. Alle diese Operationen werden auch ignoriert, wenn die zeitliche Komplexität für die Zählsart zitiert.

Speicherraum

Beachten Sie, dass im vorherigen Zählarray alle Zahlen von 0 überflüssig sind. Obwohl ihre Räume im Gedächtnis überflüssig sind, müssen sie dort sein. Die Zählsart nimmt im Allgemeinen unnötigen Speicherplatz ein. Normalerweise wird nichts getan, um die überflüssigen Orte zu vermeiden. Wenn der Mindestwert in dem angegebenen unsortierten Array bekannt sein kann, kann der Anfangsteil des Zählarrays weggelassen werden, um den Platz zu reduzieren. Die zwischengestrahlten Nullen im Zählarray können jedoch nicht weggelassen werden.

Hinweis: Es gibt auch Raumkomplexität, aber das wird in diesem Artikel nicht behandelt.

Codierung in c

Eine zählende Sortierfunktion in der C -Computersprache C ist wie folgt:

void countingsort (int arr [], int n)
int max = 0;
für (int i = 0; i max)
max = arr [i];


int count [max+1];
für (int i = 0; i< max+1; i++)
zählen [i] = 0;

//N
für (int i = 0; i< n; i++)
zählen [arr [i]] = count [arr [i]] + 1; // 1 für jedes Ereignis 1 hinzufügen

//M
int k = 0; // Index für ein bestimmtes Array
für (int i = 0; iif (count [i] != 0)
für (int j = 0; jarr [k] = i; // Zurück in das bestimmte Array zurücklegen, sortierter Wert zurückzugeben
K ++;

Die verschachtelten für die Schleife und die Eingabe sind die folgenden:

16, 20, 12, 10, 18, 8, 12, 18, 12, 14

Es gibt tatsächlich 24 große Operationen und nicht 20. Die zusätzliche 3 + 1 = 4 -Operation wird ignoriert, wenn die zeitliche Komplexität für die Zählsart zitiert.

Eine geeignete C -Hauptfunktion ist wie folgt:

int main (int argc, char ** argv)

int n = 10;
int arr [] = 16, 20, 12, 10, 18, 8, 12, 18, 12, 14;
countingsort (arr, n);
für (int i = 0; iprintf ("%d", arr [i]);
printf ("\ n");
Rückkehr 0;

Die Ausgabe ist:

8 10 12 12 12 14 16 18 18 20

Abschluss

Die zeitliche Komplexität für die Zählsart ist:

O (n + m)

Wobei m normalerweise größer als n ist, n ist die Anzahl der Elemente (Länge) der angegebenen unsortierten Liste, und M ist das maximale Element in der angegebenen unsortierten Liste.