Boble sorter tidskompleksitet
I denne artikkelen vurderes sort stigende. Denne artikkelen tar sikte på å indikere den relative hastigheten til boble -sorteringsalgoritmen. Denne relative hastigheten blir referert til som tidskompleksitet. Koding gjøres på C -dataspråket.
Artikkelinnhold
- INNLEDNING - Se ovenfor
- Boble -illustrasjon
- Worst-case ytelse
- Bedre ytelse for boble -sortering
- Noen ispedd sekvens av elementer som allerede er sortert
- Perfekt sak
- Konklusjon
Boble -illustrasjon
Tenk på følgende usorterte liste:
R x f s u z v jDet er 8 elementer, som trenger 8 komplette skanninger, noe som resulterer i:
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
Den endelige listearrangementet er den komplette sorteringen.
Worst-case ytelse
C -koden for å sortere de åtte foregående tegnene, tidligere forklart er:
#inkluderevoid bubblesort (char arr [], int n)
int teller = 0;
for (int i = 0; i < n; i++)
for (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;
teller+= 1;
printf ("%i \ n", teller);
Koden for bytte er i det indre nestet for-loop. Telleren teller antall grunnleggende operasjoner. De ytre for-loop løkker fra 0 til 7, i.e., 8 ganger. Den indre for-loop løkker fra 1 til 7, i.e., 7 ganger. Det totale antallet grunnleggende operasjoner (indre for-loop) er 8 x 7 = 56. Tellerutgangen er 56.
Hvis den indre for-loopen er loopet fra 0 til 7, ville det totale antallet grunnleggende operasjoner ha vært 8 x 8 = 64. Dette er det maksimale antallet grunnleggende operasjoner for denne hekkende for-loops. La 8 være n. Deretter er det maksimale antallet slike hekkende for-loops n2.
Den verste tidskompleksiteten for den forrige funksjonen er gitt som,
På2)
Den store o etterfulgt av parentesene med n2 kalles Big-O-notasjonen. Det indikerer den relative hastigheten på koden. Selv om i forrige kode er antall grunnleggende operasjoner 56, maksimalt mulig antall operasjoner, 82 = 64, er det som vil bli gitt for tidskompleksiteten.
En passende C hovedfunksjon for forrige kode er:
int main (int argc, char ** argv)int n = 8;
char arr [] = 'r', 'x', 'f', 's', 'u', 'z', 'v', 'j';
Bubblesort (arr, n);
for (int i = 0; i
printf ("\ n");
retur 0;
Bedre ytelse for boble -sortering
Legg merke til i forrige illustrasjon for boblen; Etter den første skanningen er det høyeste elementet i høyre ende. Etter den andre skanningen er de to høyeste elementene i høyre ende, i orden. Etter den tredje skanningen er de høyeste tre elementene i høyre ende, i orden og så videre. Operasjoner på disse ekstreme høyre elementene når de vokser kan utelates i koding. Dette vil øke den totale hastigheten (tid for fullstendig sortering). Følgende modifisert kode illustrerer dette:
void bubblesort (char arr [], int n)int teller = 0;
for (int i = 0; i < n; i++)
for (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;
teller+= 1;
printf ("%i \ n", teller);
Denne gangen er motutgangen 28. Antall grunnleggende operasjoner er 28, litt mindre enn halvparten av 64, som er 32. Den indre for -loop løkker fra 1 til n - i. I sin første skanning er jeg null, og n - i = 8.
Nå,
Logg2 8 = Logg2 23
= 3
8 x 3 = 8xlog2 23
= 24
som er nær 28. La n = 8. Det siste men-en høyre operanduttrykket ovenfor, blir n.Logg2 23, = n.Logg2 8, generelt skrevet som, n log n.
Når tidskompleksiteten er innenfor et mellomområde, 20 til 40, i dette tilfellet, uttrykkes det som:
O (n log n)
Hvor n er antall elementer i listen. Så tidskompleksiteten for den forbedrede ytelsen til boble -sortering er n log n, noe som betyr n x log2(n).
Noen ispedd sekvens av elementer som allerede er sortert
Det er åtte skanninger for den forrige boble -sorteringsillustrasjonen. Legg merke til at listen ved sjette skanning var helt allerede sortert. De to siste radene er repetisjoner av sjette rad. For denne spesielle usorterte listen var de to foregående skanninger ikke nødvendige. Dette skjer når den gitte usorterte listen har noen allerede sorterte ispedd sekvenser. Hvis den gitte listen er helt usortert, ville den siste raden være den endelige sorterte listen (den ville ikke være en repetisjon av forrige).
De siste radene som de to siste ovenfor kan utelates i sortering, og slik forbedre ytelsen (hastighet). Følgende kode illustrerer dette:
void bubblesort (char arr [], int n)_Bool byttet = 0;
for (int i = 0; i < n; i++)
byttet = 0;
for (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;
byttet = 1;
if (byttet == 0)
gå i stykker;
Perfekt sak
Perfekt ytelse oppstår når den gitte listen allerede er sortert helt. Koden for å teste dette er:
void bubblesort (char arr [], int n)int teller = 0;
_Bool byttet = 0;
for (int i = 0; i < n; i++)
byttet = 0;
for (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;
byttet = 1;
teller+= 1;
if (byttet == 0)
gå i stykker;
printf ("%i \ n", teller);
Utgangen er:
7F j r s u v x z
for en inngangsliste over,
F j r s u v x z7 er fra den indre for-loop. For tidskompleksitet vurderes imidlertid maksimalt 8. Tidskompleksiteten for perfekt ytelse uttrykkes som:
På)
Konklusjon
I denne artikkelen diskuterte vi Bubble Sort Time -kompleksiteten og la vekt på følgende:
Den verste tidskompleksiteten for boble-sortering er:
På2)
Med forbedring av kode blir tidskompleksiteten:
O (n log n)
Når den gitte listen allerede er sortert, er tidskompleksiteten:
På)