Úvod do algoritmu třídění bublin

Řazení je jednou z nejzákladnějších operací, kterou můžete u dat použít. Prvky můžete třídit v různých programovacích jazycích pomocí různých třídicích algoritmů, jako je Rychlé řazení, Řazení podle bublin, Sloučení podle sloučení, Řazení podle vložení atd. Bubble Sort je nejjednodušší algoritmus ze všech těchto.

V tomto článku se dozvíte o fungování algoritmu Bubble Sort, pseudokódu Bubble Sort algoritmus, jeho časová a prostorová složitost a jeho implementace v různých programovacích jazycích, jako jsou C ++, Python, C a JavaScript.

Jak funguje algoritmus třídění bublin?

Bubble Sort je nejjednodušší algoritmus řazení, který opakovaně prochází seznamem, porovnává sousední prvky a zaměňuje je, pokud jsou ve špatném pořadí. Tento koncept lze efektivněji vysvětlit pomocí příkladu. Zvažte netříděné pole s následujícími prvky: {16, 12, 15, 13, 19}.

Příklad:

Zde jsou sousední prvky porovnány a pokud nejsou ve vzestupném pořadí, jsou vyměněny.

Pseudokód algoritmu třídění bublin

V pseudokódu, algoritmus Bubble Sort lze vyjádřit jako:

bubbleSort (Arr [], velikost)
// smyčka pro přístup ke každému prvku pole
pro i = 0 do velikosti 1 proveďte:
// smyčka pro porovnání prvků pole
pro j = 0 do size-i-1 proveďte:
// porovnat sousední prvky
pokud Arr [j]> Arr [j + 1] pak
// vyměňte je
swap (Arr [j], Arr [j + 1])
skončit, pokud
konec pro
konec pro
konec

Výše uvedený algoritmus zpracovává všechna srovnání, i když je pole již tříděno. Lze jej dále optimalizovat zastavením algoritmu, pokud vnitřní smyčka nezpůsobila žádný swap. Tím se sníží doba provádění algoritmu.

Takže pseudokód optimalizovaného algoritmu Bubble Sort lze vyjádřit jako:

bubbleSort (Arr [], velikost)
// smyčka pro přístup ke každému prvku pole
pro i = 0 do velikosti 1 proveďte:
// zkontrolovat, zda nedojde k výměně
swapped = false
// smyčka pro porovnání prvků pole
pro j = 0 do size-i-1 proveďte:
// porovnat sousední prvky
pokud Arr [j]> Arr [j + 1] pak
// vyměňte je
swap (Arr [j], Arr [j + 1])
swapped = true
skončit, pokud
konec pro
// pokud nebyly zaměněny žádné prvky, což znamená, že pole je nyní tříděno, přerušte smyčku.
pokud (nevyměněno) pak
přestávka
skončit, pokud
konec pro
konec

Časová složitost a pomocný prostor algoritmu třídění bublin

Nejhorší časová složitost Bubble Sort Algorithm je O (n ^ 2). Dochází k němu, když je pole v sestupném pořadí a chcete jej seřadit vzestupně nebo naopak.

Nejlepší časová složitost Bubble Sort Algorithmu je O (n). Nastane, když je pole již seřazené.

Příbuzný: Co je Big-O notace?

Průměrná časová složitost algoritmu třídění bublin je O (n ^ 2). Nastává, když jsou prvky pole v neuspořádaném pořadí.

Pomocný prostor požadovaný pro algoritmus Bubble Sort je O (1).

C ++ implementace algoritmu třídění bublin

Níže je implementace algoritmu Bubble Sort v C ++:

// C ++ implementace
// optimalizovaný algoritmus Bubble Sort
#zahrnout 
pomocí jmenného prostoru std;
// Funkce pro provedení Bubble Sort
void bubbleSort (int arr [], int size) {
// Smyčka pro přístup ke každému prvku pole
pro (int i = 0; i // Proměnná pro kontrolu, zda nedojde k prohození
bool swapped = false;
// smyčka pro porovnání dvou sousedních prvků pole
pro (int j = 0; j // Porovnání dvou sousedních prvků pole
if (arr [j]> arr [j + 1]) {
// Zaměňte oba prvky, pokud jsou
// není ve správném pořadí
int temp = arr [j];
arr [j] = arr [j + 1];
arr [j + 1] = teplota;
swapped = true;
}
}
// Pokud nebyly zaměněny žádné prvky, což znamená, že pole je nyní tříděno,
// poté přerušte smyčku.
if (prohozeno == false) {
přestávka;
}
}
}
// Vytiskne prvky pole
void printArray (int arr [], int size) {
pro (int i = 0; i cout << arr [i] << "";
}
cout << endl;
}
int main () {
int arr [] = {16, 12, 15, 13, 19};
// Zjištění délky pole
int size = sizeof (arr) / sizeof (arr [0]);
// Tisk daného netříděného pole
cout << "Netříděné pole:" << endl;
printArray (arr, velikost);
// Volání funkce bubbleSort ()
bubbleSort (arr, velikost);
// Tisk seřazeného pole
cout << "Řaděné pole ve vzestupném pořadí:" << endl;
printArray (arr, velikost);
návrat 0;
}

Výstup:

Netříděné pole: 
16 12 15 13 19 
Seřazené pole ve vzestupném pořadí:
12 13 15 16 19

Pythonská implementace algoritmu třídění bublin

Níže je implementace algoritmu Bubble Sort v Pythonu:

# Pythonová implementace
# optimalizovaný algoritmus Bubble Sort
# Funkce k provedení Bubble Sort
def bubbleSort (arr, velikost):
# Smyčka pro přístup ke každému prvku seznamu
pro i v rozsahu (velikost-1):
# Proměnná pro kontrolu, zda nedojde k výměně
swapped = False
smyčka # pro porovnání dvou sousedních prvků seznamu
pro j v rozsahu (velikost-i-1):
# Porovnání dvou sousedících prvků seznamu
pokud arr [j]> arr [j + 1]:
temp = arr [j]
arr [j] = arr [j + 1]
arr [j + 1] = tepl
swapped = True
# Pokud nebyly zaměněny žádné prvky, znamená to, že seznam je nyní seřazen,
# pak prolomit smyčku.
pokud je zaměněn == False:
přestávka
# Vytiskne prvky seznamu
def printArray (arr):
pro vložený prvek:
print (element, end = "")
tisk("")
arr = [16, 12, 15, 13, 19]
# Zjištění délky seznamu
size = len (arr)
# Tisk daného netříděného seznamu
tisk ("Netříděný seznam:")
printArray (arr)
# Volání funkce bubbleSort ()
bubbleSort (arr, velikost)
# Tisk seřazeného seznamu
tisk ("Seřazený seznam ve vzestupném pořadí:")
printArray (arr)

Výstup:

Nezařazený seznam:
16 12 15 13 19 
Seřazený seznam vzestupně:
12 13 15 16 19

Příbuzný: Jak používat smyčky v Pythonu

C Implementace algoritmu třídění bublin

Níže je implementace C algoritmu Bubble Sort:

// C implementace
// optimalizovaný algoritmus Bubble Sort
#zahrnout 
#zahrnout 
// Funkce pro provedení Bubble Sort
void bubbleSort (int arr [], int size) {
// Smyčka pro přístup ke každému prvku pole
pro (int i = 0; i // Proměnná pro kontrolu, zda nedojde k prohození
bool swapped = false;
// smyčka pro porovnání dvou sousedních prvků pole
pro (int j = 0; j // Porovnání dvou sousedních prvků pole
if (arr [j]> arr [j + 1]) {
// Zaměňte oba prvky, pokud jsou
// není ve správném pořadí
int temp = arr [j];
arr [j] = arr [j + 1];
arr [j + 1] = teplota;
swapped = true;
}
}
// Pokud nebyly zaměněny žádné prvky, což znamená, že pole je nyní tříděno,
// poté přerušte smyčku.
if (prohozeno == false) {
přestávka;
}
}
}
// Vytiskne prvky pole
void printArray (int arr [], int size) {
pro (int i = 0; i printf ("% d", arr [i]);
}
printf ("\ ⁠n");
}
int main () {
int arr [] = {16, 12, 15, 13, 19};
// Zjištění délky pole
int size = sizeof (arr) / sizeof (arr [0]);
// Tisk daného netříděného pole
printf ("Netříděné pole: \ ⁠n");
printArray (arr, velikost);
// Volání funkce bubbleSort ()
bubbleSort (arr, velikost);
// Tisk seřazeného pole
printf ("Řaděné pole ve vzestupném pořadí: \ ⁠n");
printArray (arr, velikost);
návrat 0;
}

Výstup:

Netříděné pole: 
16 12 15 13 19 
Seřazené pole ve vzestupném pořadí: 
12 13 15 16 19

Implementace JavaScriptu algoritmu třídění bublin

Níže je implementace JavaScriptu algoritmu Bubble Sort:

// Implementace JavaScriptu
// optimalizovaný algoritmus Bubble Sort
// Funkce pro provedení Bubble Sort
function bubbleSort (arr, size) {
// Smyčka pro přístup ke každému prvku pole
pro (ať i = 0; i// Proměnná pro kontrolu, zda nedojde k prohození
var swapped = false;
// smyčka pro porovnání dvou sousedních prvků pole
pro (nechť j = 0; j// Porovnání dvou sousedních prvků pole
if (arr [j]> arr [j + 1]) {
// Zaměňte oba prvky, pokud jsou
// není ve správném pořadí
let temp = arr [j];
arr [j] = arr [j + 1];
arr [j + 1] = teplota;
swapped = true;
}
// Pokud nebyly zaměněny žádné prvky, což znamená, že pole je nyní tříděno,
// poté přerušte smyčku.
if (prohozeno == false) {
přestávka;
}
}
}
}
// Vytiskne prvky pole
funkce printArray (arr, velikost) {
pro (ať i = 0; idocument.write (arr [i] + "");
}
document.write ("
")
}
var arr = [16, 12, 15, 13, 19];
// Zjištění délky pole
var velikost = dorazová délka;
// Tisk daného netříděného pole
document.write ("Nezařazené pole: 
");
printArray (arr, velikost);
// Volání funkce bubbleSort ()
bubbleSort (arr, velikost);
// Tisk seřazeného pole
document.write ("Seřazené pole ve vzestupném pořadí: 
");
printArray (arr, velikost);

Výstup:

Netříděné pole:
16 12 15 13 19
Seřazené pole ve vzestupném pořadí:
12 15 13 16 19

Nyní rozumíte fungování algoritmu třídění bublin

Bubble Sort je nejjednodušší algoritmus třídění a používá se hlavně k pochopení základů třídění. Bubble Sort lze také implementovat rekurzivně, ale neposkytuje k tomu žádné další výhody.

Pomocí Pythonu můžete snadno implementovat algoritmus Bubble Sort. Pokud nejste obeznámeni s Pythonem a chcete nastartovat svoji cestu, je skvělá volba začít skriptem „Hello World“.

Jak začít s Pythonem pomocí skriptu „Hello World“

Python je dnes jedním z nejpopulárnějších programovacích jazyků. Postupujte podle tohoto tutoriálu a začněte s úplně prvním skriptem Pythonu.

Přečtěte si další

O autorovi