js实现几种常见算法

代码如下：

//js实现选择排序
function selectSort(arr) {
    var len = arr.length;
    for (var i = 0; i < arr.length - 1; i++) {
        var minIndex = i;
        for (var j = i + 1; j < arr.length; j++) {
            if (arr[j] < arr[minIndex]) {
                minIndex = j;
            }
        }
        if (minIndex != i) {
            var temp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = temp;
        }
    }
    console.log(arr)
}

//js实现插入排序
function insertSort(arr) {
    var len = arr.length;
    for (var i = 1; i < len; i++) {
        var insertValue = arr[i];
        var insertIndex = i - 1;
        while (insertIndex >= 0 && arr[insertIndex] > insertValue) {
            arr[insertIndex + 1] = arr[insertIndex];
            insertIndex--;
        }
        if (insertIndex != i - 1) {
            arr[insertIndex + 1] = insertValue;
        }
    }
}

//js实现希尔排序（移动法）
function shellSort(arr) {
    var len = arr.length;
    //必须向下取整，不然gap是个小数，现象古怪
    for (var gap = Math.floor(len / 2); gap > 0; gap = Math.floor(gap / 2)) {
        for (var i = gap; i < len; i++) {
            //插入的索引
            var index = i - gap;
            //插入值
            var val = arr[i];
            while (index >= 0 && arr[index] > val) {
                arr[index + gap] = arr[index];
                index -= gap;
            }
            if (index != i - gap) {
                arr[index + gap] = val;
            }
        }
    }
}

//快速排序
function quickSort(arr, left, right) {
    //终止递归
    if (left > right) {
        return;
    }
    var l = left;
    var r = right;
    var base = arr[left];
    var temp = 0;
    //完成值交换
    while (l != r) {
        //从右找比基准值大的
        while (arr[r] >= base && l < r) {
            r--;
        }
        //从左找比基准小的值
        while (arr[l] <= base && l < r) {
            l++;
        }
        temp = arr[l];
        arr[l] = arr[r];
        arr[r] = temp;
    }
    //讲基准值与终点值交换
    arr[left] = arr[l];
    arr[l] = base;
    //向左递归
    quickSort(arr, left, l - 1);
    //向右递归
    quickSort(arr, r + 1, right);
}

//随机快排，降低最坏时间复杂度出现
//1.获取随机索引
//low低位，high高位
function getRandomIndex (low, high) {
    var randomNum = Math.floor(Math.random()*high);
    return randomNum % (high - low + 1);
}

//2.获取随机索引，并交换和第一个元素的值（在知道第一个元素比较小的时候用会很好）
function randomQuickSort (arr,left,right){
    var temp = arr[0];
    var index = getRandomIndex(left,right);
    arr[0] = arr[index];
    arr[index] = temp;
    quickSort(arr,left,right);
}

//归并排序
//1.分
//arr，排序数组，left左值，right右值，temp临时数组
function sort (arr,left,right,temp) {
    if(left >= right)return;
    var mid = left + Math.floor((right - left)/2);
    sort(arr,left,mid,temp);
    sort(arr,mid+1,right,temp);
    merge(arr,left,mid,right,temp);
}

//2.并
function merge (arr,left,mid,rightBound,temp){
    var l = left;
    var r = mid + 1;
    var k = left;
    //填充临时数组
    while(l <= mid && r <= rightBound){
        if(arr[l] <= arr[r]){
            temp[k++] = arr[l++];
        }else{
            temp[k++] = arr[r++];
        }
    }
    //将没有比较到的元素填充到临时数组
    while(l <= mid){
        temp[k++] = arr[l++];
    }
    while(r <= rightBound){
        temp[k++] = arr[r++];
    }
    //将临时数据填充到原始数组里
    for(var m = 0; m <= rightBound; m++){
        arr[m] = temp[m];
    }
}

常用的算法特性：

名称	平均时间复杂度	最坏时间复杂度	最好时间复杂度	空间复杂度	稳定性
选择	n^2	n^2	n^2	1	不稳
冒泡	n^2	n^2	n^2	1	稳
+插入	n^2	n^2	n^2]	1	稳
+堆	n*(log n)	n*(log n)	n*(log n)	1	不稳
希尔	n^1.3	n^2	n	1	不稳
+归并	n*(log n)	n*(log n)	n*(log n)	n	稳
+快排	n*(log n)	n^2	n*(log n)	n*(log n)	不稳
桶	n + k	n^2	n	n + k	稳
计数	n + k	n + k	n + k	n + k	稳
基数	n * k	n * k	n * k	n + k	稳

算法长时间不写就容易忘记，建议大家有空多写写，对于我们解决问题思路的养成也很有帮助。