"Javascript：冒泡排序"

Question

我使用 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;
}

Answer 1

请看下面的顺序：

[5, 4, 3, 2, 1]

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

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

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

[4, 3, 2, 1, 5]

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

[3, 2, 1, 4, 5]

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

请参阅的一步一步的例子此文章。

Answer 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]));

Answer 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));

Answer 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))

Answer 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;
      }
    });
  }
}

Answer 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;
}

Answer 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;
            }
        }
    }
}

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

Answer 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

Answer 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+"*"+1000000000);
    }
}

}

Answer 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));

Answer 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));

Answer 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
        }
    }
}

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

Answer 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;
};

Answer 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 ]

Answer 15

function bubbleSort(array) {
  var done = false;
  while (!done) {
   //alert(1)
    done = true;
    for (var i = 1; i < array.length; i += 1) {
      if (array[i - 1] > array[i]) {
      //alert(2)
       
        done = false;
        var tmp = array[i - 1];
        array[i - 1] = array[i];
        array[i] = tmp;
      }
    }
  }

  return array;
}