JavaScript 排序演算法(O log(N)等)

常見演算法方法

/* 轉換位置 */
const swap = (array, i, j) => {
	[arr[i], arr[j]] = [arr[j], arr[i]]
}
/* 拷貝陣列 */
const copyArray = (arr) => {
	return [...arr];
}
複製程式碼

測試方法

/**
* @description 生成指定期間的陣列
* @param {Num} arrayNumber 陣列數量
* @param {Num} min 最小數
* @param {Num} max 最大數
* @return {number[]} return 陣列
*/
const getRandomArray = (arrayNumber, min, max) => {
	const array = [],
		  range = max - min;
	for(let i=0; i<arrayNumber; i++) {
		let rand = Math.random();
		array[i] = min + Math.round(rand * range); 
	}
	return array;
}
// 獲取50000個陣列的方法
const arr = getRandomArray(50000, 0, 50000)
複製程式碼

演算法

原生排序(JavaScriptSort: 34.169921875ms)

jsArray.sort((a,b) => a-b)
複製程式碼

插入排序(insertSort: 9178.899169921875ms)

let insertArray = copyArray(arr);
function insertSort(arr) {
	for(let i=1; i<arr.length; i++) {
		for(let j=i; j>0 && arr[j] < arr[j-1]; j--) {
			swap(arr, j-1, j);
		}
	}
	return arr
}
複製程式碼

插入排序優化版(intensifyInsertSort: 1308.403076171875ms)

let intensifyInsertArray = copyArray(arr);
function intensifyInsertSort(arr) {
	for(let i=1; i<arr.length; i++) {
		let temp = arr[i], j;
		for(j=i; j>0 && arr[j-1] > temp; j--) {
			arr[j] = arr[j-1]
		}
		arr[j] = temp;
	}
	return arr
}
複製程式碼

選擇排序(selectSort: 2222.005126953125ms)

let selectArray = copyArray(arr);
function selectSort(arr) {
	let minIndex;
	for(let i=0; i<arr.length-1; i++){
		minIndex = i;
		for(let j=i+1; j<arr.length; j++) {
			if(arr[minIndex] > arr[j]) {
				minIndex = j
			}
		}
		swap(arr, i, minIndex);
	}
	return arr;
}
複製程式碼

氣泡排序(bubbleSort: 10552.420166015625ms)

let bubbleArray = copyArray(arr);
function bubbleSort(arr) {
	for(let i=0; i<arr.length-1; i++) {
		for(let j=i+1;j<arr.length;j++) {
			if(arr[i] > arr[j]) {
				swap(arr, i, j)
			}
		}
	}
	return arr
}
複製程式碼

歸併排序(mergeSort: 28.73095703125ms)

let mergeSortArray = copyArray(arr);
function merge(arr, l, mid, r) {
	let i = l, j = mid+1, newArr = arr.slice(l, r+1);
	for(let m = l; m<=r; m++) {
		if(i > mid) {
			arr[m] = newArr[j-l]
			j++;
		} else if(j > r) {
			arr[m] = newArr[i-l]
			i++;
		} else if(newArr[i-l] < newArr[j-l]) {
			arr[m] = newArr[i-l]
			i++;
		} else {
			arr[m] = newArr[j-l]
			j++;
		}
	}
}

function mergeSortEvent(arr, l, r) {
	if(l >= r) return;
	
	let mid = Math.floor((l + r) / 2);
	mergeSortEvent(arr, l, mid);
	mergeSortEvent(arr, mid+1, r);
	merge(arr, l, mid, r);
	
}

function mergeSort(arr) {
	mergeSortEvent(arr, 0, arr.length-1)
}
複製程式碼

歸併排序優化版(intensifyMergeSort: 25.60986328125ms)

let intensifyMergeArray = copyArray(arr);
function intensifyMerge(arr, l, mid, r) {
	let i = l, j = mid+1, newArr = arr.slice(l, r+1);
	for (let m = l; m<=r; m++) {
		if (i > mid) {
			arr[m] = newArr[j-l]
			j++;
		} else if (j > r) {
			arr[m] = newArr[i-l]
			i++;
		} else if (newArr[i-l] < newArr[j-l]) {
			arr[m] = newArr[i-l]
			i++;
		} else {
			arr[m] = newArr[j-l]
			j++;
		}
	}
}

function intensifyMergeEvent(arr, l, r) {
	if (l >= r) return;
	
	let mid = Math.floor((l + r) / 2);
	intensifyMergeEvent(arr, l, mid);
	intensifyMergeEvent(arr, mid+1, r);
	
	if (arr[mid] > arr[mid+1]) {
		intensifyMerge(arr, l, mid, r);
	}
}

function intensifyMergeSort(arr) {
	intensifyMergeEvent(arr, 0, arr.length-1)
}
複製程式碼