四种排序算法的js实现

选择排序

平均时间复杂度O（n2）

空间复杂度O（1）（用于交换时作为临时变量）

算法描述：

第一次遍历所有的元素，找出最小的那个放在一号位上

第二次遍历n-1次，找出剩余元素中最小的那个放在二号位上

以此类推。。。。。。

function selectSort(arr){
    if(!Array.isArray(arr)) return;
    //临时变量
    let temp;
    for(let i=0, len=arr.length; i<len-1; i++){
        for(let j=i+1; j<len; j++){
            if(arr[i]>arr[j]){
                temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

冒泡排序：

平均时间复杂度：O（n2）

空间复杂度：O(1)（用于交换时存储临时变量）

算法描述：

选择相邻的两个数两两进行比较，小的那个数一直往前冒，这样就可以在第一轮找到最小的那个数

接着在剩下的数中重复上述操作。。。。。。

function bubbleSort(arr){
    if(Object.prototype.toString.call(arr).slice(8,-1) != "Array") return;
    // 临时变量
    let temp;
    for(let i=0, len=arr.length; i<len-2; i++){
        for(let j=len-1; j>i; j--){
            if(arr[j]<arr[j-1]){
                temp = arr[j];
                arr[j] = arr[j-1];
                arr[j-1] = temp; 
            }
        }
    }
    return arr;
}

快速排序

平均时间复杂度：O(n*logn2n)

空间复杂度：O(log₂n)~O(n)

算法描述：

1．先从数列中取出一个数作为基准数。

2．分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3．再对左右区间重复第二步，直到各区间只有一个数。

start和end分别指向数组的第一个元素后最后一个元素

首先让数组的第一个元素作为基准数，这样一号位就空出来了，首先从后往前找一个小于基准数的元素，然后填入一号为

接着从前往后找一个大于基准数的元素填入刚才填入一号位的那个元素的位置

以此类推直到start等于end为止，最后把基准数存入数组的start或者end位置

第一轮过后比第一个数大的元素都在他的右边比他小的都在左边，接着就是分别对所有的数组进行递归操作

 function quickSort(arr, start, end) {
        if(start >= end) return;
        let i = start, j = end, k = arr[start];
        while (i < j) {
            //从后往前找
            while (i < j && k < arr[j]) {
                j--;
            }
            //排除i==j跳出循环的情况
            if (i<j) {
                arr[i++] = arr[j];
            }
            // 从前往后找
           while(i<j && k >=arr[i]){
               i++;
           }
           //排除i==j跳出循环的情况
           if(i < j){
               arr[j--] = arr[i]; 
           }
        }
        arr[i] = k;
        quickSort(arr, start, i-1);
        quickSort(arr, i+1, end);
        return arr;
    }

插入排序

平均时间复杂度：O(n²)

空间复杂度：O(n²)

算法描述：

插入即表示将一个新的数据插入到一个有序数组中，并继续保持有序。

例如有一个长度为N的无序数组，进行N-1次的插入即能完成排序；

第一次，数组第1个数认为是有序的数组，将数组第二个元素插入仅有1个有序的数组中；

第二次，数组前两个元素组成有序的数组，将数组第三个元素插入由两个元素构成的有序数组中

......

第N-1次，数组前N-1个元素组成有序的数组，将数组的第N个元素插入由N-1个元素构成的有序数组中，则完成了整个插入排序。

  function insertSort(arr){
        //从一号位开始执行插入排序，因为0号位元素可以直接当成有序数
        for(let i=1,len=arr.length; i<len; i++){
            // 用于遍历已经有序的数组
            let j=0;
            while(j<i && arr[j] < arr[i]){
                    j++;
            }
            //排除j==i跳出循环的情况
            if(j<i){
                //插入a[i]
                arr.splice(j,0,arr[i]);
                //删除a[i],注意插入arr[i]后数组多了一个元素
                arr.splice(i+1,1);
            }
        }
        return arr;
    }