排序算法

冒泡排序

• 从左到右,依次比较相邻元素大小

			var arr = [1,9,18,-9,16,0];
			function bubbleSort(arr){
				var flag=false;
				for(let i=0;i<arr.length-1;i++){
					flag=false;
					for(let j=0;j<arr.length-i-1;j++){
						if(arr[j]>arr[j+1]){  //如果前一个比后一个大则交换
							let temp = arr[j];
							arr[j]=arr[j+1];
							arr[j+1]=temp;
							flag=true;
						}
					}
					if(flag==false){
						break;
					}
				}
			}
			bubbleSort(arr);
			console.log(arr);

选择排序

• 选取某个元素，与后面的元素中寻找是否比它小（或大）的，若有则进行交换

			var arr = [-5,3,0,1,7,1,6,8];
			function selectSort(arr){
				var index;
				var value;
				for(let i=0;i<arr.length-1;i++){
					index=i;
					value=arr[i];
					for(let j=i+1;j<arr.length;j++){
						if(arr[j]<value){
							index=j;
							value=arr[j];
						}
					}
					let temp = arr[index];
					arr[index]=arr[i];
					arr[i]=temp;
				}
			}
			selectSort(arr);
			console.log(arr);

快速排序

• 在数据集之中，选择一个元素作为"基准"（pivot）

所有小于"基准"的元素，都移到"基准"的左边 所有大于"基准"的元素，都移到"基准"的右边。

对"基准"左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

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 = 排序思路：将无序的数组 拆成N部分进行有序处理，然后合并
　　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) )
}

归并排序

• 采用分治策略，将大问题分为小问题，先解决小问题再递归解决大问题

排序思路：将无序的数组 拆成N部分进行有序处理，然后合并

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

计数排序

• 计数排序就是简单的桶排序，一个桶代表数组中一个数出现的个数，所以需要一个和数组数字范围一样大的辅助数组，一般用在范围小于100的排序，时间复杂度为O(n)，空间复杂度为数组的数字范围。

let countSort = arr =>{
  let hashTable = {}, max = 0, result = []
  for(let i=0; i<arr.length; i++){ // 遍历数组
    if(!(arr[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
}