Javascript：冒泡排序

Posted 2023-02-19

【中文标题】Javascript：冒泡排序

【英文标题】：Javascript: Bubble Sort

【发布时间】：2016-10-15 12:00:11

【问题描述】：

我用 JS 做了一个冒泡排序算法（sorta）。它有时会起作用，但问题是它只遍历数组一次。这是我的代码：

function bubble(arr) 
  for (var i = 0; i < arr.length; i++) 
    if (arr[i] > arr[i + 1]) 
      var a = arr[i]
      var b = arr[i + 1]
      arr[i] = b
      arr[i + 1] = a
    
  
  return arr;

【问题讨论】：

你认为如何让它再次通过数组运行？在什么情况下应该停止？

这就是我遇到的麻烦:(

请参考pseudocode implementations in Wikipedia：您需要不断循环直到满足条件（不发生交换）。在 javascript 中，这可能意味着您的代码顶部有一个很大的 while()。

【参考方案1】：

请看下面的顺序：

[5, 4, 3, 2, 1]

现在假设您需要使用冒泡排序按升序对其进行排序。

因此，您迭代数组并交换以其他方式排序的相邻元素。

这是迭代完成后你会得到的东西

[4, 3, 2, 1, 5]

现在如果你再做一次，你会得到这个：

[3, 2, 1, 4, 5]

同样，您需要重复迭代足够多次才能使其完全排序。这意味着您需要 2 个嵌套循环。内循环是对数组进行迭代，外循环是重复迭代。

请参阅this 文章的分步示例。

【参考方案2】：

您需要一个内部循环来正确完成排序：

function bubble(arr) 
      var len = arr.length;
    
      for (var i = 0; i < len ; i++) 
        for(var j = 0 ; j < len - i - 1; j++) // this was missing
        if (arr[j] > arr[j + 1]) 
          // swap
          var temp = arr[j];
          arr[j] = arr[j+1];
          arr[j + 1] = temp;
        
       
      
      return arr;
    

document.write(bubble([1,9,2,3,7,6,4,5,5]));

【讨论】：

请解释一下内部循环，为什么需要它？

【参考方案3】：

var array = [6,2,3,7,5,4,1];
function bubbleSort(arr) 
    for(let j=0;j<arr.length;j++) 
        for(let i = 0; i < arr.length; i++) 
            if(arr[i]>arr[i+1]) 
                var temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            
        
          
    return arr;

console.log(bubbleSort(array));

【参考方案4】：

const bubbleSort = (array)=>
  let sorted = false;

  let counter =0;

  while(!sorted)
    sorted = true;  
    for(let i =0; i < array.length -1 -counter; i++)

      if(array[i] > array[i+1])
        helper(i,i+1,array);        
        sorted = false;
      
     
    counter++;
  
  return array;



//swap function
function helper(i,j, array)
  return [array[i],array[j]] = [array[j],array[i]]


let array=[8,5,2,9,5,6,3];

console.log(bubbleSort(array))

【参考方案5】：

我的冒泡排序只有一个while循环：

function bubbleSort(arr)
  var sorted = false
  while (!sorted)
    sorted = true;
    arr.forEach(function (element, index, array)
      if (element > array[index+1]) 
        array[index] = array[index+1];
        array[index+1] = element;
        sorted = false;
      
    );
  

【参考方案6】：

function bubble(arr) //You need Two Loops for Bubble sort
  for (var i = 0; i < arr.length; i++) //Outer Loop
   for(var j=0; j < arr.length - 1; j++)//Inner Loop
    if (arr[j] > arr[j + 1]) 
      var a = arr[j]
      var b = arr[j + 1]
      arr[j] = b
      arr[j + 1] = a
     
   
  
  return arr;

【参考方案7】：

另一种形式的冒泡排序包括从数组的末尾开始，将最小的元素放在最前面，直到最大的元素。这是代码：

function bubbleSort(items)   
    var length = items.length;
    for (var i = (length - 1); i >= 0; i--) 
        //Number of passes
        for (var j = (length - i); j > 0; j--) 
            //Compare the adjacent positions
            if (items[j] < items[j - 1]) 
                //Swap the numbers
                var tmp = items[j];
                items[j] = items[j - 1];
                items[j - 1] = tmp;
            
        
    

注意冒泡排序是最慢的排序算法之一。

【参考方案8】：

它对我有用。我评论了代码以获得更多理解

bubbleSort = (numbersArray) => 
  const arrayLenght = numbersArray.length;

  for (let i = 0; i < arrayLenght; i++) 
    for(let j = 0; j < arrayLenght; j++) 
      // Print only to debug
      // console.log(`i: $i - j: $j`);
      // console.log(`numbersArray[i]: $numbersArray[i] | numbersArray[j]: $numbersArray[j]`);
    
      // Check if current number is greater than the next number
      if (numbersArray[j] > numbersArray[j + 1]) 
        // Store current value to generate swap
        const currentNumber = numbersArray[j];

        // Now the current position get value of the next position
        // And de next position get value of the current position
        numbersArray[j] = numbersArray[j + 1];
        numbersArray[j + 1] = currentNumber; 
       
    
  

  // Debug: Print the sorted array
  console.log(`sorted array: $numbersArray.toString()`);


const numbers = [
  [3, 10, 5, 7],
  [8, 5, 2, 9, 5, 6, 3],
  [4, 50, 28, 47, 9, 2097, 30, 41, 11, 3, 68],
  [3, 10, 5, 7, 8, 5, 2, 9, 5, 6, 3]
];

numbers.forEach(element => 
  bubbleSort(element);
);

输出：

排序数组：3,5,7,10 排序数组：2,3,5,5,6,8,9 排序后的数组：3,4,9,11,28,30,41,47,50,68,2097 排序数组：2,3,3,5,5,5,6,7,8,9,10

【参考方案9】：

package hasan;

public class hssd 

public static void main(String[] args) 


 int t=9;
int g=20;



 for (t=g;t>19;++t)

    System.out.println(7);
   int f=12;
   int r=15;

    for(r=f;r>5;++r)
        System.out.println(r+1000000000+"*"[phone]);
    

【讨论】：

对您发布的内容的一个小解释将受到欢迎。仅代码的答案不鼓励。

请解释一下你的代码做了什么，特别是为什么它解决了手头的问题

【参考方案10】：

var arr = [5, 3, 4, 1, 2, 6];

function sort (arr) 
    for(let i=0; i < arr.length - 1; i++) 
        if(arr[i] > arr[i+1]) 
            let b = arr[i+1];

            arr[i+1] = arr[i];
            arr[i] = b;

            i = -1; // Resets the loop
        
    

    return arr;


console.log(sort(arr));

【参考方案11】：

试试这个（性能升级）：

function bubbleSort(inputArr, reverse = false) 
    const len = inputArr.length;
    for (let i = 0; i < len; i++) 
        for (let j = i + 1; j < len; j++) 
            let a = inputArr[i];
            let b = inputArr[j];
            if (reverse ? a < b : a > b) 
                const tmp = inputArr[j];
                inputArr[j] = inputArr[i];
                inputArr[i] = tmp;
            
        
    
    return inputArr;

用途：

arr = [234,2,4,100, 1,12,5,23,12];
console.log(bubbleSort(arr)); // or console.log(bubbleSort(arr, true));

【参考方案12】：

你需要另一个循环：

var arr = [2, 1]
for(let i = 0;i<arr.length;i++)
    for(let b = 0; b<arr.length;i++)
        if(arr[b] > arr[b+1])
            var first = arr[b]
            var second = arr[b + 1]
            arr[b] = second
            arr[b + 1] = first
        
    

希望这对您有所帮助，但如果您想要高效率，我建议您使用快速排序。

【讨论】：

对我通过引用 i 而不是 b 所犯的意外错误表示歉意，我已经在 node.js 中成功运行它，但为了这个问题而改变了它！

【参考方案13】：

另一个冒泡排序实现：

const bubbleSort = array => 
  const arr = Array.from(array); // avoid side effects
  for (let i = 1; i < arr.length; i++) 
    for (let j = 0; j < arr.length - i; j++) 
      if (arr[j] > arr[j + 1]) 
        [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
      
    
  
  return arr;
;

【参考方案14】：

const bubbleSort = (inputArr) => 
  const len = inputArr.length;

  for (let i = 0; i < len; i++) 
    for (let j = 0; j < len; j++) 
      if (inputArr[j] > inputArr[j + 1]) 
        let tmp = inputArr[j];
        inputArr[j] = inputArr[j + 1];
        inputArr[j + 1] = tmp;
      
    
  

  return inputArr;
;

const numbers = [50, 30, 10, 40, 60];

console.log(bubbleSort(numbers));

// Output: [ 10, 30, 40, 50, 60 ]