选择排序的循环写法

minIndex重写

let minIndex =(numbers) => {
    let index =0 //默认下标为0
    for(let i =1; i<numbers.length; i++){
        if(number[i] < numbers[index]){
            index =i
        }
    }
    return index
}

最终代码

let sort =(numbers) =>{
    for(let i =0 ; i<number.length -1 ; i++){
        console.log(`----`)//这个log很精髓
        console.log(`i : ${i}`)
        let index =minIndex(numbers.slice(i))+ i
        console.log(`index:${index}`)
        console.log(`min:${numbers[index]}`)
        if(index !== i){
            swap(numbers,index , i)
        }
        console.log(`swap ${index}:${i}`)
    }
    return numbers
}


let swap =(array ,i, j) =>{
    let temp =array[i]
    array[i]=array[j]
    array[j] =temp
}

let minIndex =(numbers) =>{
        let index =0
        for(let i =1; i<numbers.length ;i++){
            if(numbers[i] < numbers[index]){
                index =1
            }
        }
        return index
}

sort([1,199,27,93,124,4903,4])
----
i:0
index:0
min:1
----
i:1
index:6
min:4
swap:6: 1
(7)[1,4,27,93,124,4903,199]
----
i:2
index:2
min:27
----
i:3
index:3
min:93
----
i:4
index:4
min:124
----
i:5
index:6
min:199
:swap 6:5
(7)[1,4,27,93,124,199,4903]
(7)[1,4,27,93,124,199,4903]

最终代码删掉log

let sort =(numbers) =>{
    for(let i=0; i<numbers.length-1 ;i++){
        let index =minIndex(numbers.slice(i))+1
        if(index !== i){
            swap(numbers,index,i)
        }
        return numbers
    }
}

let swap =(array ,i, j) =>{
    let temp =array[i]
    array[i]=array[j]
    array[j] =temp
}

//返回最小值的下标
let minIndex =(numbers) =>{
        let index =0
        for(let i =1; i<numbers.length ;i++){
            if(numbers[i] < numbers[index]){
                index =i
            }
        }
        return index
}

解析： numbers.slice(i) 从第i个开始，到最后一个，以新的字符串返回。

slice()方法可提取字符串的某个部分，并以新的字符串返回被提取的部分

快排源码

阮一峰写的版本

let quickSort =arr =>{
    if(arr.length <= 1) {return  arr;}
    let pivotIndex =Math.floor(arr.length  /2); //找中间的那个数 =基准
    let pivot =arr.splice(pivotIndex ,1)[0]; //把一个数从数组中筛选出来
    let left =[];
    let right =[];
    for(let i= 0; i<arr.length ;i++){
        if(arr[i] <pivot){left.push(arr[i])}
        else{right.push(arr[i])}
    }
    return quickSort(left).concat(
    [pivot],quickSort(right))  //递归
}

arr =[1,21,2]
pivot=arr.splice(1,1)
[21]

pivot=arr.splice(1,1)[0]
21

归并排序

let mergeSort =arr =>{
    let k =arr.length
    if(k === 1){return arr}
    let left =arr.slice(0,Math.floor(k/2))
    let right =arr.slice(Math.floor(k/2)
    return merge(mergeSort(left),mergeSort(right))
}

let merge =(a,b) =>{
    if(a.length === 0) return b
    if(b.length === 0) return a 
    return a[0] > b[0]?
    [b[0]].concat(merge(a,b.slice(1))) :
    [a[0]].concat(merge(a.slice(1),b))
}

计数排序