使用 JavaScript 的冒泡排序算法

冒泡排序算法是一种通过比较两个相邻元素来对数组进行排序的算法，如果它们不符合预期的顺序，则交换它们。这里的顺序可以是任何增加的顺序或减少的顺序。

冒泡排序的工作原理

我们有一个未排序的数组arr = [ 1, 4, 2, 5, -2, 3 ]任务是使用冒泡排序对数组进行排序。

冒泡排序比较索引 0 中的元素，如果第 0 个索引小于第 1 个索引，则交换值，如果第 0 个索引小于第 1 个索引，则什么也不会发生。

然后，第一个索引与第二个索引进行比较，然后第二个索引与第三个索引进行比较，依此类推……

让我们用一个例子来看看它，这里简要说明每个步骤

比较发生到数组的最后一个元素

每次迭代后，数组的最大值成为数组的最后一个索引。在每次迭代中，比较发生到最后一个未排序的元素。

现在比较减少了一步，因为最大的元素在它的正确位置

在元素的所有迭代和比较之后，我们得到一个排序的数组。

句法

BubbleSort(array){
  for i -> 0 to arrayLength 
     for j -> 0 to (arrayLength - i - 1)
      if arr[j] > arr[j + 1]
        swap(arr[j], arr[j + 1])
}

执行

Javascript

// Bubble sort Implementation using Javascript
  
  
// Creating the bblSort function
 function bblSort(arr){
     
 for(var i = 0; i < arr.length; i++){
     
   // Last i elements are already in place  
   for(var j = 0; j < ( arr.length - i -1 ); j++){
       
     // Checking if the item at present iteration 
     // is greater than the next iteration
     if(arr[j] > arr[j+1]){
         
       // If the condition is true then swap them
       var temp = arr[j]
       arr[j] = arr[j + 1]
       arr[j+1] = temp
     }
   }
 }
 // Print the sorted array
 console.log(arr);
}
  
  
// This is our unsorted array
var arr = [234, 43, 55, 63,  5, 6, 235, 547];
  
  
// Now pass this array to the bblSort() function
bblSort(arr);

Output 
Sorted array :
[5, 6, 43, 55, 63, 234, 235, 547]

注意：此实现未优化。接下来我们将看到优化的解决方案。

优化方案

正如我们之前讨论的未优化的冒泡排序实现。即使数组已排序，代码也会以 O(n^2) 复杂度运行。让我们看看如何在 javascript 中实现优化的冒泡排序算法。

优化解决方案的语法

BubbleSort(array){
  for i -> 0 to arrayLength 
     isSwapped <- false
     for j -> 0 to (arrayLength - i - 1)
      if arr[j] > arr[j + 1]
        swap(arr[j], arr[j + 1])
        isSwapped -> true
}

执行

Javascript

// Optimized implementation of bubble sort Algorithm
  
function bubbleSort(arr){
    
  var i, j;
  var len = arr.length;
    
  var isSwapped = false;
    
  for(i =0; i < len; i++){
      
    isSwapped = false;
      
    for(j = 0; j < len; j++){
        if(arr[j] > arr[j + 1]){
          var temp = arr[j]
          arr[j] = arr[j+1];
          arr[j+1] = temp;
          isSwapped = true;
        }
    }
      
    // IF no two elements were swapped by inner loop, then break 
      
    if(!isSwapped){
      break;
    }
  }
    
  // Print the array
  console.log(arr)
}
  
  
var arr = [243, 45, 23, 356, 3, 5346, 35, 5];
  
// calling the bubbleSort Function
bubbleSort(arr)

Output
Sorted Array :
[3, 5, 23, 35, 45, 243, 356, 5346]

复杂性

最坏情况和平均情况时间复杂度

如果数组是逆序的，那么这种情况是最坏的情况，它的时间复杂度是O(n ² )。

最佳情况时间复杂度

如果数组已经排序，那么它是最好的情况，它的时间复杂度是O(n)

辅助空间：O(1)