1. 冒泡排序 (Bubble Sort)

冒泡排序是一种简单的排序算法，它重复地遍历待排序的数组，比较相邻元素并交换顺序错误的元素。每次遍历后，最大的元素“冒泡”到数组的末尾。

function bubbleSort(arr) {
	const 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]) {
		 		// 交换                
		 		[arr[j], arr[j + 1]] = [arr[j + 1], arr[j]];
		 	}
		 }
	}
	return arr;
}

2. 选择排序 (Selection Sort)

选择排序是一种简单直观的排序算法。它的基本思想是每一轮从未排序部分选择最小或最大的元素，将其放到已排序部分的末尾。

function selectionSort(arr) {    
	const len = arr.length;    
	for (let i = 0; i < len - 1; i++) {        
		let minIndex = i;       
		for (let j = i + 1; j < len; j++) {            
			if (arr[j] < arr[minIndex]) {                
				minIndex = j;            
			}        
		}        
		// 交换        
		[arr[i], arr[minIndex]] = [arr[minIndex], arr[i]];    
	}    
	return arr;
}

3. 插入排序 (Insertion Sort)

插入排序是一种简单且有效的排序算法。它通过构建一个有序子序列，将未排序元素逐一插入到该序列中。

function insertionSort(arr) {    
	const len = arr.length;    
	for (let i = 1; i < len; i++) {        
		const key = arr[i];        
		let j = i - 1;        	
		while (j >= 0 && arr[j] > key) {            
			arr[j + 1] = arr[j];            
			j--;        
		}        
		arr[j + 1] = key;    
	}    
	return arr;
}

4. 快速排序 (Quick Sort)

快速排序是一种高效的排序算法，采用分治法策略。它通过选取一个“基准”元素，将数组分为两个部分，一部分比基准小，另一部分比基准大，然后递归排序这两个部分。

function quickSort(arr) {    
	if (arr.length <= 1) return arr;        
	const pivot = arr[arr.length - 1];    
	const left = [];    
	const right = [];        
		for (let i = 0; i < arr.length - 1; i++) {        
			if (arr[i] < pivot) {            
				left.push(arr[i]);        
			} else {            
				right.push(arr[i]);        
			}    
		}        
	return [...quickSort(left), pivot, ...quickSort(right)];

}

5. 归并排序 (Merge Sort)

归并排序是一种利用分治法的排序算法。它将数组分成两半，分别对这两半进行排序，然后将排序后的两半合并在一起。

function mergeSort(arr) {    
	if (arr.length <= 1) return arr;    
	const mid = Math.floor(arr.length / 2);    
	const left = mergeSort(arr.slice(0, mid));    
	const right = mergeSort(arr.slice(mid));        
	return merge(left, right);
}
function merge(left, right) {    
	const result = [];    
	let i = 0, j = 0;    
	while (i < left.length && j < right.length) {        
		if (left[i] < right[j]) {            
			result.push(left[i]);            
			i++;        
		} else {            
			result.push(right[j]);            
			j++;        
		}    
	}    
	return result.concat(left.slice(i)).concat(right.slice(j));
}