常规排序算法 ： 冒泡排序

1.冒泡排序（Bubble Sort）

开始，大学里接触到的第一个算法

(1)算法描述

冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

(2)算法描述和实现

具体算法描述如下：

• <1>.比较相邻的元素。如果第一个比第二个大，就交换它们两个；

• <2>.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

• <3>.针对所有的元素重复以上的步骤，除了最后一个；

• <4>.重复步骤1~3，直到排序完成。

代码实现

function bubbleSort(arr) {
	var len =arr.length;
	for(var i=0;i<len;i++){
		for(var j=0;j<len-1-i;j++){
			if(arr[j]>arr[j+1]){  //判断相邻两个数大小
				var tmp = arr[j+1];
				arr[j+1]=arr[j];
				arr[j]=tmp;
			}
		}
	}
	return arr
}

　　改进冒泡排序： 设置一标志性变量pos,用于记录每趟排序中最后一次进行交换的位置。由于pos位置之后的记录均已交换到位,故在进行下一趟排序时只要扫描到pos位置即可。

function bubbleSort1(arr) {
    var i=arr.length-1; //初始为数组最后一个位置
    while(i>0) {
        var pos = 0;
        for(var j=0;j<i;j++){
            if(arr[j]>arr[j+1]){
                pos=j; //记录下交换时候的位置
                var tmp = arr[j+1];
                arr[j+1]=arr[j];
                arr[j]=tmp;
            }
        }    
        i=pos;
    }    
    return arr;
}

传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半

改进后的算法实现为:

  

function bubbleSort2(arr) {
    var low = 0;
    var high = arr.length-1;
    var tmp,j;
    while(low<high){
        for(j=low;j<high;j++){
            if(arr[j]>arr[j+1]){
                tmp = arr[j+1];
                arr[j+1] =arr[j];
                arr[j] =tmp    
            }
        }
        --high;
        for(j=high;j>low;j--){
            if(arr[j]<arr[j-1]){
                tmp = arr[j-1];
                arr[j-1] =arr[j];
                arr[j] =tmp    
            }
        }
        low++;
    }    
    return arr;
}

运行：

console.time('1')
console.log(bubbleSort([33,200,99,45,4,100,33,111,23]))
console.timeEnd('1')
console.time('2')
console.log(bubbleSort1([33,200,99,45,4,100,33,111,23]))
console.timeEnd('2')
console.time('3')
console.log(bubbleSort2([33,200,99,45,4,100,33,111,23]))
console.timeEnd('3')

结果：