[alexcon314]

Мои результаты таковы:

package 
{
	import flash.display.Sprite;
	import flash.events.TimerEvent;
	import flash.text.TextField;
	import flash.text.TextFieldAutoSize;
	import flash.utils.getTimer;
	import flash.utils.Timer;
 
 
	public class Main extends Sprite 
	{
		private const N:int = 10;
		private const D:int = 1000;
		private const C:int = 1;
		private var timer:Timer;
		private var tf:TextField = new TextField();
		private var store:int = 0;
		private var array:Array = [];
		public function Main() 
		{
 
			var sprite:Sprite; 
			for (var j:int = 0; j < 100000; j++) 
			{
				sprite = new Sprite();
				array[j] = sprite;
			} 
			tf.autoSize = TextFieldAutoSize.LEFT;
			addChild(tf);
			timer = new Timer(D, C);
			timer.addEventListener(TimerEvent.TIMER, test);
			timer.addEventListener(TimerEvent.TIMER_COMPLETE, result);
			timer.start();
		}
 
		private function result(e:TimerEvent):void {	
			tf.appendText( "\ntime (avg): " + store / C);
			timer.stop();
		}
		private function test(e:TimerEvent):void 
		{	
			tf.text = "Current tick: " + timer.currentCount;
			//nativeTest();
			mergeTest();
		}
		private function shuffleArray():void
		{
			var sprite:Sprite; 
			for (var j:int = 0; j < 100000; j++) 
			{
				(array[j] as Sprite).x = roundRandom();
			} 
		}
		private function nativeTest():void
		{
			var i:int;
			var t:Number;
 
			for (i = 0, t = getTimer(); i < N; i++) { shuffleArray(); array.sortOn('x', Array.NUMERIC);}
			store += (getTimer() - t);
 
		}
 
		private function mergeTest():void
		{
 
			var i:int;
			var t:Number;
 
			for (i = 0, t = getTimer(); i < N; i++){ shuffleArray();defaultSort(array, comparator);}
			store += (getTimer() - t);
 
 
		} 
		private function defaultSort(array:Array, companator:Function):void
		{
			var length:int = array.length;
 
			var result:Array = array;
			var buffer:Array = new Array(length);
			var temp:Array;
 
			var bufferPointer:uint;
			var leftPointer:int;
			var rightPointer:int;
 
			var sectionSize:int = 1;
 
			var leftSectionStart:uint;
			var leftSectionFinish:uint;
 
			var rightSectionStart:uint;
			var rightSectionFinish:uint;
 
			while (sectionSize < length)
			{
				bufferPointer = 0;
				leftSectionStart = 0;
 
				while (leftSectionStart < length)
				{
					rightSectionStart = leftSectionStart + sectionSize;
					rightSectionFinish = rightSectionStart + sectionSize;
 
					if (length < rightSectionFinish)
					{
						rightSectionFinish = length;
 
						if (length < rightSectionStart)
								rightSectionStart = length;
					}
 
					leftSectionFinish = rightSectionStart;
 
					leftPointer = leftSectionStart;
					rightPointer = rightSectionStart;
 
					while (leftPointer - leftSectionFinish & rightPointer - rightSectionFinish)
					{
						if (companator(array[leftPointer], array[rightPointer]) == -1)
								buffer[bufferPointer++] = array[leftPointer++];
						else
								buffer[bufferPointer++] = array[rightPointer++];
					}
 
					while (leftPointer < leftSectionFinish)
							buffer[bufferPointer++] = array[leftPointer++];
 
					while (rightPointer < rightSectionFinish)
							buffer[bufferPointer++] = array[rightPointer++];
 
					leftSectionStart += sectionSize << 1;
				}
 
				temp = array;
				array = buffer;
				buffer = temp;
 
				sectionSize <<= 1;
			}
 
			if (result !== array)
			{
				var i:int;
				while (i < length)
						result[i] = array[i++];
			}
		}
		private function comparator(a:Sprite, b:Sprite):int
		{
			if (a.x < b.x) return -1;
			if (a.x > b.x) return 1;
			return 0;
		}
		private function roundRandom():int
		{
			return Math.random() * 10;
		}
		private static function random():Number
		{
			return Math.random() * 10;
		}
 
	}
}

//FP 11.7 release
//Flex 4.6 FD 4.4.3
//Build: Release
//Win 7 Pro x64 Core i3 6Gb
//N = 10, D = 1000, C = 10

//nativeTest (84 Mb )
Current tick: 10
time (avg): 20432.2

//mergeTest (132 Mb)
Current tick: 10
time (avg): 7483.9

Память взята в диспетчере задач после выполнения тестов.
Выводы предлагается сделать самостоятельно.