[转]10万个浮点数排序 算法效率

http://bbs.9ria.com/viewthread.php?tid=75306&extra=page%3D1%26amp;orderby%3Ddateline%26amp;filter%3D2592000

呵呵,lz要去搜搜排序算法了.
自带的sort确实比冒泡,插入这些简单排序算法快.但不如一些高级排序(如快排,希尔,堆排,归并等)

另外排序和浮动数有什么关系,不知道面试官搞什么的?
他说的分开来排序应该是归并排序吧


数组长了，占内存大了，理论上来讲排序时每push一次耗时会增大。分成多个的话，push能节省时间。但是按什么分？按大小分的话还得做几十万次比较和更多次的push。根据不同的测试环境来说。。动态内存的时间损耗和浮点数大小比较的时间损耗又可能不同。

10万个，我机器上用sort测试，直接卡死。1万个勉强能跑下
只要不卡死就赢了。

在我的测试环境，测试两组1万个排序的结果，是分开排序快一些。如下代码

1万个随机数生成

var i=0
var arr=[]
for(i=0;i<10000;i++){
        arr[i]=Math.random()
}
复制代码
直接sort  2668ms
var t=getTimer()
var arr_=arr.sort()
trace(getTimer()-t)   //2668ms   
复制代码
分块sort  2194ms
var arr1=[]
var arr2=[]
var arr3=[]
var arr4=[]
var arr5=[]

for(i=0;i<10000;i++){
        var temp=arr[i]
        if(temp<.2){
                arr1.push(temp)
        }else if(temp<.4){
                arr2.push(temp)
        }else if(temp<.6){
                arr3.push(temp)
        }else if(temp<.8){
                arr4.push(temp)
        }else{
                arr5.push(temp)
        }
}

arr1.sort()
arr2.sort()
arr3.sort()
arr4.sort()
arr5.sort()

var arr_=arr1.concat(arr2).concat(arr3).concat(arr4).concat(arr5)
trace(getTimer()-t)     //2194

复制代码
我写了这么多字。能坚持看完的话就给我加点银子吧






没测试过怎么会乱说呢.

package  
{
        import flash.display.Sprite;
        import flash.text.TextField;
        import flash.utils.getTimer;
        import flash.events.*;
        /**
         * ...
         * @author ff
         */
        public class main2 extends Sprite
        {
                
                
                public function main2() 
                {
                 
                  stage.addEventListener("click", onClick);
             
                }
                
                private function onClick(e:MouseEvent):void {
                        sortTest();
                }
                
                
                private function sortTest():void {//各种排序效率测试
                        var tArr:Array = new Array();
                        var qArr:Array = new Array();
                        var iArr:Array = new Array();
                        var sArr:Array = [];
                        var gArr:Array = [];
                        var hArr:Array = [];
                        var ppArr:Array = [];
                        var selectArr:Array = [];
                        //数组的长度
                        var testLength:int = 100000;
                    //让各个数组元素随机
                        for (var i:int = 0; i <testLength; i++) {
                                var ran:int = int(Math.random() * testLength);
                                //trace("ran",ran);
                                tArr.push(ran);
                                qArr.push(ran);
                                iArr.push(ran);
                                sArr.push(ran);
                                gArr.push(ran);
                                hArr.push(ran);
                                ppArr.push(ran);
                                selectArr.push(ran);
                        }
                        var d1:int;
                        
                        
            
                        
                        /*d1 = getTimer();
                        insertSort(iArr,0,iArr.length-1);//插入
                        trace("插入排序","排列",testLength," 时间: ",getTimer() - d1);
                        
                        d1 = getTimer();
                        ppSort(ppArr);//冒泡
                        trace("冒泡排序", "排列", testLength, " 时间: ", getTimer() - d1);
                        */
                        d1 = getTimer();
                        qSort(qArr,0,qArr.length-1);//快速排序
                        trace("快速排序","排列",testLength," 时间: ",getTimer() - d1);
                        
                        d1 = getTimer();
                        shlSort(sArr,sArr.length);//希尔
                        trace("希尔排序","排列",testLength," 时间: ",getTimer() - d1);
                        
                        d1 = getTimer();
                        MgbSort(gArr,0,gArr.length-1);//归并，比希尔慢一些但他是稳定的
                        trace("归并排序","排列",testLength," 时间: ",getTimer() - d1);
                        //trace(gArr);
                        
                     d1 = getTimer();
                        tArr.sort();
                        trace("数组自带排序","排列",testLength," 时间: ",getTimer() - d1);
                }
                private function ppSort(data:Array):void {
                        var len:int = data.length;
                        var temp:int = 0;
                        for (var i:int = 0; i < len; i++) {
                                for (var j:int = len-1; j >= i; j--) {
                                        if (data[j] > data[j - 1]) {
                                                temp = data[j];
                                                data[j] = data[j - 1];
                                                data[j - 1] = temp;
                                        }
                                }
                        }
                }
                private function selectSort(data:Array):void {
                        var len:int = data.length;
                        var tempId:int;
                        var temp:int;
                        while (--len) {
                                tempId = len - 1;
                                for(var i:int=len-2;i>=0;i--){        
            if(data[i]>data[tempId]){ //如果大于,把这个索引变最大值索引
                                tempId=i;                
                        }
                }
                //最后把最大的和最后一个交换.同时在while条件中把length减一
                if(tempId!=len-1){
                temp=data[tempId];
                data[tempId]=data[len-1];
                data[length-1]=temp;
                }
        
                        }
                }
                private function qSort(data:Array, left:int, right:int):void {
           var min:int=left;
        var max:int=right;

        var key:int=data[left];
        var temp:int;
        while (true) {        
        while(min<max&&data[max]>=key){
         max--; 
        }
        while(min<max&&data[min]<=key){
     min++;
        }
        
        if(min<max){
                temp=data[min];
                data[min]=data[max];
                data[max]=temp;
          
        }else{//min=＝max 结束循环
                break;
        }
        }
        data[left]=data[min];
        data[min]=key;
        if(min-1>left){
     qSort(data,left,min-1);
        }
        if(max+1<right){
     qSort(data,max+1,right); 
    }
                }
                
        private function insertSort(a:Array,start:int,n:int):void {
                for(var i:int = start-1; i < n; i++)
        {
        var temp:int= a[i];
        for (var j:int = i; j > start && temp < a[j - 1]; j--)
        {
         a[j] = a[j - 1];
                        }
          a[j] = temp;
                }
        }
        private function shlSort(p:Array,n:int):void {
                var k:int;
                var i:int;
                var j:int;
            var t:int;
        k=n/2;        
        while(k>0)                
        {                
                for(j=k;j<=n-1;j++)                        
                {                        
                        t=p[j];i=j-k;                        
                        while((i>=0)&&(p[i]>t))                                
                        {                                
                                p[i+k]=p[i];i=i-k;                        
                        }                        
                        p[i+k]=t;                        
                }
                k=k/2;                
        }        
        
        }
        
        private function gbSort(data:Array, left:int, right:int):void {
                var  len:int = (right - left) + 1;
                var center:int = len/2 + left;
                var tempData:Array = [];
                var index:int = 0;
                var i:int;
                var d1Index:int=left;
                var d2Index:int = center;//搞了半天，这里的center错写成right了.苦啊
    while(d1Index<center&&d2Index<=right){
                
                if(data[d1Index]>data[d2Index]){
        tempData[index++]=data[d2Index++];
                }else{
        tempData[index++]=data[d1Index++];
                }        
        }
        
        while(d1Index<center){
      tempData[index++] = data[d1Index++];
         
        }

        while(d2Index<=right){//同上
                tempData[index++] = data[d2Index++];
                
        }
        for(i=0;i<len;i++){
                data[left+i]=tempData[i];
        }        
        }
        private function MgbSort(a:Array,left:int,right:int):void{
        if (left < right)
        {
                var center:int = left+(right-left+1) / 2;//取得中点
                //将原来序列分为两段
                MgbSort(a, left, center-1);
                MgbSort(a, center, right);
                //合并刚才分开的两段，得到原来序列的有序序列
                //trace("center",center);
                gbSort(a,left,right);
        }
        }
        }

}

点击鼠标就可以输出结果了,简单排序注释了,因为非常慢(你可以试试).
debug测试和release测试得的结果是不一样的,最终效率当然以release为准.
想看到release的结果请自己加一个txt让结果显示出了.

release模式下,sort比其他几个高级排序慢10倍或者以上