排序算法（js實現）

1. 冒泡排序：兩兩比較，遍歷一趟會挑出最大的值放在最後。

function bubbleSort(arr) {
	var len = arr.length;
	for (let i = 0; i < len-1; i++) {
		for (let j = 0; j < len-1-i; j++) {
			if (arr[j] > arr[j+1]) {
				var temp = arr[j+1];
				arr[j+1] = arr[j];
				arr[j] = temp;
			}
		}
	}
	return arr;
}

2. 選擇排序：從頭至尾掃描序列，每次找出最小的一個元素，和第一個元素交換，接着從剩下的元素中繼續這種選擇和交換方式，最終得到一個有序序列。

function selectSort(arr) {
	var len = arr.length;
	var minIndex, tmp;
	for(let i = 0; i < len-1; i++) {
		minIndex = i;
		for(let j = i+1; j < len; j++) {
			if (arr[minIndex] > arr[j]) {
				minIndex = j;
			}
		}
		tmp = arr[minIndex];
		arr[minIndex] = arr[i];
		arr[i] = tmp;
	}
	return arr;
}

3. 插入排序：將數組的第一個數認爲是有序數組，從後往前掃描該有序數組，把數組中其餘n-1個數，根據數值的大小，插入到有序數組中，直至數組中的所有數有序排列爲止。這樣的話，n個元素需要進行n-1趟排序！！

function insertionSort(arr) {
	var len = arr.length;
	var current, preIndex;
	for(let i = 1; i < len; i++) {
		current = arr[i];
		preIndex = i - 1;
		while (preIndex >= 0 && arr[preIndex] > current) {
			arr[preIndex + 1] = arr[preIndex];
			preIndex--;
		}
		arr[preIndex+1] = current;
	}
	return arr;
}

4. 歸併排序: 該算法是採用分治法。將已有序的子序列合併，得到完全有序的序列；即先使每個子序列有序，再使子序列段間有序。若將兩個有序表合併成一個有序表，稱爲二路歸併。歸併排序是一種穩定的排序方法。

function mergeSort(arr) {
	var len = arr.length;
	if(len < 2) {
		return arr;
	}
	var middle = Math.floor(len / 2),
	    left = arr.slice(0, middle),
	    right = arr.slice(middle);
	return merge(mergeSort(left), mergeSort(right));
}
function merge(left, right) {
	var result = [];
	while (left.length && right.length) {
		if(left[0] <= right[0]) {
			result.push(left.shift());
		}else {
			result.push(right.shift());
		}
	}
	if(left.length) {
		result = result.concat(left)
	}
	if(right.length) {
		result = result.concat(right)
	}
	return result;
}

6. 快速排序：
   ①先從隊尾開始向前掃描且當left < right 時,如果arr[right] > pivot ,則right–,但如果arr[right] < pivot,則將right的值賦值給left,同時要轉換數組掃描的方式,即需要從隊首開始向隊尾進行掃描了
     ②同理,當從隊首開始向隊尾進行掃描時,如果arr[right] < pivot,則left++,但如,即arr[low] = arr[high],同時將數組掃描方式換爲由隊尾向隊首進行掃描.
     ③重複①和②,直到 left>=right時(其實是left=right),left或right的位置就是該哨兵在數組中的正確索引位置。

function quickSort(arr, left, right) {
	if(left < right) {
		var index = partition(arr, left, right);
		quickSort(arr, 0, index-1);
		quickSort(arr, index+1, right);
		return arr;
	}
}
function partition(arr, left, right) {
	var pivot = arr[left];
	while(left < right) {
	    // 這裏需要考慮數組中有兩個數相等的情況，如果沒有考慮的話，會出現死循環。
		while (left < right && arr[right] >= pivot) {
			right--;
		}
		arr[left] = arr[right];
		while (left < right && arr[left] <= pivot) {
			left++;
		}
		arr[right] = arr[left];
	}
	arr[left] = pivot;
	return left;
}
var arr = [2, 10, 4, 1, 0, 9, 5, 2];
console.log(quickSort(arr, 0, arr.length - 1));

7. 希爾排序：插入排序的一種更高效的實現。

function shellSort(arr) {
		var preIndex, val;
		var len = arr.length;
		var gap = Math.floor(len/2),
		    val;
		for(gap; gap > 0; gap = Math.floor(gap/2)) {
			for(let i = gap; i < len; i++) {
				val = arr[i];
				for(var j = i-gap; j>=0 && arr[j] > val; j-=gap) {
					arr[j+gap] = arr[j];
				}
				arr[j+gap] = val;
			}
		}
		return arr;
	}