常用算法

选择排序

• 递归写法

let minIndex= 
let sort = (numbers) =>{
    if(numbers.length >2){
        let index = minIndex(numbers)
        let min = numbers(index)
        numbers.splic(index,1)
        return [min].concat (sort(numbers))
    }else{
        return numbers[0]<numbers[1] ? numers: numbers.revers()
    }
}

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

• 循环写法

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


let minIndex = (numbers) =>{
    let index =0
    if(numbers[i]<numbers[index]){
        index = i
    }
    return index
}

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

快速排序

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))
}

归并排序

let merge = arr =>{
    if(arr.length ===1){
        return arr
    }
    let left = arr.slice(0,arr.length/2)
    let right = arr.slice(arr.length/2)
    return merge(mergesort(left).concat(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]].mergr(a.concat(b.slice(1)) : [a[0]].merge(a.slice(1),b))
}

计数排序

let counsort = arr =>{
    let hashTable ={},max = 0, result = []
    for(let 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<=arr[i];j++){
            if(j in hashTable){
                for(let i=0;i<hashTable(j);i++){
                    result.push(j)
                }
            }
        }
    }
    return result
}