js实现常见排序算法

1. 冒泡排序

时间复杂度：O(n) = n²
空间复杂度：O(n) = 1
稳定性：稳定

	function sort(arr) {
	    for (let i = 0; i < arr.length; i++) {
	         let flag = false;
	         for (let j = arr.length - 1; j >= i; j--) {
	             if (arr[j] > arr[j - 1]) {
	                 let temp = arr[j];
	                 arr[j] = arr[j - 1];
	                 arr[j - 1] = temp;
	                 flag = true;
	             }
	         }
	         if(!flag) break
	     }
	     return arr;
	 }

2. 插入排序

时间复杂度：O(n) = n²
空间复杂度：O(n) = 1
稳定性：稳定

	function sort(arr){
        for (let i = 1; i < arr.length; i++){
            let current = arr[i];
            let prevIndex = i - 1;
            while (prevIndex >= 0 && current < arr[prevIndex]) {
                arr[prevIndex + 1] = arr[prevIndex];
                prevIndex--;
            }
            arr[prevIndex + 1] = current;
        }
        return arr;
    }

3. 选择排序

时间复杂度：O(n) = n²
空间复杂度：O(n) = 1
稳定性：不稳定

	 function sort(){
         for (let i = 0; i < arr.length; i++) {
             let minIndex = i;
             for (let j = i + 1; j < arr.length; j++) {
                 if (arr[j] < arr[minIndex]) {
                     minIndex = j;
                 }
             }
             let temp = arr[i];
             arr[i] = arr[minIndex];
             arr[minIndex] = temp;
         }
         return arr;
     }

4. 归并排序

时间复杂度：O(n) = nlogn
空间复杂度：O(n) = n
稳定性：稳定

	function merge(left, right) {
        let result = [];
        while (left.length && right.length) {
            if (left[0] <= right[0]) {
                result.push(left.shift());
            } else {
                result.push(right.shift());
            }
        }
        while (left.length) result.push(left.shift());
        while (right.length) result.push(right.shift());
        return result;
    }

    function sort(arr) {
        if (arr.length < 2) return arr;
        let middle = Math.floor(arr.length / 2);
        let left = arr.slice(0, middle);
        let right = arr.slice(middle, arr.length);
        let sortLeft = sort(left);
        let sortRight = sort(right);
        return merge(sortLeft, sortRight)
    }

5. 快速排序

时间复杂度：O(n) = nlogn
空间复杂度：O(n) = n
稳定性：不稳定

	function sort(arr){
        if(arr.length < 2) return arr;
        let pivotIndex = Math.floor(arr.length / 2);
        let pivot = arr.splice(pivotIndex, 1)[0];
        let left = [];
        let right = [];
        for (let i = 0; i < arr.length; i++){
            if(arr[i] < pivot){
                left.push(arr[i]);
            }else {
                right.push(arr[i]);
            }
        }
        return sort(left).concat([pivot], sort(right));
    }