冒泡排序进阶优化

冒泡排序的思想：我们以升序排列为例，所谓冒泡排序就是在无序数组中每执行一趟选出这一趟中最大的数放在最后面，第二趟选出次大的数放在倒数第二位上，直到完成排序。以此类推降序就是将小的数放在后面排序。代码如下： 

方法（一）

 1     var arr = [6, 5, 3, 4, 1, 2];
 2     function sort(arr) {
 3         // 遍历数组，次数就是arr.length - 1
 4         for (var i = 0; i < arr.length - 1; i++) {
 5             // 这里根据外层for循环的i，逐渐减少内层 for循环j的次数所以要减i。
 6             for (var j = 0; j < arr.length - 1-i; j++) {
 7                 if (arr[j] > arr[j + 1]) {
 8                 //设置第三方变量（x）来用于数据交换，且这个变量放在循环的外面性能要好，两两对比，把大的数放在后面。
 9                     var x = arr[j + 1];
10                     arr[j + 1] = arr[j];
11                     arr[j] = x;
12                     // 利用加法来实现两个数据的交换
13                     // arr[j] = arr[j] + arr[j+1];
14                     // arr[j+1] = arr[j] - arr[j+1];
15                     // arr[j] = arr[j] - arr[j+1];
16                     
17                     // 利用位运算实现两个数据的交换
18                     //arr[j] = arr[j]^arr[j+1];
19                     //arr[j+1] = arr[j]^arr[j+1];
20                     //arr[j] = arr[j]^arr[j+1];  
21 
22                 }
23 
24             }
25 
26             console.log("第" + (i + 1) + "次排序后的数组是" + arr);
27 
28         }
29 
30     }
31  sort(arr);
32 console.log(arr);

 运行机制如图：

方法（二）

主要还是对方法一的优化，设置一个标志，如果这一趟下来发生了交换，则为true，否则为false。如果有一趟下来没有发生交换，则说明排序已经完成。代码如下：

 1   var arr = [3, 2, 1, 4, 5, 6];
 2     function sort(arr) {
 3         var maxNum = arr.length - 1;
 4         for (var j = 0; j < maxNum; j++) {
 5             // 声明一个变量，作为标志位
 6             var done = true;
 7             for (var i = 0; i < maxNum - j; i++) {
 8                 if (arr[i] > arr[i + 1]) {
 9                     var temp = arr[i];
10                     arr[i] = arr[i + 1];
11                     arr[i + 1] = temp;
12                     done = false;
13                 }
14             }
15             console.log("第" + (i + 1) + "次排序后的数组是" + arr);
16             if (done) {
17                 break;
18             }
19         }
20         return arr;
21     }
22     sort(arr);
23     console.log(arr);

  方法（三）

      是对前两种方式的进一步优化，假如数组长度是30，如果只有前15位是无序排列的，后十五位是有序且都大于前15位，所以第一趟遍历排序的时候发生交换的位置必定小于15，且该位置之后的必定有序，我们只需要排序好该位置之前的就可以，因此我们要来标记这个位置就可以了，代码如下：

    var arr = [3, 2, 1, 4, 5, 6];

    function sort(arr) {
        var n = arr.length;
        var j, k;
        var flag = n;
        while (flag > 0) {
            k = flag;
            flag = 0;
            for (j = 1; j < k; j++) {
                if (arr[j - 1] > arr[j]) {
                    x = arr[j - 1];
                    arr[j - 1] = arr[j];
                    arr[j] = x;
                    flag = j;
                }
            }
        }
    }
    sort(arr);
    console.log(arr);