1、选择排序

    选择出最小的或者做大的然后两两比较进行排序

    1. let minIndex = (numbers) =>{
    2.     let index = 0
    3.     for(let i=1;i<numbers.length;i++){
    4.         if(numbers[i] < numbers[index]){
    5.             index = i 
    6.         }
    7.     }
    8.         return index
    9. }
    12. let swap = (array,i,j) =>{
    13.     let temp = array[i]
    14.     array[i] = array[j]
    15.     array[j] = temp
    16. }
    19. let sort = (numbers) =>{
    20.     for(let i = 0 ;i < numbers.length -1; i++){
    21.         let index = minIndex(numbers.slice(i)) + i
    22.         if(index !== i ){swap(numbers,index,i)}
    23.     }
    24.     return numbers
    25. }

    image.png
    2、快速排序
    快速排序 以基准进行比较进行排序

    1. let quicksort = arr =>{
    2.     if(arr.length < 2){return arr}
    3.     let pivotIndex = Math.floor(arr.lengtn /2)
    4.     let pivot =arr.splice(pivotIndex,1)[0]
    5.     let left = []
    6.     let right = []
    7.     for(let i = 0;i<arr.length;i++){
    8.         if(arr[i]<pivot){left.push(arr[i])
    9.          }else{right.push(arr[i])}
    10.     }
    11.     return quicksort(left).concat([pivot],quicksort(right))
    12. }

    image.png
    3、归并排序
    归并排序，把需要排序的数组进行划分排序，然后将其进行合并

    1. let mergesort = arr =>{
    2.     let k = arr.length
    3.     if(k===1){return arr}
    4.     else{
    5.     let left = arr.slice(0,Math.floor(k/2))
    6.     let right = arr.slice(Math.floor(k/2))
    7.     return merge(mergesort(left),mergesort(right))}}
    9. let merge = (a,b) =>{
    10.     if(a.length ===0) return b 
    11.     if(b.length ===0) return a 
    12.     return a[0] > b[0] ? [b[0]].concat(merge(a,b.slice(1))) : [a[0]].concat(merge(a.slice(1),b))}
    13.         //出现错误  代码：b[0].concat(merge(a,b.slice(1)))   b[0] !== [b[0]]

    image.png
    4、计数排序

    使用哈希表做记录

    1. let countsort = arr =>{
    2.     let hashTable = {},max = 0,result = []
    3.     for(let i = 0 ;i <arr.length;i++){                        //遍历数组
    4.     if(!(arr[i] in hashTable)){                    // 出现错误  代码if(!arr[i] in hashTable)
    5.         hashTable[arr[i]] = 1
    6.     }else{
    7.         hashTable[arr[i]] += 1                                
    8.     }
    9.     if(arr[i]>max) {max = arr[i]}
    10.     }
    11.     for(let j=0; j<=max;j++){                                        //遍历哈希表
    12.     if(j in hashTable){
    13.        for(let i=0;i<hashTable[j];i++){              //若出现多次，遍历哈希表时多次打印
    14.         result.push(j)
    15.        }
    16.         }
    17.     }
    18.     return result 
    19. }

    5、冒泡排序
    image.png
    6、插入排序
    image.png
    7、希尔排序
    希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

    1. let xier = arr =>{
    2.     let len = arr.length;
    3.     for (var fraction = Math.floor(len / 2); fraction > 0; fraction = Math.floor(fraction / 2)) {
    4.         for (var i = fraction; i < len; i++) {
    5.             for (var j = i - fraction; j >= 0 && arr[j] > arr[fraction + j]; j -= fraction) {
    6.                 var temp = arr[j];
    7.                 arr[j] = arr[fraction + j];
    8.                 arr[fraction + j] = temp;
    9.             }
    10.         }
    11.     }
    12.  return arr
    13. }

    8、基数排序
    比较所有数字的个位数、然后比较所有数字的十位数、百位、千位…… 然后进行排序