今天覆習了歸併和快排，突然想計算一下他們的速度差別到底有多大～結果還是挺令人意外的，哈哈。

話不多說，看程式碼。

	let arr = [];
	for (let i = 0; i < 500000; i++) {
	    arr.push(Math.round((Math.random() * 1000)));
	}
	let start = new Date().getTime();
	
	/**
	 * 快速排序
	 */
	function quickSort(arr) {
	
	    if (arr.length <= 1) {
	        return arr;
	    }
	
	    let mid = arr.length >> 1;
	    let midValue = arr.splice(mid, 1);
	    let left = [];
	    let right = [];
	
	    for (let i = 0; i < arr.length; i++) {
	        if (arr[i] < midValue) {
	            left.push(arr[i]);
	        } else {
	            right.push(arr[i]);
	        }
	    }
	
	    return quickSort(left).concat(midValue, quickSort(right));
	}
	
	/**
	 * 歸併排序
	 */
	function mergeSort(arr) {
	    function part(arr, left, right) {
	        if (left == right) {
	            return;
	        }
	        let mid = left + ((right - left) >> 1);
	
	        part(arr, left, mid);
	        part(arr, mid + 1, right);
	
	        let p1 = left;
	        let p2 = mid + 1;
	        let cache = [];
	        let i = 0;
	        while (p1 <= mid && p2 <= right) {
	            cache[i++] = arr[p1] < arr[p2] ? arr[p1++] : arr[p2++];
	        }
	
	        while (p1 <= mid) {
	            cache[i++] = arr[p1++];
	        }
	
	        while (p2 <= right) {
	            cache[i++] = arr[p2++];
	        }
	
	        for (let i = 0; i < cache.length; i++) {
	            arr[left + i] = cache[i];
	        }
	
	        return arr;
	    }
	
	    return part(arr, 0, arr.length - 1);
	}
	
	
	/**
	 * 驗證
	 */
	console.log(`結果：[${quickSort(arr)}]`);
	let end = new Date().getTime();
	console.log(`用時：${end - start}毫秒`);
 

結果

• 在陣列僅有100項的時候 快排： 歸併： 不相上下啊哈哈啊，那麼我們直接上二十萬項的陣列～

• 陣列200000項： 快排： 九秒多！ 來看看可愛的歸併： 兩秒！ 差距這麼大的嗎？

驚不驚喜，意不意外！ 話說回來或許是這次我使用的快排太浪費空間，下次換個好用的試試～

From Raool