Zeitkomplexität der Blase Sortierkomplexität
In diesem Artikel wird die Sorte aufsteigend berücksichtigt. Dieser Artikel zielt darauf ab, die relative Geschwindigkeit des Blasensortalgorithmus anzuzeigen. Diese relative Geschwindigkeit wird als Zeitkomplexität bezeichnet. Die Codierung erfolgt in der C -Computersprache C.
Artikelinhalt
- Einführung - siehe oben
- Bubble -Sortier -Illustration
- Schlimmste Leistung
- Bessere Leistung für die Blasenart
- Einige durchsetzter Sequenz von bereits sortierten Elementen
- Perfekter Fall
- Abschluss
Bubble -Sortier -Illustration
Betrachten Sie die folgende ungewöhnliche Liste:
R x f s u z v jEs gibt 8 Elemente, die 8 vollständige Scans benötigen, was dazu führt:
R f s u x v j zF r s u v j x z
F r s u j v x z
F r s j u v x z
F r j s u v x z
F J r s u v x z
F J r s u v x z
F J r s u v x z
Die endgültige Listenanordnung ist die vollständige Sortierung.
Schlimmste Leistung
Der zuvor erklärte C -Code zum Sortieren der vorherigen acht Zeichen lautet:
#enthaltenvoid bubblesort (char arr [], int n)
int counter = 0;
für (int i = 0; i < n; i++)
für (int j = 1; j < n; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
Zähler+= 1;
printf ("%i \ n", Zähler);
Der Code für den Austausch befindet sich im inneren Verschachtel. Der Zähler zählt die Anzahl der Grundvorgänge. Die äußere For-Loop-Schleifen von 0 bis 7, ich.e., 8 Mal. Die inneren For-Loop-Schleifen von 1 bis 7, ich.e., 7 mal. Die Gesamtzahl der grundlegenden Operationen (innere für die Schleife) beträgt 8 x 7 = 56. Der Zählerausgang ist 56.
Wenn die innere For-Schleife von 0 bis 7 geschoben worden wäre, wäre die Gesamtzahl der Grundvorgänge 8 x 8 = 64 gewesen. Dies ist die maximale Anzahl grundlegender Operationen für diese Verschachtelung für Schleife. Sei 8 n sein n. Dann ist die maximale Anzahl solcher Verschachtelungssteigers n n2.
Die schlimmste Zeitkomplexität für die vorherige Funktion ist als,
An2)
Das große O gefolgt von seinen Klammern mit n2 wird als Big-O-Notation bezeichnet. Es zeigt die relative Geschwindigkeit des Codes an. Obwohl im vorherigen Code die Anzahl der grundlegenden Operationen 56 beträgt, die maximal mögliche Anzahl von Operationen, 82 = 64, was für die Zeitkomplexität gegeben werden würde.
Eine geeignete C -Hauptfunktion für den vorherigen Code ist:
int main (int argc, char ** argv)int n = 8;
char arr [] = 'r', 'x', 'f', 's', 'u', 'z', 'v', 'j';
Bubblesort (arr, n);
für (int i = 0; i
printf ("\ n");
Rückkehr 0;
Bessere Leistung für die Blasenart
Beachten Sie in der vorherigen Abbildung für die Blase -Sortierung; Nach dem ersten Scan befindet sich das höchste Element am rechten Ende. Nach dem zweiten Scan befinden sich die höchsten zwei Elemente am rechten Ende, um in Ordnung zu kommen. Nach dem dritten Scan sind die höchsten drei Elemente am rechten Ende, in der Reihenfolge und so weiter. Operationen zu diesen extremen rechtsextremen Elementen, die beim Wachstum sind. Dies würde die Gesamtgeschwindigkeit erhöhen (Zeit für die vollständige Sortierung). Der folgende geänderte Code zeigt dies:
void bubblesort (char arr [], int n)int counter = 0;
für (int i = 0; i < n; i++)
für (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
Zähler+= 1;
printf ("%i \ n", Zähler);
Diesmal beträgt der Zählerausgang 28. Die Anzahl der Grundvorgänge beträgt 28, etwas weniger als die Hälfte von 64, was 32 ist. Die inneren For -Loop -Schleifen von 1 bis n - i. In seinem ersten Scan ist ich Null und n - i = 8.
Jetzt,
Protokoll2 8 = log2 23
= 3
8 x 3 = 8xlog2 23
= 24
das ist fast 28. Sei n = 8. Der letzte, aber eins rechte Operandenausdruck oben wird n.Protokoll2 23, = n.Protokoll2 8, allgemein geschrieben als, n log n n.
Wenn die Zeitkomplexität in einem mittleren Bereich von 20 bis 40 liegt, wird in diesem Fall sie ausgedrückt als:
O (n log n)
Wobei n die Anzahl der Elemente in der Liste ist. Die zeitliche Komplexität für die verbesserte Leistung der Blasensortierung lautet also N log n, was bedeutet n x log2(N).
Einige durchsetzter Sequenz von bereits sortierten Elementen
Es gibt acht Scans für die vorherige Illustration der Blasenart. Beachten Sie, dass die Liste durch den sechsten Scan bereits vollständig sortiert war. Die letzten beiden Zeilen sind Wiederholungen der sechsten Reihe. Für diese spezielle unsortierte Liste waren die beiden vorherigen Scans nicht erforderlich. Dies geschieht, wenn in der angegebenen unsortierten Liste einige bereits sortierte zwischengestellte Sequenzen sortiert sind. Wenn die angegebene Liste völlig ungeortiert ist, wäre die letzte Zeile die endgültige sortierte Liste (es wäre keine Wiederholung des vorherigen).
Die letzten Zeilen wie die letzten beiden oben können in der Sortierung weggelassen werden und die Leistung (Geschwindigkeit) verbessern (Geschwindigkeit). Der folgende Code zeigt dies:
void bubblesort (char arr [], int n)_BOOL SWIPT = 0;
für (int i = 0; i < n; i++)
ausgetauscht = 0;
für (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
ausgetauscht = 1;
if (ausgetauscht == 0)
brechen;
Perfekter Fall
Eine perfekte Leistung tritt auf, wenn die angegebene Liste bereits vollständig sortiert ist. Der Code zum Testen ist:
void bubblesort (char arr [], int n)int counter = 0;
_BOOL SWIPT = 0;
für (int i = 0; i < n; i++)
ausgetauscht = 0;
für (int j = 1; j < n-i; j++)
if (arr [j] < arr[j - 1])
char temp = arr [j];
arr [j] = arr [j - 1];
arr [j - 1] = temp;
ausgetauscht = 1;
Zähler+= 1;
if (ausgetauscht == 0)
brechen;
printf ("%i \ n", Zähler);
Die Ausgabe ist:
7F J r s u v x z
für eine Eingabeliste von,
F J r s u v x zDie 7 stammt aus dem inneren For-Loop. Für die Zeitkomplexität wird jedoch maximal 8 berücksichtigt. Die zeitliche Komplexität für perfekte Leistung wird ausgedrückt als:
An)
Abschluss
In diesem Artikel haben wir die Komplexität der Bubble -Sortierzeit diskutiert und Folgendes betont:
Die schlimmste Zeitkomplexität für die Blasensorte ist:
An2)
Mit der Verbesserung des Codes wird die zeitliche Komplexität:
O (n log n)
Wenn die angegebene Liste bereits vollständig sortiert ist, lautet die Zeitkomplexität:
An)