冒泡排序算法JavaScript [关闭]

Posted 2023-02-14

【中文标题】冒泡排序算法JavaScript [关闭]

【英文标题】：Bubble sort algorithm JavaScript [closed]

【发布时间】：2011-11-22 01:58:22

【问题描述】：

请问你能告诉我在 javascript 中这种冒泡排序算法的实现有什么问题吗？

for (var i=1; i<records.length; i++)
        for (var j=records.length; j<1; j--)
            if (parseInt(records[i-1]) < parseInt(records[i]))
                var temp = records[i-1];
                records[i-1] = records[i]
                records[i] = temp;
               
            
    

【问题讨论】：

如果您告诉我们它的问题是什么，这可能会更好，然后我们也许可以告诉您如何解决它。

【参考方案1】：

冒泡排序的几个代码

冒泡排序不应该用于较大的数组，可以用于较小的数组，因为它很简单。

优化方式，包含所有检查

const bubble_Sort = (nums) => 
  if(!Array.isArray(nums)) return -1; // --->if passed argument is not array
  if(nums.length<2) return nums; // --->if array length is one or less

    let swapped=false
     temp=0,
     count=-1,
     arrLength=0;


    do
      count ++;
      swapped=false;
      arrLength = (nums.length-1) - count; //---> not loop through sorted items
      for(let i=0; i<=arrLength; i++)
          if(nums[i]>nums[i+1])
            temp=nums[i+1];
            nums[i+1]=nums[i];
            nums[i]=temp;
            swapped=true;
          
      
    

    while(swapped)
    return nums;
  
  console.log(bubble_Sort([3, 0, 2, 5, -1, 4, 1]));

方法一

var a = [33, 103, 3, 726, 200, 984, 198, 764, 9];

function bubbleSort(a) 
    var swapped;
    do 
        swapped = false;
        for (var i=0; i < a.length-1; i++) 
            if (a[i] > a[i+1]) 
                var temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
                swapped = true;
            
        
     while (swapped);


bubbleSort(a);
console.log(a);

方法二

function bubbleSort(items) 
    var length = items.length;
    //Number of passes
    for (var i = 0; i < length; i++)  
        //Notice that j < (length - i)
        for (var j = 0; j < (length - i - 1); j++)  
            //Compare the adjacent positions
            if(items[j] > items[j+1]) 
                //Swap the numbers
                var tmp = items[j];  //Temporary variable to hold the current number
                items[j] = items[j+1]; //Replace current number with adjacent number
                items[j+1] = tmp; //Replace adjacent number with current number
            
                
    

方法3

function bubbleSort() 
    var numElements = this.dataStore.length;
    var temp;
    for (var outer = numElements; outer >= 2; --outer) 
        for (var inner = 0; inner <= outer-1; ++inner) 
            if (this.dataStore[inner] > this.dataStore[inner+1]) 
                swap(this.dataStore, inner, inner+1); 
        
        console.log(this.toString()); 
    

【讨论】：

方法 3 是错误和部分代码！ this.dataStore.length 是什么意思？error codes

在方法1中，在每个交换阶段之后，较大的数字总是向右冒泡，所以在第二阶段，我们可以忽略最后一个元素，类似地在每个阶段之后我们可以减小数组的大小被 1 看。这将减少比较次数：

function bubbleSort(a) var swapped, len = a.length; do swapped = false; for (var i=0; i < len; i++) if (a[i] > a[i+1]) var temp = a[i]; a[i] = a[i+1]; a[i+1] = temp; swapped = true; len-- while (swapped); bubbleSort(a);

优化方式拒绝 TypedArray（将返回 -1），尽管该算法适用于 TypedArray。

在优化方案中，应该是i<arrLength而不是i<=arrLength。

【参考方案2】：

ES6 JavaScript 中的一个简单实现将是

    function BubbleSort(arr) 
      const sortedArray = Array.from(arr);
      let swap;
      do 
        swap = false;
        for (let i = 1; i < sortedArray.length; ++i) 
          if (sortedArray[i - 1] > sortedArray[i]) 
            [sortedArray[i], sortedArray[i - 1]] = [sortedArray[i - 1], sortedArray[i]];
            swap = true;
          
        
       while (swap)
      return sortedArray;
    
console.log(BubbleSort([3, 12, 9, 5]));

【参考方案3】：

我的解决方案：

  function bubbleSort(A)
  var swapped,
      len = arr.length;

  if(len === 1) return;

  do 
    swapped = false;
    for(var i=1;i<len;i++) 
      if(A[i-1] > A[i])    
        var b = A[i];
        A[i] = A[i-1];
        A[i-1] = b;
        swapped = true;
         
    

  
  while(swapped)  


var arr = [1, 6, 9, 5, 3, 4, 2, 12, 4567, 5, 34];
bubbleSort(arr);
document.write(arr);

【参考方案4】：

我相信在冒泡排序中，一旦第 i 个循环完成了一次迭代，那么第 i 个元素现在就处于正确的位置。这意味着您应该将 j 循环编写为

for (var j = i + 1; j < records.length; j++)

否则您的冒泡排序将（甚至更）低效。

【参考方案5】：

第二个for 循环编码错误，应该是

for (var i=0; i<records.length; i++)
    for (var j=0; j<records.length; j++)
        if (parseInt(records[i]) > parseInt(records[j]))
            var temp = records[i];
            records[i] = records[j];
            records[j] = temp;
           
        

【讨论】：

最好将for 循环嵌套在while 循环中，并为循环建立一个谓词。上面的代码将继续循环和循环，直到它结束......即使列表元素已经按顺序放置。

我认为您的代码在最佳情况下也可以工作 O(n2)。拥有这样的代码成本很高。根据这种情况，它不太好。也要坚持复杂性

【参考方案6】：

您应该在第二个循环中使用 j 而不是 i，并且不要忘记将 j1

【讨论】：

谢谢你，我想我用 J 代替我

if (parseInt(records[i-1]) < parseInt(records[i])) var temp = records[i-1]; records[i-1] = records[i] records[i] = temp; 我在那儿

是的，你是对的，但后来我得到：TypeError: records[j] is undefined

那是因为你试图访问records[records.length]，这个数组中不存在，如果你想从最后开始for循环，你必须从记录开始。长度-1 for (var j=records.length-1; j>0; j--)

【参考方案7】：

for (var j=records.length; j<1; j--)

不应该是这样的

for (var j=records.length; j>1; j--)

【讨论】：

我认为它应该是 (records.length - 1) 因为索引从 0 开始

但是 j 不用作数组的索引；而是用作计数器

这真的是冒泡排序吗？这将如何工作？？

目前不会冒泡排序 - 它只会继续交换第 i 和第 (i - 1) 个元素。我只是指出了他的代码的明显问题（没有进入内部循环的原因）。

是的，我也指出了这一点 :)