Forked from:: bkzen's AS3 sorting algorithm faster than native sorting

forked from: AS3 sorting algorithm faster than native sorting

Add Array / Vector compare and Array.NUMERIC param

forked:0
favorite:0
lines:99
license : MIT License
modified : 2011-04-14 17:39:28

Embed: Tweet

// forked from bkzen's AS3 sorting algorithm faster than native sorting
package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageScaleMode;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.text.TextField;
    import flash.utils.getTimer;
    
    /**
     * Add Array / Vector compare and Array.NUMERIC param
     */
    public class Sorting extends Sprite 
    {
        private var txt: TextField;
        private var tgr: Boolean = true;
        public function Sorting() 
        {
            if (stage) init();
            else addEventListener(Event.ADDED_TO_STAGE, init);
        }
        
        private function init(e: Event = null): void 
        {
            removeEventListener(Event.ADDED_TO_STAGE, init);
            
            stage.align = StageAlign.TOP_LEFT;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            txt = new TextField();
            txt.width = stage.stageWidth > 0 ? stage.stageWidth : 465;
            txt.height = stage.stageHeight > 0 ? stage.stageHeight : 465;
            addChild(txt);
            addEventListener(Event.ENTER_FRAME, loop);
            stage.addEventListener(MouseEvent.CLICK, onClick);
        }
        
        private function onClick(e:MouseEvent):void 
        {
            if (tgr) removeEventListener(Event.ENTER_FRAME, loop);
            else addEventListener(Event.ENTER_FRAME, loop);
            tgr = !tgr;
        }
        
        private function loop(e: Event): void 
        {
            trc();
            var data:Vector.<Number> = new Vector.<Number>(20000);
            var data2:Array = new Array(20000);
            for(var i:int = 0; i<20000; i++){
                var v:Number = Math.random()
                data[i] = data2[i] = v;
            }
            var data3:Vector.<Number> = data.concat();
            var data4:Vector.<Number> = data.concat();
            var t:Number = getTimer();
            data.sort(sf);
            trc("Native Vector sort", (getTimer()-t));
            t = getTimer();
            data.sort(sf);
            trc("Native Vector sort on ordered elements", (getTimer()-t));
            t = getTimer();
            data2.sort(Array.NUMERIC);
            trc("Native Array sort", (getTimer()-t));
            t = getTimer();
            data2.sort(Array.NUMERIC);
            trc("Native Array sort on ordered elements", (getTimer()-t));
            t = getTimer();
            data3.sort(Array.NUMERIC);
            trc("Native Vector sort with Array.NUMERIC", (getTimer()-t));
            t = getTimer();
            data3.sort(Array.NUMERIC);
            trc("Native Vector sort with Array.NUMERIC on ordered elements", (getTimer()-t));
            t = getTimer();
            shellSort(data4);
            trc("AS3 Shell sort", (getTimer()-t));
            t = getTimer();
            shellSort(data4);
            trc("AS3 Shell sort on ordered elements", (getTimer()-t));
        }
        
        private function trc(... args): void
        {
            if (args.length == 0) txt.text = "";
            else txt.appendText(args + "\n");
        }
        
        final private function sf(a: Number, b: Number): int 
        {
            return (a==b ? 0 : (a < b) ? -1 : 1);
        }
        
        final private function shellSort(data: Vector.<Number>): void 
        {
            var n:int = data.length;
            var inc:int = int(n/2);
            while(inc) {
                for(var i:int=inc; i<n; i++) {
                    var temp:Number = data[i], j:int = i;
                    while(j >= inc && data[int(j - inc)] > temp) {
                        data[j] = data[int(j - inc)];
                        j = int(j - inc);
                    }
                    data[j] = temp
                }
                inc = int(inc / 2.2);
            }
        }
    }
}

Code Fullscreen

Preview Fullscreen