js实现冒泡，插入，快排算法一纯手工制造

最新推荐文章于 2024-09-16 01:56:04 发布

aoje86881

最新推荐文章于 2024-09-16 01:56:04 发布

阅读量110

点赞数

文章标签：数据结构与算法 javascript ViewUI

原文链接：http://www.cnblogs.com/Tiboo/p/6773267.html

版权

不稳定排序：快速排序，选择排序，堆排序，希尔排序（快选堆希）

稳定排序：插入排序，冒泡排序，归并排序，基数排序（插冒归基）

算法的稳定性判读：排序前2个相等的数在序列中的前后位置顺序与排序后它们两个的前后位置顺序相同

冒泡排序（适用于数据规模很小时）

此案例为从小到大，原理如下：

1 比较相邻元素之间大小，如果前面的值大于后面的值，则交换值的顺序，即小的值放前面（这样得到数组最后一个值为这个数组最大值）

2 上一步操作确定了数组最后一个值为最大值，此时除了最后一个值其他值再次重复步骤1, 依此类推

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>冒泡</title>
</head>
<body>
<script type="text/javascript">
    var arr = [9, 2, 4, 1, 8];
    function bubbleSort(arr) {
        var i = arr.length;
        var j;
        var temp;
        while (i > 0) {
            for (j = 0; j < i - 1; j++) {
                if (arr[j] > arr[j + 1]) {
                    temp = arr[j];
                    arr[j] = arr[j + 1];
                    arr[j + 1] = temp;
                }
            }
            i--;
        }
        return arr;
    }
    var arrSorted = bubbleSort(arr);
    console.log(arrSorted);
    alert(arrSorted);
</script>
</body>
</html>

复杂度计算（即需要比较的次数求和）：

s = (n-1)+ (n-2) + (n-3) + ......+ 1 + 0

偶数项时：

观察第一项加最后一项等于第二项加倒数第二项即等于 n-1

所以s = n(n-1)/ 2

基数项时：

基本规律同上，相加等于n-1的有 (n -1) /2项，除了中间项值为n - ((n-1)/2 + 1)

所以： s = (n -1)(n-1)/ 2 + (n - ((n-1)/2 + 1))

= n(n-1)/2

即s = n(n-1)/ 2

当n足够大时, n(n-1)/ 2 等于n², 由此得出复杂度为 n²

插入排序

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8"/>
    <title>直接插入</title>
    <body>
      <script type="text/javascript" >
        var arr=[5,2,4,6,1,3];
        function insertSort(){
            var key;
            var i;
            for(var j=1;j<arr.length;j++){
                key=arr[j];
                i=j-1;
                while(i>-1&&arr[i]>key){
                    arr[i+1]=arr[i];
                    i=i-1;
                }
                arr[i+1]=key;
                }
            return arr;
            }
        var newsort = insertSort(arr);
        console.log(newsort);
        alert(newsort);
    </script>
</body>
</html>

快速排序

<!DOCTYPE html>
<html>
<head>
    <meta charset="utf-8">
    <title>快排</title>
</head>
<body>
<script type="text/javascript">
    var arr = [90,9,12,6,30,60,36,32,40];
      function quickSort(arr){
        if (arr.length <= 1) { return arr; }
         var pivotIndex = Math.floor(arr.length / 2); //取基值的下标
         var pivot = arr.splice(pivotIndex, 1)[0];    //删除基值后的第一个值，并返回该值
         var left = [];  //定义一个左数组
         var right = [];
         for (var i = 0; i < arr.length; i++){
           if (arr[i] < pivot) {
              left.push(arr[i]); //左边数组
            } else {
              right.push(arr[i]);
             }
         }
        return quickSort(left).concat([pivot], quickSort(right));
      }
        //concat() 方法用于连接两个或多个数组,该方法不会改变现有的数组，而仅仅会返回被连接数组的一个副本。
    var newsort = quickSort(arr);
    console.log(newsort);
    alert(newsort);
</script>
</body>
</html>