插入排序，选择排序，冒泡排序，归并排序，快速排序整理（js版本）

先上神图：

冒泡排序法：相邻比较大小，来决定是否交换位置，依次迭代，标准的冒泡排序内循环是在尾部开始的；稳定

插入排序法：打扑克牌整理牌时的做法，注意需要用到temp来缓存下一个值；稳定；

选择排序法：冒泡太着急了，我选择稳妥一点，一次迭代后才确定交换一次；不稳定；因为相同元素的位置会调换；

快速排序法：将一大堆数据分成两个堆，一个大的一个小的；然后分别在大堆小堆继续迭代，不稳定；

归并排序法：我先分成一个个数组，再依次合并起来，合并的算法也是有讲究的，稳定；

还有桶排序，计数排序这类是要求拓展内存空间来做的，都是稳定的；

希尔排序呢，是插入排序的高级实现，一种用间隔不断缩小迭代的思想去进行插入排序，实现起来相对复杂；

堆排序呢，用大根堆，小根堆的思想去做的，因为每一个数在堆上进行排序的时间复杂度是log2{n}，所以最终时间

复杂度为nlog(n），但是不稳定；

下面我只实现了五种算法：

记忆：

不稳定：快速，选择；

稳定：归并，插入，冒泡；

快排平均时间复杂度：O(nlogn)，最少是O(nlogn)，最大是O(n2)，最好情况是对半分，每次递归需要比较n次，递归log(n)次；最坏的情况是选择到最大与最小的情况了；

推导过程查看知乎大神的：

知乎：如何证明快速排序法的平均复杂度为 O(nlogn)？

以下是算法的实现：

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

// 冒泡排序法
function bubbleSort(arr){
    const len = arr.length;
    for(let i=0;i<len;i++){
        for(let j=len-1;j>i;j--){
            if(arr[j]<arr[j-1]){
                swap(arr,j,j-1)
            }
        }
    }
    return arr
   
}



// 插入排序
function insertSort(arr){
    const len = arr.length;
    for(let i=1;i<len;i++){
        let temp = arr[i],j;
        // 此处从最后的位置来依次遍历
        for(j=i-1;j>=0 && temp<arr[j];j--){
            // 往后移动一位
            arr[j+1] = arr[j]
        }
        // 记住是temp赋值，而不是arr[i]赋值，因为此时arr[i]已经被覆盖了
        arr[j+1]=temp;
    }
   return arr
}


// 选择排序
function selectSort(arr){
     const len = arr.length;
    for(let i=0;i<len;i++){
        // 保留当前的索引
        let index = i;
        for(let j=len-1;j>i;j--){
            if(arr[j]<arr[index]){
                index = j;    
            }
        }
        
        swap(arr,index,i)
    }
}


//  快排
function quickSort(arr,left,right){
    let len = arr.length;
    left = left!==undefined? left:0;
    right = right!==undefined? right:len-1;
    // 递归条件
    if(left<right){
        const baseIndex = sortAndFindIndex(arr,left,right)
        quickSort(arr,left,baseIndex-1)
        quickSort(arr,baseIndex+1,right)
    } 

}
function sortAndFindIndex(arr,left,right){
    let baseIndex = left;
    let baseValue = arr[left];
    let index = baseIndex+1;
    for(let i = index;i<=right;i++){
        if(baseValue>arr[i]){
        swap(arr,i,baseIndex)
        index++    
    }
       
    }
swap(arr,index-1,baseIndex)
    return index-1

}


// 归并排序
function mergeSort(arr,left,right){
     let len = arr.length;
    if(len<2){
        return arr
    }
    let middleIndex= Math.floor(len/2);
    let leftArr = arr.slice(0,middleIndex);
    let rightArr = arr.slice(middleIndex,len);
    return merge(mergeSort(leftArr),mergeSort(rightArr))
}
function merge(left,right){
    const 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
}

基本掌握就这么多了