冒泡排序

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

**】算法描述
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。

**】优化方案1：定义一个变量l来保存一趟交换中两两交换的次数，如果l==0,则说明排序已经完成，退出for循环（如下代码中的： flag）

function bubbleSort(arr) {
    let len = arr.length; 
    let i = 0;
	let pos = 0;//用来记录最后一次交换的位置
	let k = len - 1;
	let flag = 0;
    for(i = 0; i < len - 1; i++) { // 确定排序趟数
    	pos = 0; 
		let j = 0;
        for(j = 0; j < len -1; j++) { // 确定比较次数
            if(arr[j] > arr[j+1]) {        // 相邻元素两两对比   
                let temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
               flag++
            }
        }
		if(flag==0) { return;}
	        
	    }
    
    return arr;
}

**】优化方案2（假如有一个长度为50的数组，在一趟交换后，最后发生交换的位置是10，那么这个位置之后的40个数必定已经有序了，记录下这位置，下一趟交换只要从数组头部到这个位置就可以了）
定义一个变量pos来保存一趟交换中最后一次发生交换的位置，并把它传递给下一趟交换

**】 代码实现

function bubbleSort(arr) {
    let len = arr.length; 
    let i = 0;
	let pos = 0;//用来记录最后一次交换的位置
	let k = len - 1;
	let flag = 0;
    let j = 0;
    for(i = 0; i < len - 1; i++) { // 确定排序趟数
        for(j = 0; j < k; j++) { // 确定比较次数
            if(arr[j] > arr[j+1]) {        // 相邻元素两两对比
                  
                let temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
               flag++;
			   pos = j;
            }
        }
		if(flag==0) { return;}
        k = pos;
    }
    
    return arr;
}

**】优化3
一次排序可以确定两个值，正向扫描找到最大值交换到最后，反向扫描找到最小值交换到最前面

function bubbleSort(arr) {
    let len = arr.length; 
    let i = 0;
	let pos = 0;//用来记录最后一次交换的位置
	let k = len - 1;
	let flag = 0;
    let j = 0;
    let n = 0;
    for(i = 0; i < len - 1; i++) { // 确定排序趟数
        for(j = n; j < k; j++) { // 确定比较次数
            if(arr[j] > arr[j+1]) {        // 相邻元素两两对比
                  
                let temp = arr[j+1];        // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
               flag++;
			   pos = j;
            }
        }
		if(flag==0) { return;}
        k = pos;
        //反向寻找最小值
		for (j = k; j > n; j--)
		{
			int tmp = arr[j];
			arr[j] = arr[j - 1];
			arr[j - 1] = tmp;
			flag = 1;
		}
		n++;
		if (flag == 0)//如果没有交换过元素，则已经有序,直接结束
		{
			return;
		}
 }
    
    return arr;
}

**】 效果展示