JavaScript——冒泡排序

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

　　例如一个数组[5,4,3,2,1],按照顺序从小往大排序。

　　arr.length=5（5个元素）。

　　第一种常见做法：

　　思路如下：

　　1.排序的第1次（即是i=0的时候），交换了4次(j<4)，排序的结果为：4 3 2 1 5

　　　排序的第2次（即是i=1的时候），交换了3次(j<3)，排序的结果为：3 2 1 4 5

　　　排序的第3次（即是i=2的时候），交换了2次(j<2)，排序的结果为：2 1 3 4 5

　　　排序的第4次（即是i=3的时候），交换了1次(j<1)，排序的结果为：1 2 3 4 5

 　　因此得出规律排序了4趟（即是外层循环了arr.length-1次），里层交换了4次（即是里层循环了arr.length-i-1次）；

　　2.就是位置的交换，max作为临时变量存储，进行if条件判断，如果前面的数值大于后面的数值，则把两个值进行交换位置。

　 代码如下;　

　　 var arr = [5,4,3,2,1];
　　var max;
　　console.log(arr.length);
　　for (var i = 0; i < arr.length; i++) {
    　　for (var j = 0; j < arr.length-i-1; j++) {
         {
            if (arr[j] > arr[j+1]) {
                max = arr[j+1];
                arr[j+1] = arr[j];
                arr[j] = max;
           　　 }
         　　   console.log(‘这是第’ + i + ‘次的循环结果如下：’ + ‘/n’ + arr);//打印每次第i趟，方便观察j交换了多少次的结果
      　　  }
   　　 }
　 }
　　console.log(‘最终的结果为’+arr);
 
 
　　第二种是我自己的想法（如果想从大往小排，改变if判断语句为arr[i] < arr[j]）：

      思路如下：

      1.排序的第1次（即是i=0的时候），交换了4次，排序的结果为：1 5 4 3 2

　　 排序的第2次（即是i=1的时候），交换了3次，排序的结果为：1 2 5 4 3

        排序的第3次（即是i=2的时候），交换了2次，排序的结果为：1 2 3 5 4

　　 排序的第4次（即是i=3的时候），交换了1次，排序的结果为：1 2 3 4 5

　　 因此得出规律排序了4趟（即是外层循环了arr.length-1次），但是在里层循环，我是保持j的范围小于5，j的初始值设为i+1

　　 即当i=0时，与j=1，j=2，j=3，j=4比较；当i=1时，与j=2，j=3，j=4比较；当i=2时，j=3，j=4比较；当i=3时，与j=4比较；

        2.就是位置的交换，max作为临时变量存储，进行if条件判断，a[i]与a[j]进行比较，如果前面的数值大于后面的数值，则把两个值进行交换位置，一直往后挪。

　    代码如下：

　　var arr = [5,4,3,2,1];
　　var max;
　　console.log(arr.length);
　　for (var i = 0; i < arr.length – 1; i++) {
   　　 for (var j = i + 1; j < arr.length; j++) {
      　　  {
         　　   if (arr[i] > arr[j]) {
             　　   max = arr[j];
               　　 arr[j] = arr[i];
                　　arr[i] = max;
           　　 }
            　　console.log(‘这是第’ + i + ‘次的循环结果如下：’ + ‘/n’ + arr);
        　　}
    　　}
　　}
　　console.log(‘最终的结果为’+arr);