常用排序算法
本文章算法实现皆使用js实现。
1. 冒泡排序
分析：原理如它名字一样，不断的让最大（最小）的数字冒出来，完成排序。时间复杂度为O(n²)。
算法实现：
let effervescent = (nums) => { let len = nums.length; for (let i = 0; i < len; i++) { for (let j = i + 1; j < len; j++) { if (nums[i] > nums[j]) { let temp = nums[i]; nums[i] = nums[j]; nums[j] = temp; } } } return nums; }
2. 选择排序
分析：遍历获取每次的最小（最大）值的下标，遍历完成后和边界位置置换，一直循环到全部数据，完成排序。 时间复杂度O(n²)。
算法实现：
let choose = (nums) => { let len = nums.length; for (let i = 0; i < len; i++) { let minIndex = i; for (let j = i + 1; j < len; j++) { if (nums[j] < nums[minIndex]) { minIndex = j; } } let temp = nums[minIndex]; nums[minIndex] = nums[i]; nums[i] = temp; } return nums; }
3. 快速排序
分析：选择一个基准元素，将数组中大于它的数放这个右边，小于它的数字放左边。然后将左边，右边递归调用这个方法进行排序。 时间复杂度 O(nlogn)。
算法实现
let quick = (nums, start = 0, end = 0) => { let len = nums.length; if(len < 2){ return nums; } let leftIndex = start, rightIndex = end === 0 && start === 0 ? len - 1 : end; if(rightIndex - leftIndex < 1){ return; } let flag = nums[start]; //基准 while (leftIndex < rightIndex) { while (leftIndex < rightIndex) { //从右边找出一个小于基准的数字，放入左边位置 if (flag > nums[rightIndex]) { nums[leftIndex++] = nums[rightIndex]; break; } --rightIndex; } while (leftIndex < rightIndex) { //从左边找出一个大于基准的数字，放入右边位置 if (flag <= nums[leftIndex]) { nums[rightIndex--] = nums[leftIndex]; break; } ++leftIndex; } } nums[leftIndex] = flag; //将基准放入中间位置，该位置为上面移位后空余的位置 quick(nums, start, leftIndex - 1);//left quick(nums, rightIndex + 1, end);//right return nums; }
4. 插入排序
分析：将数组看成两个部分，前面部分为排序部分，后面部分为待排序部分，一次遍历待排序部分，插入排序部分。排序部分不断增加，待排序部分不断减少，直至变成目标排序数组。时间复杂度O(n²)。
算法实现：
var insert = (nums) => { let len = nums.length; for (let i = 1; i < len; i++) { let target = nums[i]; //找出插入位置 let j = 0; while (j < i) { if (target < nums[j]) { break; } j++; } //插入 if (j < i) { let removeIndex = i; //后移 while (removeIndex >= j) { nums[removeIndex] = nums[removeIndex - 1]; removeIndex--; } //插入 nums[j] = target; } } return nums; }
5. 希尔排序
分析：设置插入比较的步长，不断进行插入排序，并且减少步长，他会逐渐使序列变得有序，当步长为1时，就是插入排序。它是插入排序的进阶版，主要优点是减少移动次数。时间复杂度O(n²)。
算法实现：
let shell = (nums) => { let len = nums.length; for (let step = Math.round(len / 2); step > 0; step = Math.floor(step / 2)) {//step 为分组长度 for (let i = step; i < len; i += step) { let flag = nums[i]; //找到插入位置 let j = 0; while (j < i) { if (nums[j] > flag) { break; } j += step; } //后移 if (j < i) { let removeIndex = i; while(removeIndex > j){ nums[removeIndex] = nums[removeIndex - step]; removeIndex -= step; } nums[j] = flag; } } } return nums; }
6. 桶排序
分析：获取数组中最大值， 用该值初始化一个长度为该值的一个数组（桶），初始各项为0，遍历需要排序的数组，把每个出现的数字作为下标，标记桶数组该下标的数量。最后遍历桶，输出内容大于0的下标，内容有多少就输出多少次。这样做的缺点很明显，在出现一个特别大的数字情况下特别的浪费空间，不过在特定情况下，它的排序速度会比较快。时间复杂度为： O(x*n)。
算法实现为：
let bucket = (nums) => { let arr = []; let len = nums.length; //获取最大值 let max = nums[0]; let i = 1; while(i < len){ if(nums[i] > max){ max = nums[i]; } i++; } //初始化桶 let bucketArr = new Array(max); //标记桶 i = 0; while(i < len){ let val = bucketArr[nums[i]]; if(val && val > 0){ bucketArr[nums[i]] ++; }else{ bucketArr[nums[i]] = 1; } i++; } //得到数组 i = 0; while(i <= max){ if(bucketArr[i] && bucketArr[i] > 0){ let j = 0; while(j < bucketArr[i]){ arr.push(i); j++; } } i ++; } return arr; }
7. 基数排序
分析：升级版本的桶排序。低位排序（LSD）：初始化一个长度为10的数组（桶）。首先对待排序的个位数进行桶排序，获取排序结果。然后对结果进行十位数的桶排序。直至完成最大位数的桶排序，获取最后的排序结果。高位排序（MSD）: 初始化一个长度为10的数组（桶）。首先对最高位进行桶排序，然后再对桶内的元素进行低一位的排序，一直到个位完成排序。两种方式不同之处在于，高位排序为真实排序，所以不必再和其它为进行比对。 时间复杂度: O(x*(log(r))*n)。
LSD算法实现为:
let radixLsd = (nums) => { let len = nums.length; let bucketArr = new Array(10); //找到最大位，确定排序次数 let max = nums[0]; for (let i = 1; i < len; i++) { if (nums[i] > max) { max = nums[i]; } } let maxLen = max.toString().length; let index = 0; //[0, maxLen) while (index < maxLen) { bucketArr = new Array(10); //对该位桶排序 let i = 0; // 遍历nums [0, len) //入桶 while (i < len) { //获取nums[i] index位置的数字 let valArr = nums[i].toString().split(''); let numberIndex = valArr.length <= index ? -1 : valArr.length - index - 1; let number = numberIndex >= 0 ? parseInt(valArr[numberIndex]) : 0; if (bucketArr[number]) { bucketArr[number].push(nums[i]); } else { bucketArr[number] = [nums[i]]; } i++; } nums = []; //出桶 let j = 0; //遍历桶的索引 [0, 9] while (j <= 9) { if (bucketArr[j]) { for (let k = 0; k < bucketArr[j].length; k++) { nums.push(bucketArr[j][k]); } } j++; } index++; } return nums; }
MSD算法实现为:
let radixMsd = (nums) => { //递归获取排序桶 let bucketArr = bucketMsd(nums, -1); //递归读取桶中排序数据 let arr = []; readBucket(bucketArr, arr); return arr; } let readBucket = (bucket, arr) => { if (bucket instanceof Array) { for (let i = 0; i < bucket.length; i++) { if (bucket[i]) { readBucket(bucket[i], arr); } } } else { if (typeof(bucket) === 'number') { arr.push(bucket); } } } //对数组高位桶排序，返回桶 let bucketMsd = (nums, index) => { //index 为排序位，-1时为最高位置 let len = nums.length; let bucketArr = new Array(10); if (index === -1) { //找到最大位，确定排序次数 let max = nums[0]; for (let i = 1; i < len; i++) { if (nums[i] > max) { max = nums[i]; } } let maxLen = max.toString().length; index = maxLen - 1; //控制桶排序次数 [0, max - 1] } //根据最高位入桶 for (let i = 0; i < len; i++) { //获取nums[i] index位置的数字 let valArr = nums[i].toString().split(''); let numberIndex = valArr.length <= index ? -1 : valArr.length - index - 1; let number = numberIndex >= 0 ? parseInt(valArr[numberIndex]) : 0; if (bucketArr[number]) { bucketArr[number].push(nums[i]); } else { bucketArr[number] = [nums[i]]; } } if (index > 0) { for (let k = 0; k < bucketArr.length; k++) { if (bucketArr[k] && bucketArr[k].length > 0) { bucketArr[k] = bucketMsd(bucketArr[k], index - 1); } } } return bucketArr; }
