JavaScript的排序算法——冒泡排序

冒泡排序（Bubble Sort）

冒泡排序，有时也被称做沉降排序，是一种比较简单的排序算法。这种算法的实现是通过遍历要排序的列表，把相邻两个不符合排列规则的数据项交换位置，然后重复遍历列表，直到不再出现需要交换的数据项。当没有数据项需要交换时，则表明该列表已排序。

中心思想：重复地走访要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来

算法描述：

1、比较相邻的元素，如果第一个比第二个大，就交换它们

2、对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对，这样在最后对元素就是最大的数

3、针对所有的元素，重复以上的步骤(除了最后一个)

4、重复步骤1～3，直到排序完成

                                                         

原理图：

复杂度

算法	最好情况	平均情况	最坏情况	空间复杂度	稳定性
冒泡排序	O(n)	O(n2)	O(n2)	O(1)	稳定

 

代码实现：

function bubbleSort(array){
	var len = array.length, result;
	result = array.slice(0);
	for (let i = 0; i < len; i++) {
		for (let j = 0; j <len-1; j++) {
			if (result[j] > result[j +1]) {
				var tmp = result[j + 1];
				result[j + 1] = result[j];
				result[j] = tmp;
			}
		}
	}
	return result;
}
console.log(bubbleSort([17,3,25,14，20,9]));

改进冒泡排序

对上述冒泡排序的一种优化， 优化思路：当一次遍历前后数组不产生变化时，说明该数组已经有序，结束排序。

 

function bubbleSort(array){
	var len = array.length, result;
	result = array.slice(0);
	var exchange; //判断数组排序内容是否有变化
	for (let i = 0; i < len; i++) {
		exchange = true;
		for (let j = 0; j <len-1; j++) {
			if (result[j] > result[j +1]) {
				var tmp = result[j + 1];
				result[j + 1] = result[j];
				result[j] = tmp;
				exchange = false;
			}
		}
		
		if(exchange){
			break;
		}
	}
	return result;
}
console.log(bubbleSort([17,3,25,14,20,9]));

冒泡排序优化2：

减小循环次数

function bubbleSort3(arr){
    let len = arr.length;
    for(let i = 0;i<len;i++){
        let exchange = true;
        for(let j = 0;j<len-1-i;j++){
            if(arr[j]>arr[j + 1]){
                [arr[j],arr[j+1]] = [arr[j+1],arr[j]];
                exchange = false;
            }
        }
        
        if(exchange){
            break;
        }
    }
    return arr;
}
console.log(bubbleSort3([17,3,25,14,20,9]));

 

冒泡排序优化3：

利用在每趟排序中进行正向和反向两遍冒泡的方法，一次可以得到两个最值(最大值和最小值)，从而使排序趟数几乎减少一半。

function bubbleSort3(arr){
	var low = 0, high = arr.length-1;
	while(low<high){
		var j = low;
		for(j;j<high;j++){ // 正向冒泡找到最大值
			if(arr[j]>arr[j+1]){
				var temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
		}
		--high;
		for(j=high;j>low;j--){// 反向冒泡找到最小值
			if(arr[j]<arr[j-1]){
				var temp = arr[j];
				arr[j] = arr[j-1];
				arr[j-1] = temp;
			}
		}
		++low;
	}
	return arr;
}

冒泡优化4：

设置一个最大值标志maxPos和最小值标志minPos，每次只将两个标志之间的进行排序比较。

function bubbleSort4(arr){
	 var minPos = 0, maxPos = arr.length-1;
	 while(minPos<maxPos){
	     var j = minPos, tempMin, tempMax;
	     for(j;j<maxPos;j++){
	         if(arr[j]>arr[j+1]){
	             tempMax = j;
	             var temp = arr[j];
	             arr[j] = arr[j+1];
	             arr[j+1] = temp;
	         }
	     }
	     maxPos = tempMax;
	     for(j=maxPos;j>minPos;j--){
	         if(arr[j]<arr[j-1]){
	             tempMin = j;
	             var temp = arr[j];
	             arr[j] = arr[j-1];
	             arr[j-1] = temp;
	         }
	     }
	     minPos = tempMin;
	 }
	 return arr;
}

相关阅读

JavaScript的排序算法——冒泡排序
JavaScript的排序算法——选择排序
JavaScript的排序算法——插入排序
JavaScript的排序算法——归并排序
JavaScript的排序算法——快速排序