【Js】排序算法

先上代码：

View Code 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
<head>
    <meta http-equiv="Content-Type" content="text/html;charset=UTF-8" />
    <title></title>
    <script type="text/javascript">
    window.onload = function(){

    function bubbleSort(arr){   //冒泡排序
        var len = arr.length;
        for(var i = 0; i < len; i++){
            for(var j = 0; j < len - i; j++){
                if(arr[j] > arr[j+1]){
                    arr[j] = [arr[j+1], arr[j+1] = arr[j]][0];
                }
            }
        }
        return arr;
    }


    function selectorSort(arr){  //选择排序
        var len =  arr.length;
        var min;
        for(var i = 0; i < len; i++){
            min = i;
            for(var j = i+1; j < len; j++){
                if(arr[min] > arr[j]){
                    min = j;
                }
            }
            if(min != i){
                arr[min] = [arr[i], arr[i] = arr[min]][0];
            }
        }
        return arr;
    }

    function quickSort(arr){   //快速排序
        var len = arr.length;
        if(len <= 1){
            return arr;
        }

        var num = Math.floor(len/2);
        var numValue = arr.splice(num, 1)[0];  //splice返回数组 取第一个值
        var left = [];
        var right = [];

        for(var i = 0; i < arr.length; i++){   //这边不能用 len 因为上面splice 改变了数组的长度
            arr[i] < numValue? left.push(arr[i]) : right.push(arr[i]);
        }

        return quickSort(left).concat([numValue], quickSort(right));  //这个返回的是新数组， 因为他是新数组连接成的 原数组不变
    }

        var a = [6,54,6,22,5,7,8,2,34];
        // bubbleSort(a); 
        // console.log(a);  

        // selectorSort(a); 
        // console.log(a);   

       var xx = quickSort(a); 
        console.log(xx);  
    }
    </script>
</head>
<body>
</body>
</html>

 1.冒泡排序：每次都选最大的元素放后面。

1 for(var i = 0; i < len; i++){   //数组有几个元素就循环几次
2     for(var j = 0; j < len - i; j++){    //内嵌循环
3         if(arr[j] > arr[j+1]){      //比较大小
4             arr[j] = [arr[j+1], arr[j+1] = arr[j]][0];  //交换位置
5         }
6     }
7 }

 

依次减少内嵌循环次数(len -i)， 因为第一次循环最大的放在最后一个， 第二次循环就不需要管最后一个了。

 

2.选择排序：每次都选择最小的元素放前面。

 1 for(var i = 0; i < len; i++){
 2     min = i; //用第i个元素作为初始比较对象
 3     for(var j = i+1; j < len; j++){ //依次减少循环次数 从第（i+1）个开始
 4         if(arr[min] > arr[j]){  // 比较元素
 5             min = j;     //获取最小元素的下标
 6         }
 7     }
 8     if(min != i){
 9         arr[min] = [arr[i], arr[i] = arr[min]][0]; //交换位置
10     }
11 }

 

 

因为要比较的初始对象是 (min = i), 所以和他比较的就是他的下一个，所有从（j = i + 1）开始。

 

3.快速排序：从数组中找出个基准点（比较对象），比它大的放一个数组，比它小的放一个数组，最后连接数组。

 1 function quickSort(arr){   //快速排序
 2     var len = arr.length;
 3     if(len <= 1){return arr;} //如果数组长度为1 就不需要比较了
 4 
 5     var num = Math.floor(len/2); //取中间位置下标
 6     var numValue = arr.splice(num, 1)[0];  //splice返回数组 取第一个值，这边会改变原本的数组。
 7     var left = [];
 8     var right = [];
 9 
10     for(var i = 0; i < arr.length; i++){   //这边不能用 len 因为上面splice 改变了数组的长度
11         arr[i] < numValue? left.push(arr[i]) : right.push(arr[i]);
12     }
13 
14     return quickSort(left).concat([numValue], quickSort(right));  //这个返回的是新数组， 因为他是新数组连接成的 原数组不变
15 }
16 　　var a = [6,54,6,22,5,7,8,2,34];
17 　　var xx = quickSort(a);   //注意调用。
18 　　console.log(xx);

 

splice()返回的是一个数组，通过splice(num,1)[0];取得数组元素

concat（arrX,arrY）中的参数是 数组， 所以要把中间元素转为一个数组 [numValue]

注意：调用这个函数的时候，因为最终返回的数组是通过连接 left, right和中间元素，所以返回的是一个新的数组，并不是原本的数组。

posted @ 2013-01-07 11:57  ic-  阅读(204)  评论(0)    收藏  举报