En introduksjon til boblesorteringsalgoritmen

Sortering er en av de mest grunnleggende operasjonene du kan bruke på data. Du kan sortere elementer på forskjellige programmeringsspråk ved å bruke forskjellige sorteringsalgoritmer som Quick Sort, Bubble Sort, Merge Sort, Insertion Sort, etc. Bubble Sort er den enkleste algoritmen blant alle disse.

I denne artikkelen lærer du om hvordan Bubble Sort -algoritmen fungerer, pseudokoden til Bubble Sort -algoritmen, dens tid og romkompleksitet og implementering på forskjellige programmeringsspråk som C ++, Python, C og JavaScript.

---

---

Hvordan fungerer boblesorteringsalgoritmen?

Boblesortering er den enkleste sorteringsalgoritmen som gjentatte ganger går gjennom listen, sammenligner tilgrensende elementer og bytter dem hvis de er i feil rekkefølge. Dette konseptet kan forklares mer effektivt ved hjelp av et eksempel. Vurder en usortert matrise med følgende elementer: {16, 12, 15, 13, 19}.

Eksempel:

Her sammenlignes de tilstøtende elementene, og hvis de ikke er i stigende rekkefølge, byttes de ut.

Pseudokode for boblesorteringsalgoritmen

I pseudokode kan Bubble Sort -algoritmen uttrykkes som:

bubbleSort(Arr[], size)
// loop to access each array element
for i=0 to size-1 do:
// loop to compare array elements
for j=0 to size-i-1 do:
// compare the adjacent elements
if Arr[j] > Arr[j+1] then
// swap them
swap(Arr[j], Arr[j+1])
end if
end for
end for
end


Algoritmen ovenfor behandler alle sammenligningene, selv om matrisen allerede er sortert. Den kan optimaliseres ytterligere ved å stoppe algoritmen hvis den indre sløyfen ikke forårsaket noen bytte. Dette vil redusere kjøringstiden til algoritmen.

---

---

Dermed kan pseudokoden til den optimaliserte boblesorteringsalgoritmen uttrykkes som:

bubbleSort(Arr[], size)
// loop to access each array element
for i=0 to size-1 do:
// check if swapping occurs
swapped = false
// loop to compare array elements
for j=0 to size-i-1 do:
// compare the adjacent elements
if Arr[j] > Arr[j+1] then
// swap them
swap(Arr[j], Arr[j+1])
swapped = true
end if
end for
// if no elements were swapped that means the array is sorted now, then break the loop.
if(not swapped) then
break
end if
end for
end


Tidskompleksitet og tilleggsrom for boblesorteringsalgoritmen

Den verste tilfelle av kompleksitet av boblesorteringsalgoritmen er O (n^2). Det oppstår når matrisen er i synkende rekkefølge og du vil sortere den i stigende rekkefølge eller omvendt.

---

---

kule ting å gjøre på diskord

Tidskompleksiteten i beste tilfelle av boblesorteringsalgoritmen er O (n). Det oppstår når matrisen allerede er sortert.

flytte filer fra mac til pc

I slekt: Hva er Big-O Notation?

Gjennomsnittlig sakstidskompleksitet for boblesorteringsalgoritmen er O (n^2). Det oppstår når elementene i matrisen er i blandet rekkefølge.

Hjelpeplassen som kreves for Bubble Sort -algoritmen er O (1).

C ++ Implementering av boblesorteringsalgoritmen

Nedenfor er C ++ - implementeringen av Bubble Sort -algoritmen:

// C++ implementation of the
// optimised Bubble Sort algorithm
#include
using namespace std;
// Function to perform Bubble Sort
void bubbleSort(int arr[], int size) {
// Loop to access each element of the array
for (int i=0; i<(size-1); i++) {
// Variable to check if swapping occurs
bool swapped = false;
// loop to compare two adjacent elements of the array
for (int j = 0; j <(size-i-1); j++) {
// Comparing two adjacent array elements
if (arr[j] > arr[j + 1]) {
// Swap both elements if they're
// not in correct order
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
// If no elements were swapped that means the array is sorted now,
// then break the loop.
if (swapped == false) {
break;
}
}
}
// Prints the elements of the array
void printArray(int arr[], int size) {
for (int i = 0; i cout << arr[i] << ' ';
}
cout << endl;
}
int main() {
int arr[] = {16, 12, 15, 13, 19};
// Finding the length of the array
int size = sizeof(arr) / sizeof(arr[0]);
// Printing the given unsorted array
cout << 'Unsorted Array: ' << endl;
printArray(arr, size);
// Calling bubbleSort() function
bubbleSort(arr, size);
// Printing the sorted array
cout << 'Sorted Array in Ascending Order:' << endl;
printArray(arr, size);
return 0;
}


Produksjon:

Unsorted Array:
16 12 15 13 19
Sorted Array in Ascending Order:
12 13 15 16 19

Python -implementering av boblesorteringsalgoritmen

Nedenfor er Python -implementeringen av Bubble Sort -algoritmen:

# Python implementation of the
# optimised Bubble Sort algorithm

# Function to perform Bubble Sort
def bubbleSort(arr, size):
# Loop to access each element of the list
for i in range (size-1):
# Variable to check if swapping occurs
swapped = False
# loop to compare two adjacent elements of the list
for j in range(size-i-1):
# Comparing two adjacent list elements
if arr[j] > arr[j+1]:
temp = arr[j]
arr[j] = arr[j+1]
arr[j+1] = temp
swapped = True
# If no elements were swapped that means the list is sorted now,
# then break the loop.
if swapped == False:
break
# Prints the elements of the list
def printArray(arr):
for element in arr:
print(element, end=' ')
print('')

arr = [16, 12, 15, 13, 19]
# Finding the length of the list
size = len(arr)
# Printing the given unsorted list
print('Unsorted List:')
printArray(arr)
# Calling bubbleSort() function
bubbleSort(arr, size)
# Printing the sorted list
print('Sorted List in Ascending Order:')
printArray(arr)


Produksjon:

Unsorted List:
16 12 15 13 19
Sorted List in Ascending Order:
12 13 15 16 19

I slekt: Hvordan bruke for sløyfer i Python

C Implementering av boblesorteringsalgoritmen

Nedenfor er C -implementeringen av Bubble Sort -algoritmen:

// C implementation of the
// optimised Bubble Sort algorithm
#include
#include
// Function to perform Bubble Sort
void bubbleSort(int arr[], int size) {
// Loop to access each element of the array
for (int i=0; i<(size-1); i++) {
// Variable to check if swapping occurs
bool swapped = false;
// loop to compare two adjacent elements of the array
for (int j = 0; j <(size-i-1); j++) {
// Comparing two adjacent array elements
if (arr[j] > arr[j + 1]) {
// Swap both elements if they're
// not in correct order
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
swapped = true;
}
}
// If no elements were swapped that means the array is sorted now,
// then break the loop.
if (swapped == false) {
break;
}
}
}
// Prints the elements of the array
void printArray(int arr[], int size) {
for (int i = 0; i printf('%d ', arr[i]);
}
printf(' ⁠n ');
}
int main() {
int arr[] = {16, 12, 15, 13, 19};
// Finding the length of the array
int size = sizeof(arr) / sizeof(arr[0]);
// Printing the given unsorted array
printf('Unsorted Array: ⁠n');
printArray(arr, size);
// Calling bubbleSort() function
bubbleSort(arr, size);
// Printing the sorted array
printf('Sorted Array in Ascending Order: ⁠n');
printArray(arr, size);
return 0;
}

Produksjon:

Unsorted Array:
16 12 15 13 19
Sorted Array in Ascending Order:
12 13 15 16 19

JavaScript -implementering av boblesorteringsalgoritmen

Nedenfor er JavaScript -implementeringen av Bubble Sort -algoritmen:

// JavaScript implementation of the
// optimised Bubble Sort algorithm
// Function to perform Bubble Sort
function bubbleSort(arr, size) {
// Loop to access each element of the array
for(let i=0; i // Variable to check if swapping occurs
var swapped = false;
// loop to compare two adjacent elements of the array
for(let j=0; j // Comparing two adjacent array elements
if(arr[j] > arr[j+1]) {
// Swap both elements if they're
// not in correct order
let temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
swapped = true;
}
// If no elements were swapped that means the array is sorted now,
// then break the loop.
if (swapped == false) {
break;
}
}
}
}
// Prints the elements of the array
function printArray(arr, size) {
for (let i=0; i document.write(arr[i] + ' ');
}
document.write('
')
}

var arr = [16, 12, 15, 13, 19];
// Finding the length of the array
var size = arr.length;
// Printing the given unsorted array
document.write('Unsorted Array:
');
printArray(arr, size);
// Calling bubbleSort() function
bubbleSort(arr, size);
// Printing the sorted array
document.write('Sorted Array in Ascending Order:
');
printArray(arr, size);


Produksjon:

Unsorted Array:
16 12 15 13 19
Sorted Array in Ascending Order:
12 15 13 16 19

Nå forstår du hvordan boblesorteringsalgoritmen fungerer

Bubble Sort er den enkleste sorteringsalgoritmen og brukes hovedsakelig til å forstå grunnlaget for sortering. Bubble Sort kan også implementeres rekursivt, men det gir ingen ekstra fordeler å gjøre det.

Ved å bruke Python kan du enkelt implementere Bubble Sort -algoritmen. Hvis du ikke er kjent med Python og ønsker å starte reisen din, er det et godt valg å starte med et 'Hello World' -manus.

Dele Dele kvitring E -post Hvordan komme i gang med Python ved hjelp av et 'Hello World' -skript

Python er et av de mest populære programmeringsspråkene som brukes i dag. Følg denne opplæringen for å komme i gang med ditt aller første Python -skript.

Les neste Relaterte temaer

• Programmering
• Java
• Python
• Opplæringsprogrammer for koding

Om forfatteren Yuvraj Chandra(60 artikler publisert)

Yuvraj er en informatikkstudent ved University of Delhi, India. Han brenner for Full Stack webutvikling. Når han ikke skriver, utforsker han dybden i forskjellige teknologier.

beste budsjett -cpu for spill 2019

Mer fra Yuvraj Chandra

Abonner på vårt nyhetsbrev

Bli med i vårt nyhetsbrev for tekniske tips, anmeldelser, gratis ebøker og eksklusive tilbud!

Klikk her for å abonnere