冒泡排序

冒泡排序由于比较简单和容易理解，往往会成为人们首先想到的排序算法。所谓冒泡就是泡泡一个一个往上冒，让体积最轻的泡泡浮在最上面，然后按照重量往下依次排列。(让当前项和后一项进行比较，如果当前项大于后一项，两个交换位置，小的在前面)

比如

var ary = [4,3,5,2,1];
第一轮比较
    4>3  交换位置 [3，4，5，2，1]
    4<5  不交换位置 [3，4，5，2，1]
    5>2  交换位置 [3，4，2，5，1]
    5>1 交换位置 [3，4，2，1，5]
    虽然没有实现目标，但是已经把最大的一项放在末尾
第二轮比较
    3<4  不交换位置 [3，4，2，1，5]
    4>2  交换位置 [3，2，4，1，5]
    4>1  交换位置 [3，2，1，4，5]
    到此结束本轮比较，因为在第一轮中已经把最大的放在最后了，因此，下行就不需要了，但是为了验证，我再次写出
    4<5 不交换位置 [3，2，1，4，5]
    虽然没有实现目标，但是已经把第二大的一项放在末尾
第三轮比较
    3>2  交换位置 [2，3，1，4，5]
    3>1  交换位置 [2，1，3，4，5]
    到此结束本轮比较，因为在第二轮中已经把第二最大的放在倒数第二了，因此，下行就不需要了，但是为了验证，我再次写出
    3<4  不交换位置 [2，1，3，4，5]
    4<5 不交换位置 [2，1，3，4，5]
    虽然没有实现目标，但是已经把第三大一项放在末尾
第四轮比较
    2>1  交换位置 [1，2，3，4，5]
    到此结束本轮比较，因为在第三轮中已经把第三大的放在倒数第三了，因此，下一行就不需要了，但是为了验证，我再次写出
    2<3  不交换位置 [1，2，3，4，5]
    3<4  不交换位置 [1，2，3，4，5]
    4<5 不交换位置 [1，2，3，4，5]   
    已经实现目标
从以上例子可以看出,我们可以总结出规律
假如有n项，我们用i代表数组的索引，i从0开始。
我们最多最多比较n-1轮，把最大值放在最后，把第二大放在倒数第二。。。。。。每一轮比较的次数：n-1-i;按照此规律即可实现数组排序

规律已经总结出，但是我们发现在比较中，要比较的两项交换位置，那么怎样才能交换位置呢？

var a= 1;
var b=2;
var c= null;
c=a;
a=b;
b=c;
console.log(a,b,c);

结果为2,1,1 我们可以看到a=2,b=1 a和b已经交换位置了

第二种方法，不用第三方变量来交换位置

var a= 1;
var b=2;
a = a+b;
b = a-b;
a = a-b;
console.log(a,b)

结果为 2，1 a和b已经交换位置

*写到这里思想已经分析完了，下面就是上代码了

var ary = [4,3,5,2,1];
    var tmp = null;
    function bubbleSort(ary) {
        for(var i=0;i<ary.length-1;i++){//此处是控制比较轮数，此数组长度为5，比较四次，也就是i<(5-1);i依次是0,1,2,3 比较4次
            for(var j=0;j<ary.length-1-i;j++){//此处控制每轮比较的次数
                if(ary[j]>ary[j+1]){
                    tmp = ary[j];
                    ary[j] = ary[j+1];
                    ary[j+1] = tmp;
                }
            }
        }
        return ary;
    }
    var res = bubbleSort(ary);
    console.log(res);

结果为 [1, 2, 3, 4, 5]