学习算法排序

请写一个 min 函数，要求 min(numbers) 能返回数组 numbers 中的最小数字

let min = (numbers) => numbers[0] < numbers[1] ? numbers[0] : numbers[1] //两个数当中最小

let min = (numbers) => {
    if(numbers.length > 2){
        return min(
        [numbers[0],min(numbers.slice(1))]
        )
    }else{
        return Math.min.apply(null,numbers)
    }
    return numbers
}

min([1,3,4,2,9,7,6])

请写出一个 sort 函数，要求 sort(numbers) 能返回一个把 numbers 从小到大排列的数组

let minIndex = (numbers) =>{
    let index = 0
    for(let i = 1 ; i < numbers.length ; i++){
        if(numbers[i] < numbers[index]){
            index = i
        }
    }
    return index //minIndex这个函数是求一次numbers这个数组里最小数的下标
}

let sort = (numbers) => {
    if(numbers.length > 2){
        let index = minIndex(numbers)
        let min = numbers[index]
        numbers.splice(index,1) //去除index下标的数字，返回numbers
        return [min].concat(sort(numbers))
    }else{
        return numbers[0] < numbers[1] ? numbers : numbers.reverse()
    }
}

sort([1,3,4,2,9,7,6])

let sort = (numbers) =>{
    for(let i = 0;i < numbers.length -1;i++){
        console.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 = i
        }
    }
    return index
}

快速排序

let quickSort = (arr) => {
    if(arr.length <= 1){return arr;}
    let pivotIndex = Math.floor(arr.length / 2); //找一个数组里面中间的数，例如arr.length / 2 =3.4 ,那么Math.floor = 3
    let pivot = arr.splice(pivotIndex , 1)[0]; //splice的意思就是把这个数index单独拧出来
    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])}//如果第i项小于我们拧出来的pivot，就把这个数放到left数组里面，else相反
    }
    return quickSort(left).concat([pivot],quickSort(right))//最后返回左边这个数组加上拧出来的数再加上右边这个数组
}

归并排序

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

let merge = (a,b) =>{//定义a,b两个数组
    if(a.length === 0){return b}//如果a或者b的长度等于0的时候返回相反
    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))//找出两个数字a[0],b[0]做对比，把小的放前面，后面的部分在循环执行merge，直到a或者b的长度为0的时候，退出
}

计数排序

let countSort = arr =>{
    let hashTable = {}
    let max = 0
    let result = []
    for(let arr[i] = 0 ;i<arr.length; i++){
        if(!(i in hashTable)){
            hashTable[arr[i]] = 1
        }else{
            hashTable[arr[i]] += 1
        }
        if(arr[i] > max){max = arr[i]}
    }
    for(let j = 0;j<=max; j++){
        if(j in hashTable){
            for(let i = 0; i<hashTable[j]; i++){
                result.push(j)
            }
        }
    }
    return result
}

countSort([5,2,3,9,7,6])