En introduktion til boblesorteringsalgoritmen

En introduktion til boblesorteringsalgoritmen

Sortering er en af ​​de mest grundlæggende operationer, du kan anvende på data. Du kan sortere elementer på forskellige programmeringssprog ved hjælp af forskellige sorteringsalgoritmer som Quick Sort, Bubble Sort, Merge Sort, Insertion Sort osv. Bubble Sort er den mest enkle algoritme blandt alle disse.





I denne artikel lærer du om funktionen af ​​Bubble Sort -algoritmen, pseudokoden for Bubble Sort -algoritmen, dens tid og rumkompleksitet og dens implementering på forskellige programmeringssprog som C ++, Python, C og JavaScript.



Hvordan fungerer boblesorteringsalgoritmen?

Boblesortering er den enkleste sorteringsalgoritme, der gentagne gange går gennem listen, sammenligner tilstødende elementer og bytter dem, hvis de er i den forkerte rækkefølge. Dette koncept kan forklares mere effektivt ved hjælp af et eksempel. Overvej et usorteret array med følgende elementer: {16, 12, 15, 13, 19}.





Eksempel:

Her sammenlignes de tilstødende elementer, og hvis de ikke er i stigende rækkefølge, byttes de.



Pseudokode for boblesorteringsalgoritmen

I pseudokode kan Bubble Sort -algoritmen udtrykkes 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

Ovenstående algoritme behandler alle sammenligninger, selvom matrixen allerede er sorteret. Det kan optimeres yderligere ved at stoppe algoritmen, hvis den indre sløjfe ikke forårsagede nogen bytte. Dette vil reducere algoritmens udførelsestid.



Således kan pseudokoden for den optimerede Bubble Sort -algoritme udtrykkes 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 hjælpeplads for boblesorteringsalgoritmen

Den værst tænkelige tidskompleksitet af boblesorteringsalgoritmen er O (n^2). Det opstår, når arrayet er i faldende rækkefølge, og du vil sortere det i stigende rækkefølge eller omvendt.



windows media player hvordan man roterer video

Tidskompleksiteten i bedste tilfælde af boblesorteringsalgoritmen er O (n). Det opstår, når arrayet allerede er sorteret.

er ulovlig adgang til det mørke web

Relaterede: Hvad er Big-O Notation?

Den gennemsnitlige sagstids kompleksitet af boblesorteringsalgoritmen er O (n^2). Det opstår, når elementerne i arrayet er i blandet rækkefølge.

Det ekstra rum, der kræves til Bubble Sort -algoritmen, er O (1).

C ++ Implementering af boblesorteringsalgoritmen

Nedenfor er C ++ implementeringen af ​​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;
}

Produktion:

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

Python -implementering af boblesorteringsalgoritmen

Nedenfor er Python -implementeringen af ​​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)

Produktion:

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

Relaterede: Sådan bruges til sløjfer i Python

C Implementering af boblesorteringsalgoritmen

Nedenfor er C -implementeringen af ​​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;
}

Produktion:

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

JavaScript -implementering af boblesorteringsalgoritmen

Nedenfor er JavaScript -implementeringen af ​​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);

Produktion:

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

Nu forstår du funktionen af ​​boblesorteringsalgoritmen

Bubble Sort er den enkleste sorteringsalgoritme og bruges hovedsageligt til at forstå grundlaget for sortering. Bubble Sort kan også implementeres rekursivt, men det giver ingen yderligere fordele at gøre det.

Ved hjælp af Python kan du nemt implementere Bubble Sort -algoritmen. Hvis du ikke kender Python og vil kickstarte din rejse, er det et godt valg at starte med et 'Hello World' -script.

Del Del Tweet E -mail Sådan kommer du i gang med Python ved hjælp af et 'Hello World' script

Python er et af de mest populære programmeringssprog, der bruges i dag. Følg denne vejledning for at komme i gang med dit allerførste Python -script.

Læs Næste Relaterede emner
  • Programmering
  • Java
  • Python
  • Kodning Tutorials
Om forfatteren Yuvraj Chandra(60 artikler udgivet)

Yuvraj er en datalogi bachelorstuderende ved University of Delhi, Indien. Han brænder for Full Stack Web Development. Når han ikke skriver, undersøger han dybden af ​​forskellige teknologier.

hvorfor virker min snap ikke
Mere fra Yuvraj Chandra

Abonner på vores nyhedsbrev

Tilmeld dig vores nyhedsbrev for at få tekniske tips, anmeldelser, gratis e -bøger og eksklusive tilbud!

Klik her for at abonnere