logo

TechCodeview

Bubble Sort – Vadnice za strukturo podatkov in algoritme

Bubble Sort je najenostavnejši algoritem za razvrščanje ki deluje tako, da večkrat zamenja sosednje elemente, če so v napačnem vrstnem redu. Ta algoritem ni primeren za velike nabore podatkov, saj je njegova povprečna in najslabša časovna kompleksnost precej visoka.

10 odstotkov od 60

Algoritem za razvrščanje z mehurčki

V algoritmu Bubble Sort,

  • prečkaj z leve in primerjaj sosednje elemente, višjega pa postavi na desno stran.
  • Na ta način se največji element najprej premakne na skrajno desni konec.
  • Ta postopek se nato nadaljuje, da se najde drugi največji in ga postavi in ​​tako naprej, dokler niso podatki razvrščeni.
Priporočena praksa Razvrščanje mehurčkov Poskusite!

Kako deluje Bubble Sort?

Razumejmo delovanje razvrščanja z mehurčki s pomočjo naslednje ilustracije:



Vnos: arr[] = {6, 0, 3, 5}

Prvi prehod:

Največji element je postavljen na pravilen položaj, to je na konec niza.

Algoritem za razvrščanje z mehurčki: postavitev največjega elementa na pravilen položaj

Drugi prehod:

Postavite drugi največji element na pravilno mesto

Algoritem za razvrščanje z mehurčki: postavitev drugega največjega elementa na pravilno mesto

Tretji prehod:

Preostala dva elementa postavite na pravilna mesta.

Algoritem za razvrščanje z mehurčki: postavitev preostalih elementov na njihove pravilne položaje

  • Skupno št. prehodov: n-1
  • Skupno št. primerjav: n*(n-1)/2

Izvedba Bubble Sort

Spodaj je izvedba razvrščanja z mehurčki. Lahko ga optimizirate tako, da zaustavite algoritem, če notranja zanka ni povzročila zamenjave.

C++ 
// Optimized implementation of Bubble sort #include  using namespace std; // An optimized version of Bubble Sort void bubbleSort(int arr[], int n) {  int i, j;  bool swapped;  for (i = 0; i < n - 1; i++) {  swapped = false;  for (j = 0; j < n - i - 1; j++) {  if (arr[j]>arr[j + 1]) { zamenjaj(arr[j], arr[j + 1]);  zamenjano = res;  } } // Če nobeden od dveh elementov ni bil zamenjan // z notranjo zanko, potem prekini, če (zamenjano == false) break;  } } // Funkcija za tiskanje matrike void printArray(int arr[], int size) { int i;  za (i = 0; i< size; i++)  cout << ' ' << arr[i]; } // Driver program to test above functions int main() {  int arr[] = { 64, 34, 25, 12, 22, 11, 90 };  int N = sizeof(arr) / sizeof(arr[0]);  bubbleSort(arr, N);  cout << 'Sorted array: 
';  printArray(arr, N);  return 0; } // This code is contributed by shivanisinghss2110>
C 
// Optimized implementation of Bubble sort #include  #include  void swap(int* xp, int* yp) {  int temp = *xp;  *xp = *yp;  *yp = temp; } // An optimized version of Bubble Sort void bubbleSort(int arr[], int n) {  int i, j;  bool swapped;  for (i = 0; i < n - 1; i++) {  swapped = false;  for (j = 0; j < n - i - 1; j++) {  if (arr[j]>arr[j + 1]) { zamenjaj(&arr[j], &arr[j + 1]);  zamenjano = res;  } } // Če z notranjo zanko nista bila zamenjana nobena dva elementa, // potem prekini, če (zamenjano == false) break;  } } // Funkcija za tiskanje matrike void printArray(int arr[], int size) { int i;  za (i = 0; i< size; i++)  printf('%d ', arr[i]); } // Driver program to test above functions int main() {  int arr[] = { 64, 34, 25, 12, 22, 11, 90 };  int n = sizeof(arr) / sizeof(arr[0]);  bubbleSort(arr, n);  printf('Sorted array: 
');  printArray(arr, n);  return 0; }>
Java 
// Optimized java implementation of Bubble sort import java.io.*; class GFG {    // An optimized version of Bubble Sort  static void bubbleSort(int arr[], int n)  {  int i, j, temp;  boolean swapped;  for (i = 0; i < n - 1; i++) {  swapped = false;  for (j = 0; j < n - i - 1; j++) {  if (arr[j]>arr[j + 1]) { // Zamenjaj arr[j] in arr[j+1] temp = arr[j];  arr[j] = arr[j + 1];  arr[j + 1] = temp;  zamenjano = res;  } } // Če nobena dva elementa // nista bila zamenjana z notranjo zanko, potem prekini, če (zamenjano == false) break;  } } // Funkcija za tiskanje matrike static void printArray(int arr[], int size) { int i;  za (i = 0; i< size; i++)  System.out.print(arr[i] + ' ');  System.out.println();  }  // Driver program  public static void main(String args[])  {  int arr[] = { 64, 34, 25, 12, 22, 11, 90 };  int n = arr.length;  bubbleSort(arr, n);  System.out.println('Sorted array: ');  printArray(arr, n);  } } // This code is contributed // by Nikita Tiwari.>
Python3 
# Optimized Python program for implementation of Bubble Sort def bubbleSort(arr): n = len(arr) # Traverse through all array elements for i in range(n): swapped = False # Last i elements are already in place for j in range(0, n-i-1): # Traverse the array from 0 to n-i-1 # Swap if the element found is greater # than the next element if arr[j]>arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] swapped = True if (swapped == False): break # Koda gonilnika za preizkus zgoraj if __name__ == '__main__': arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print('Razvrščena matrika:') za i v obsegu(len(arr)): print('%d' % arr[i], end=' ') # To kodo je spremenil Suraj krushna Yadav>>>C#
Javascript 
// Optimized javaScript implementation // of Bubble sort // An optimized version of Bubble Sort function bubbleSort(arr, n) {  var i, j, temp;  var swapped;  for (i = 0; i < n - 1; i++)   {  swapped = false;  for (j = 0; j < n - i - 1; j++)   {  if (arr[j]>arr[j + 1]) { // Zamenjaj arr[j] in arr[j+1] temp = arr[j];  arr[j] = arr[j + 1];  arr[j + 1] = temp;  zamenjano = res;  } } // ČE nobena dva elementa // nista bila zamenjana z notranjo zanko, potem prekini, če (zamenjano == false) break;  } } // Funkcija za tiskanje matrike function printArray(arr, size) { var i;  za (i = 0; i< size; i++)  console.log(arr[i] + ' '); } // Driver program var arr = [ 64, 34, 25, 12, 22, 11, 90 ]; var n = arr.length; bubbleSort(arr, n); console.log('Sorted array: '); printArray(arr, n); // This code is contributed shivanisinghss2110>
PHP 
 // PHP Optimized implementation // of Bubble sort // An optimized version of Bubble Sort function bubbleSort(&$arr) { $n = sizeof($arr); // Traverse through all array elements for($i = 0; $i < $n; $i++) { $swapped = False; // Last i elements are already // in place for ($j = 0; $j < $n - $i - 1; $j++) { // Traverse the array from 0 to // n-i-1. Swap if the element  // found is greater than the // next element if ($arr[$j]>$arr[$j+1]) { $t = $arr[$j]; $arr[$j] = $arr[$j+1]; $arr[$j+1] = $t; $swapped = True; } } // Če nobeden od dveh elementov ni bil zamenjan // z notranjo zanko, potem prekini, če ($swapped == False) break; } } // Koda gonilnika $arr = array(64, 34, 25, 12, 22, 11, 90); $len = sizeof($arr); bubbleSort($arr); echo 'Razvrščena matrika: 
'; for($i = 0; $i< $len; $i++) echo $arr[$i].' '; // This code is contributed by ChitraNayal. ?>>
Izhod 
Sorted array: 11 12 22 25 34 64 90>

Analiza kompleksnosti Bubble Sort :

Časovna zapletenost: O(N2)
Pomožni prostor: O(1)

Prednosti Bubble Sort:

  • Razvrščanje z mehurčki je preprosto razumljivo in implementirano.
  • Ne potrebuje dodatnega pomnilniškega prostora.
  • To je stabilen algoritem razvrščanja, kar pomeni, da elementi z enako ključno vrednostjo ohranijo svoj relativni vrstni red v razvrščenem izhodu.

Slabosti Bubble Sort:

  • Razvrščanje z mehurčki ima časovno kompleksnost O(N2), zaradi česar je zelo počasen za velike nize podatkov.
  • Bubble sort je algoritem za razvrščanje, ki temelji na primerjavi, kar pomeni, da zahteva primerjalni operator za določitev relativnega vrstnega reda elementov v nizu vhodnih podatkov. V določenih primerih lahko omeji učinkovitost algoritma.

Nekaj ​​pogostih vprašanj, povezanih z Bubble Sort:

Kaj je mejni primer za Bubble sort?

Razvrščanje z mehurčki traja najmanj časa (vrstni red n), ko so elementi že razvrščeni. Zato je najbolje, da predhodno preverite, ali je matrika že razvrščena ali ne, da se izognete O(N2) časovna zapletenost.

Ali se razvrščanje izvede na mestu pri Bubble sort?

Da, Bubble sort izvede zamenjavo sosednjih parov brez uporabe večje podatkovne strukture. Zato je algoritem Bubble sort algoritem na mestu.

Ali je algoritem Bubble sort stabilen?

Da, algoritem razvrščanja z mehurčki je stabilen.

Kje se uporablja algoritem Bubble sort?

Zaradi svoje preprostosti se razvrščanje z mehurčki pogosto uporablja za uvedbo koncepta algoritma za razvrščanje. V računalniški grafiki je priljubljen zaradi svoje zmožnosti odkrivanja majhne napake (kot je zamenjava samo dveh elementov) v skoraj razvrščenih nizih in jo popravlja s samo linearno kompleksnostjo (2n).

Primer: Uporablja se v algoritmu za zapolnjevanje poligonov, kjer so mejne črte razvrščene po koordinati x na določeni črti skeniranja (črta, ki je vzporedna z osjo x), s povečevanjem y pa se le njihov vrstni red spremeni (zamenjata se dva elementa). na presečiščih dveh črt.

Povezani članki:

  • Rekurzivno razvrščanje z mehurčki
  • Praksa kodiranja za razvrščanje
  • Kviz o Bubble Sort
  • Analiza kompleksnosti Bubble Sort