Javascript：冒泡排序

问题描述 投票：0回答：17

我使用 JS 制作了一个冒泡排序算法（有点）。有时它可以工作，但问题是它只迭代数组一次。这是我的代码：

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;
}
javascript algorithm sorting bubble-sort
17个回答
3
投票

另一种冒泡排序实现：

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

2
投票

请看以下顺序：

[5, 4, 3, 2, 1]

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

因此，您迭代数组并交换否则排序的相邻元素。

这是迭代完成后您将得到的结果

[4, 3, 2, 1, 5]

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

[3, 2, 1, 4, 5]

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

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

1
投票
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))
1
投票
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] && (i+1 < arr.length)) {
                var temp = arr[i];
                arr[i] = arr[i+1];
                arr[i+1] = temp;
            }
        }
    }      
    return arr;
}
console.log(bubbleSort(array));
0
投票

我的冒泡排序只需要一个 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;
      }
    });
  }
}
0
投票
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;
}
0
投票

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

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

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

0
投票

这对我有用。我评论了代码以便更好地理解

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
0
投票
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));
0
投票

试试这个（性能升级）：

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));
0
投票

你需要另一个循环：

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

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

0
投票
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 ]
0
投票
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;
}
0
投票

另一种方式是这样的：

function bubbleSort(arr) {
  let swapped;

  do {
    swapped = false;

    for (var i = 0; i < arr.length; i++) {
      if (arr[i] > arr[i + 1]) {
        swapped = true;
        var tmp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = tmp;
      }
    }
  } while (swapped);

  return arr;
}

let myArray = [8, 1, 2, 5, 51, 13, 15, 33, 123, 100, 22];

console.log(bubbleSort(myArray));

解释：
在此函数中，我们将声明一个 swapped 变量，该变量在 DO WHILE 循环内设置为 false，这样做是为了防止出现无限循环。

在循环内部，我们有另一个 FOR 循环，它迭代给定的数组并检查当前值是否大于下一个值（我们不希望这样，我们需要升序）。

当 IF 条件为 true 时，我们将交换变量并为交换的变量分配 true，这样做是因为我们想保持 DO WHILE 循环，直到所有内容都排序完毕。

0
投票

使用无交换方法的冒泡排序

const bubbleSort = (arr) => {
    let noSwaps;
    for(let i=arr.length; i>=0; i--) {
        noSwaps = true;
        for(let j=0; j<i; j++) {
            if(arr[j] > arr[j+1]) {
                //SWAP!!
                [arr[j], arr[j+1]] = [arr[j+1], arr[j]];
                noSwaps = false;
            }
        }
        if(noSwaps) break;
    }
    return arr;
}

console.log(bubbleSort([8,1,2,3,4,5,6]));
-1
投票
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);
    }
}

}
最新问题
© www.soinside.com 2019 - 2024. All rights reserved.