排序

排序：

1、快排

• 平均时间复杂度为O(nlogn)
• 最坏时间情况下 O(n2)
• 空间复杂度O(1)
• 不稳定

//递归
function quicksort(arr, l, r) {
    if (l < r) {
        let i = sort(arr, l, r)
        quicksort(arr, l, i-1)
        quicksort(arr, i+1, r)
    }
   
}

function sort(arr, head, end) {
    let key = arr[head];
    let i = head;
    let j = end;
    while(i<j) {
        while(i<j&& arr[j]>=key) {
            j--;
        }
        while(i<j && arr[i] <= key) {
            i++;
        }
        
        
        if(i!=j) {
            swap(arr, i,j)
        }
    }
    swap(arr, head, i)
    return i
}

function swap (arr, i, j) {
    let key = arr[i]
    arr[i] = arr[j]
    arr[j] = key
}

// 循环
function quicksort(arr) {
    const stack = []
    stack.push(0)
    stack.push(arr.length-1)
    while(stack[stack.length - 1]>=0) {
    let end = stack.pop()
    let start = stack.pop()
    let i = sort(arr, start, end)
    if (i - 1>start) {
        stack.push(start)
        stack.push(i-1)
    }
    if(i+1<end) {
        stack.push(i+1)
        stack.push(end)
    }
    }
}
function sort(arr, head, end) {
    let key = arr[head];
    let i = head;
    let j = end;
    while(i<j) {
    //必须从右边开始，也就是从基准数的对面开始。
        while(i<j&& arr[j]>=key) {
            j--;
        }
        while(i<j && arr[i] <= key) {
            i++;
        }
        
        
        if(i!=j) {
            swap(arr, i,j)
        }
    }
    swap(arr, head, i)
    return i
}

function swap (arr, i, j) {
    let key = arr[i]
    arr[i] = arr[j]
    arr[j] = key
}

2、插入排序

• 平均时间复杂度为O(n2)
• 最坏时间情况下 O(n2)
• 空间复杂度O(1)
• 稳定

function insertSort(arr) {
    for (let i = 1; i < arr.length; i++) {
        let key = arr[i]
        for (let j = i - 1; j >= 0; j--) {
            if (arr[j] > key) {
                arr[j + 1] = arr[j]
                arr[j] = key
            }
        }
    }
}

3、冒泡

• 平均时间复杂度为O(n2)
• 最坏时间情况下 O(n2)
• 空间复杂度O(1)
• 稳定

function popsort(arr) {
    for (let i = 0; i < arr.length - 1; i++) {
        for (let j = 0; j < arr.length - 1 - i; j++) {
            if (arr[j + 1] < arr[j]) {
                let tem = arr[j]
                arr[j] = arr[j + 1]
                arr[j + 1] = tem
            }
        }
    }
}

4、选择

• 平均时间复杂度为O(n2)
• 最坏时间情况下 O(n2)
• 空间复杂度O(1)
• 不稳定

function selectsort(arr) {
    for(let i =0; i< arr.length; i++) {
        let key = i;
        for (let j = i+ 1; j<arr.length; j++) {
            if(arr[j]< arr[i]) {
                key = j
            }
        } 
        if(key != i) {
            swap(arr, i, key)
        }
    }
}

5、归并排序

• 平均时间复杂度为n*log(n)
• 最坏时间情况下 n*log(n)
• 空间复杂度O(n)
• 稳定

function mergesort(arr) {
    if(arr.length < 2) return arr
    let mid = Math.floor(arr.length/2)
    let left = arr.slice(0, mid)
    let right = arr.slice(mid)
    return merge(mergesort(left), mergesort(right))
}
function merge(left, right) {
    let res = []
    while(left.length && right.length) {
        if (left[0]<right[0]){
            res.push(left.shift())
        } else {
            res.push(right.shift())
        }
    }
    while(left.length) {
        res.push(left.shift())
    }
    while(right.length) {
        res.push(right.shift())
    }
    return res
}