常规排序算法 ： 冒泡排序

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

结果：