BURBULŲ RŪŠIAVIMAS – DUOMENŲ STRUKTŪROS IR ALGORITMŲ VADOVĖLIAI

Burbulų rūšiavimas yra paprasčiausias rūšiavimo algoritmas kuri veikia pakartotinai keičiant gretimus elementus, jei jie yra neteisinga tvarka. Šis algoritmas netinka dideliems duomenų rinkiniams, nes jo vidutinis ir blogiausio atvejo laiko sudėtingumas yra gana didelis.

Burbulų rūšiavimo algoritmas

Naudodami burbulų rūšiavimo algoritmą,

važiuokite iš kairės ir palyginkite gretimus elementus, o aukštesnis dedamas dešinėje pusėje.

Tokiu būdu didžiausias elementas iš pradžių perkeliamas į dešinįjį kraštą.

Tada šis procesas tęsiamas ieškant antrojo pagal dydį ir įdedant jį ir taip toliau, kol duomenys bus surūšiuoti.

Rekomenduojamas praktinis burbulų rūšiavimas Išbandykite!

Kaip veikia burbulinis rūšiavimas?

Supraskime burbulų rūšiavimo veikimą naudodami šią iliustraciją:

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

Pirmas leidimas:

Didžiausias elementas dedamas į teisingą padėtį, ty masyvo pabaigą.

Burbulų rūšiavimo algoritmas: didžiausio elemento įdėjimas į teisingą vietą

Antrasis leidimas:

Padėkite antrą pagal dydį elementą teisingoje vietoje

Burbulų rūšiavimo algoritmas: antrojo pagal dydį elemento įdėjimas į teisingą vietą

Trečias leidimas:

Įdėkite likusius du elementus į teisingas vietas.

Burbulų rūšiavimo algoritmas : likusių elementų išdėstymas teisingose vietose

Iš viso Nr. leidimų: n-1
Iš viso Nr. palyginimų: n*(n-1)/2

„Bubble Sort“ diegimas

Žemiau pateikiamas burbulų rūšiavimo įgyvendinimas. Jį galima optimizuoti sustabdžius algoritmą, jei vidinė kilpa nesukėlė jokio apsikeitimo.

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]) { apsikeitimas(arr[j], arr[j + 1]);  sukeistas = tiesa;  } } // Jei vidiniu ciklu nebuvo sukeisti du elementai //, tada break if (sukeisti == false) break;  } } // Funkcija spausdinti masyvą void printArray(int arr[], int dydis) { int i;  už (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

  // 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]) { apsikeitimas(&arr[j], &arr[j + 1]);  sukeistas = tiesa;  } } // Jei vidine kilpa nebuvo sukeisti du elementai, // tada break if (sukeisti == false) break;  } } // Funkcija spausdinti masyvą void printArray(int arr[], int dydis) { int i;  už (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]) { // Sukeisti arr[j] ir arr[j+1] temp = arr[j];  arr[j] = arr[j + 1];  arr[j + 1] = temp;  sukeistas = tiesa;  } } // Jei vidiniu ciklu nebuvo // sukeisti du elementai, tada break if (sukeisti == false) break;  } } // Funkcija spausdinti masyvą static void printArray(int arr[], int dydis) { int i;  už (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] sukeistas = Tiesa, jei (sukeisti == Netiesa): pertrauka # Vairuotojo kodas, kurį reikia patikrinti aukščiau, jei __name__ == '__main__': arr = [64, 34, 25, 12, 22, 11, 90] bubbleSort(arr) print('Sorted array:') for i diapazone(len(arr)): print('%d' % arr[i], end=' ') # Šį kodą modifikavo Suraj krushna Yadav

  // Optimized C# implementation of Bubble sort using System; class GFG {  // An optimized version of Bubble Sort  static void bubbleSort(int[] arr, int n)  {  int i, j, temp;  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]) { // Sukeisti arr[j] ir arr[j+1] temp = arr[j];  arr[j] = arr[j + 1];  arr[j + 1] = temp;  sukeistas = tiesa;  } } // Jei vidiniu ciklu nebuvo // sukeisti du elementai, tada break if (sukeisti == false) break;  } } // Funkcija spausdinti masyvą static void printArray(int[] arr, int dydis) { int i;  už (i = 0; i < size; i++)  Console.Write(arr[i] + ' ');  Console.WriteLine();  }  // Driver method  public static void Main()  {  int[] arr = { 64, 34, 25, 12, 22, 11, 90 };  int n = arr.Length;  bubbleSort(arr, n);  Console.WriteLine('Sorted array:');  printArray(arr, n);  } } // This code is contributed by Sam007

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]) { // Sukeisti arr[j] ir arr[j+1] temp = arr[j];  arr[j] = arr[j + 1];  arr[j + 1] = temp;  sukeistas = tiesa;  } } // JEI nebuvo du elementai // sukeisti vidine kilpa, tada break if (sukeisti == false) break;  } } // Funkcija spausdinti masyvo funkciją printArray(arr, size) { var i;  už (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; $sukeisti = Tiesa; } } // Jei vidiniu ciklu nebuvo sukeisti du elementai //, tada pertrauka if ($swaped == False) break; } } // Tvarkyklės kodas $arr = array(64, 34, 25, 12, 22, 11, 90); $len = dydisof($arr); bubbleSort($arr); echo 'Rūšiuotas masyvas: 
'; for($i = 0; $i < $len; $i++) echo $arr[$i].' '; // This code is contributed by ChitraNayal. ?>>>   
  Išvestis       Laiko sudėtingumas:     O (N  ² )   
    Pagalbinė erdvė:     O(1)  
      Burbulinio rūšiavimo pranašumai:     
   Burbulų rūšiavimą lengva suprasti ir įgyvendinti.  
  Tam nereikia papildomos atminties vietos.  
  Tai stabilus rūšiavimo algoritmas, reiškiantis, kad elementai, turintys tą pačią rakto reikšmę, išlaiko santykinę tvarką surūšiuotoje išvestyje.  
 
     Burbulinio rūšiavimo trūkumai:     
   Burbulų rūšiavimo laiko sudėtingumas yra O(N  ² ), todėl dideliems duomenų rinkiniams tai daroma labai lėtai.  
  Burbulų rūšiavimas yra palyginimu pagrįstas rūšiavimo algoritmas, o tai reiškia, kad norint nustatyti santykinę elementų tvarką įvesties duomenų rinkinyje, reikalingas palyginimo operatorius. Tam tikrais atvejais tai gali apriboti algoritmo efektyvumą.  
 
  Kai kurie DUK, susiję su burbulų rūšiavimu:  
     Kas yra „Bubble“ rūšiavimo ribinis atvejis?        
  Burbulų rūšiavimas užtrunka mažiausiai laiko (n tvarka), kai elementai jau surūšiuoti. Todėl geriausia iš anksto patikrinti, ar masyvas jau surūšiuotas, ar ne, kad būtų išvengta O(N  ² ) laiko sudėtingumas.  
   Ar rūšiavimas vyksta vietoje burbulų rūšiavimo sistemoje?  
  Taip, burbulų rūšiavimas atlieka gretimų porų apsikeitimą nenaudodamas jokios pagrindinės duomenų struktūros. Taigi burbulų rūšiavimo algoritmas yra vietoje algoritmas.  
   Ar burbulų rūšiavimo algoritmas stabilus?  
  Taip, burbulų rūšiavimo algoritmas yra stabilus.  
   Kur naudojamas burbulų rūšiavimo algoritmas?  
  Dėl savo paprastumo burbulų rūšiavimas dažnai naudojamas rūšiavimo algoritmo koncepcijai pristatyti. Kompiuterinėje grafikoje ji populiari dėl savo gebėjimo aptikti mažytę klaidą (pvz., vos dviejų elementų apsikeitimą) beveik surūšiuotose masyvuose ir ją ištaisyti tik tiesiniu sudėtingumu (2n).  
   Pavyzdys: jis naudojamas daugiakampio užpildymo algoritme, kai ribojančios linijos rūšiuojamos pagal jų x koordinates konkrečioje nuskaitymo linijoje (tiesė, lygiagreti x ašiai), o didinant y jų tvarka keičiasi (du elementai sukeisti) tik dviejų linijų sankirtose.  
      Susiję straipsniai:        
     Rekursyvus burbulų rūšiavimas   
   Rūšiavimo kodavimo praktika   
   Viktorina apie burbulų rūšiavimą   
   Burbulų rūšiavimo sudėtingumo analizė