排序算法代码

求最小值

let min =(numbers) => {
	if(numbers.length > 2){
	return min([numbers[0],min(numbers.slice(1))])//第0个数，和从数字第1个数开始取得最小
	}else{
		return Math.min.apply(null,numbers)//如果numbers长度等于2，就用Math.min.apply
		                                   //意思是把两个数字展开，返回最小值
   }
}

一.选择排序

1. 选择排序的递归写法---------sort排序

• 每次选择出最小的放前面，再sort

let sort =(numbers) =>{
	if(numbers.length > 2){
   let index = minIndex(numbers) //取到最小值下标
   let min =numbers[index] //用最小值下标取到最小值
   numbers.splice(index,1) //从index处删掉一个，也就是删掉最小值
	return [min].concat(sort(numbers))//返回最小值和其他的数字的最小值连接起来
	                                 //其他的数字sort递归排序
   }else{
		return numbers[0]<numbers[1] ? numbers:numbers.reverse()
		 //要是数字长度等于2，第一个小于第二个就返回这个数字，否则就把两个数字倒过来
		 //再返回第一个小的。
  }
}

let minIndex = (numbers) =>
 	numbers.indexOf(min(numbers))
 

let min =(numbers) => {
	if(numbers.length > 2){
	return min([numbers[0],min(numbers.slice(1))])
	}else{
		return Math.min.apply(null,numbers)//如果numbers长度等于2，就用Math.min.apply
		                                   //意思是把两个数字展开，返回最小值
   }
}

1. 选择排序的循环写法---------排序

minIndex循环写法

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

let swap =(array,i,j) => {
	let temp =array[i]
	array[i] = arry[j]
	array[j] = temp
}
swap(numbers,1,2)

minIndex查找范围有问题

• let index = minIndex(numbers)
• 这句话有问题，如果上次循环已经找到了第一个最小得数字，那么之后找最小数字得时候，就可以忽略第一个
• let index =minIndex(numbers.slice(i))+i
• 为什么要+i
• 如果不加，那么index总是从0数起

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

• 打log技巧

//打log技巧


    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}`) //
                console.log(numbers) //
            }
        }
        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 privotIndex = Math.floor(arr.length/2);
	//从arr中，从基准下标处删掉1个，也就是删掉基准，[0]表示取出删掉的第一个，赋值给pivot,因为不取出splice返回的是一个数组，
	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))
}

三，归并排序

• 思路
• 左边一半排好序，右边一半排好序
• 然后把左右两边合并（merge）起来
  

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

四，计数排序

• 思路
• 用一个哈希表作记录
• 发现数字N就记N:1,如果再次发现N 就加1
• 最后把哈希得key 全部打出来，假设N:m，那么N 需要打印m次
• 

let countSort = arr =>{
	let hashTable ={}, max = 0, result =[]
	for(let i=0; i<arr.length;i++){
		if(!(arr[i] in hashTable)){
	 		hashTable[i] = 1
	 }else{
		hashTable[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
}