排序算法之冒泡排序

冒泡排序应该是大家比较熟悉的排序方法之一，但是确是一个效率不是太高的排序算法，特别是面对大数据集的时候。

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,这样一趟过去后,最大或最小的数字被交换到了最后一位,然后再从头开始进行两两比较交换,直到倒数第二位时结束,接下来的操作类似，看例子如下：

例子为从小到大排序,

原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |

第一趟排序(外循环)

第一次两两比较6 > 2交换(内循环)

交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |

第二次两两比较,6 > 4交换

交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |

第三次两两比较,6 > 1交换

交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |

第四次两两比较,6 > 5交换

交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第五次两两比较,6 < 9不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二趟排序(外循环)

第一次两两比较2 < 4不交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |

交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |

第二次两两比较,4 > 1交换

交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第四次两两比较,5 < 6不交换

交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

第三趟排序(外循环)

第一次两两比较2 > 1交换

交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第二次两两比较,2 < 4不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第三次两两比较,4 < 5不交换

交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |

第四趟排序(外循环)无交换

第五趟排序(外循环)无交换

排序完毕,输出最终结果1 2 4 5 6 9

javascript实现的的代码如下：

<html>
<head>
    <title>Date Example</title>
</head>
<body>
<div id="content"></div>

<script type="text/javascript">
     function CArray (numElements){
         this.dataStore = [];
         this.pos = 0;
         this.numElements = numElements;

         this.insert = function (element){
             this.dataStore[this.pos++] = element;
         };

         this.toString = function (){
             var restr = "";
             for (var index = 0; index < this.dataStore.length; ++index){
                restr += this.dataStore[index] + " ";
                if (index > 0 && index % 10 == 0){
                    restr += "\n";
                }

                
             }
             return restr;
         };

         this.clear = function (){
             for (var index = 0; index < this.dataStore.length; ++index){
                this.dataStore[index] = 0;
             }
         };

         this.setData = function (){
             for (var index = 0; index < this.numElements; ++index){
                this.dataStore[index] = Math.floor(Math.random() * (this.numElements + 1));
             }
         };

         this.swap = function (arr, index1, index2){
            var tempData = arr[index1];
            arr[index1] = arr[index2];
            arr[index2] = tempData;
         };

        //   冒泡排序
         this.bubbleSort = function (){

             var numLength = this.numElements;
             for (var outer = numLength; outer >= 2; --outer){
                 for (var inner = 0; inner <= (numLength -1); ++inner){
                      if (this.dataStore[inner] > this.dataStore[inner + 1]){
                          this.swap(this.dataStore, inner, (inner + 1));
                      }
                 }

                 console.log(this.toString());     //   查看排序过程
             }
         };
     }

     var numElements = 10;
     var myNums = new CArray(numElements);
     myNums.setData();
     console.log(myNums.toString());
     myNums.bubbleSort();
     console.log(myNums.toString());
</script>
</body>
</html>

参考：http://www.cnblogs.com/kkun/archive/2011/11/23/2260280.html

来源：https://www.cnblogs.com/duhuo/p/5090234.html

标签

冒泡排序

排序算法