排序算法的Javascript实现
1.冒泡排序：
比较相邻的两个数，如果前一个数大于后一个数，就将这两个数换位置。每一次遍历都会将本次遍历最大的数冒泡到最后。为了将n个数排好序，需要n-1次遍历。 如果某次遍历中，没有调整任何两个相邻的数的位置关系，说明此时数组已排好序，可以结束程序。
Array.prototype.bubbleSort = function () { let i, j; for (i = 1; i < this.length; i++) { //表示本次是第i次遍历 let changed = false; for (j = 0; j < this.length - i; j++) { //访问序列为arr[0:length-i] if(this[j] > this[j + 1]){ //发现前一个数大于后一个时，互换位置 [this[j],this[j+1]] = [this[j+1],this[j]]; changed = true; } } if(!changed) { //如果本轮遍历没有发现位置调整，结束排序函数 break; } }};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.bubbleSort();console.log(arr);
2.选择排序
第i轮遍历arr[0:n-i]选出最大的数，与arr[n-i]互换。
Array.prototype.selectSort = function () { let i, j; for (i = 1; i < this.length; i++) { //表示本次是第i次遍历 let maxIndex = 0; for (j = 0; j <= this.length - i; j++) { //访问子序列为arr[0:this.length-i] if (this[j] > this[maxIndex]) { //当前值大于当前最大值时，记录索引 maxIndex = j; } } //将子数组最大值索引的值，与子数组末尾的值互换 [this[this.length - i], this[maxIndex]] = [this[maxIndex], this[this.length - i]] }};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.selectSort();console.log(arr);
3.插入排序 数组的前面部分已经排好序，要把当前数字插入到前面已排好序的数组的相应位置。可能有人会有疑问为什么默认数组前面部分已排好序？是怎么排好序的？是因为当排序开始时，从第2个数字开始进行向前插入，此时当前数字索引为1，当前数字前面仅有一个数字，因此可以认为前面部分已经排好序，将这个数字插入到相应位置之后数组仍然是有序的。每次都将当前数字插入到对应的位置，因此每次插入之后前面的数组仍是排好序的。
Array.prototype.insertSort = function () { let i, j; for (i = 1; i < this.length; i++) { //i表示当前要向前插入的数字的索引，从1(即第2个数)开始前插 let val = this[i]; //记录当前要前插的数的大小 /* * 用指针j来遍历第i个数字前面的，已经排好序的子数组。当j没有指到头，并且j的数字大于要插入的数字时，说明 * j还要向前遍历，直到发现一个比要插入数字小的位置pos，然后将这个数字插到pos+1处。如果j已经指到头了， * 到了-1了还没有找到比当前数字小的位置，就把当前数字放在索引0处。 * */ for (j = i - 1; j >= 0 && this[j] > val; j--) { this[j + 1] = this[j]; } this[j + 1] = val; }};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.insertSort();console.log(arr);
4.shell排序 加了step的插入排序。分别以索引数为0,1,......step-1的元素为起点，将其看做不同的组，0、0+step,0+2step，......，0+nstep为一组，1,1+step,1+2step，.....,1+nstep为一组依次分组，按照组为单位进行插入排序。各组都已经插入排序一轮过后，将step除以2向下取整，再进行分组并将各组分别进行插入排序，直到step为0。 step的取值与性能直接相关，需要思考后取值。 并且这里的分组仅仅是逻辑上分组，并没有开辟新的地址空间将其进行物理上的分组。
const {floor} = Math;//这个和插入排序相同，只不过加了stepArray.prototype.shellInsertSort = function (startIndex, step) { let i, j; for (i = startIndex + step; i < this.length; i += step) { let val = this[i]; for (j = i - step; j >= 0 && this[j] > val; j -= step) { this[j + step] = this[j]; } this[j + step] = val; }};Array.prototype.shellSort = function () { let i, step; for (step = floor(this.length / 2); step > 0; step = floor(step / 2)) { for (i = 0; i < step; i++) { this.shellInsertSort(i, step); } }};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.shellSort(true);console.log(arr);
5.合并排序
举个例子： 有 43 12 32 29 66 78 31这个数组要用合并排序。 先将相邻两数分为一组进行合并 43|12 32|29 66|78 31 结果为12 43 29 32 66 78 31
再将组的大小乘以二 (12 43|29 32) (66 78|31) 本次合并后结果为 12 29 32 43 31 66 78
再将组的大小乘以二 12 43 29 32 | 66 78 31 合并结果：12 29 31 32 43 66 78
合并的过程中要开辟新的数组arr，建立两个指针i,j分别指向arr1与arr2，此时arr1与arr2都是排好序的，然后每次都将arr1[i]与arr2[j]较小的数加到arr中并将指针后移。最后哪个数组有剩余的数在追加到arr后面。
const {min} = Math;function merge(arr1, arr2,) { let arr = []; let i = 0, j = 0; while (i < arr1.length && j < arr2.length) { arr1[i] < arr2[j] ? arr.push(arr1[i++]) : arr.push(arr2[j++]); } return i < arr1.length ? arr.concat(arr1.slice(i)) : arr.concat(arr2.slice(j))}Array.prototype.mergeSort = function () { let groupSize, i, secondPartSize, firstPart, secondPart, totalSize; //最初合并时，每组的大小仅为1，然后将组的大小乘以2。 for (groupSize = 1; groupSize < this.length; groupSize *= 2) { for (i = 0; i < this.length; i += 2 * groupSize) { //前半段大小一定是groupSize，后半段则不一定 secondPartSize = min(groupSize, this.length - i - groupSize); totalSize = secondPartSize + groupSize; //截取前后部分数组，将其排序 firstPart = this.slice(i, i + groupSize); secondPart = this.slice(i + groupSize, i + groupSize + secondPartSize); this.splice(i, totalSize, ...merge(firstPart, secondPart)); } }};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.mergeSort();console.log(arr);
6.自然合并排序
合并排序的分组是死板的没有利用到数组中原本就是顺序的子序列。
如果数组为 43 56 79 12 33 90 66 将其分组为 43 56 79 | 12 33 90 | 66 再将相邻的，原本就是从小到大的顺序的数组进行合并，效果会更好。
function merge(arr1, arr2) { let arr = [], i = 0, j = 0; while (i < arr1.length && j < arr2.length) { arr.push(arr1[i] < arr2[j] ? arr1[i++] : arr2[j++]) } return arr.concat(i < arr1.length ? arr1.slice(i) : arr2.slice(j));}function getSortedArrList(arr) { //记录下已经原本就是从小到大顺序的子数组 let sortedArrList = []; let childArr = [arr[0]]; for (let i = 1; i < arr.length; i++) { //当前值小于上一个值时，将childArr加入sortedArrList中，创建新的childArr，并加入当前值。 if (arr[i] < arr[i - 1]) { sortedArrList.push(childArr); childArr = [arr[i]]; } //否则，将当前值加入到childArr中 else { childArr.push(arr[i]); } } sortedArrList.push(childArr); return sortedArrList;}Array.prototype.naturalMergeSort = function() { let sortedArrList = getSortedArrList(this); //获取原本从小到大顺序的子数组 while (sortedArrList.length > 1) { //当还有两个及以上的数组没合并完成时 let newSortedArrList = []; for (let i = 0; i < sortedArrList.length; i += 2) { if (i !== sortedArrList.length - 1) { newSortedArrList.push(merge(sortedArrList[i], sortedArrList[i + 1])); } else { newSortedArrList.push(sortedArrList[i]); } } sortedArrList = newSortedArrList; } this.splice(0,this.length,...sortedArrList[0]);};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.naturalMergeSort();console.log(arr);
7.基数排序(LSD least significant digit first) LSD中没有数值之间的比较。建立一个[10][]的二维数组arr。 挑选出要排序数组中最大的数字，计算该数字的位数记为digitNum。将数组中的所有数字填充到digitNum位，位数不够的高位补0。 然后遍历digitNum次，从低位开始。第i次遍历按照将数组中元素的第i位的数值，将元素num放到二维数组相应位置处，如果num第i位数值为n，则执行arr[n].push(num)的操作。每次遍历之后，将arr[0:9]各数组的元素依次取出，并且重新初始化二维数组。直到遍历到最高位为止，再取出的就是已经排好序的。
const {max} = Math;function initBarrel() { let barrel = []; for (let i = 0; i < 10; i++) { barrel[i] = []; } return barrel;}function radixSort(arr) { let barrel = initBarrel(); let figureNum = max(...arr).toString().length; //计算最大的数字的位数 arr = arr.map(num => num.toString().padStart(figureNum, '0')); //将数字填充到figureNum位 for (let i = 0; i < figureNum; i++) { let index = figureNum - i - 1; //本次根据第index位来选择放入哪个桶 arr.forEach(numStr => { //将填充过的数组放入桶中 let num = Number(numStr[index]); barrel[num].push(numStr); }); arr = barrel.reduce((prevArr, curArr) => prevArr.concat(curArr), []);//汇总barrel中的数 barrel = initBarrel(); //初始化barrel } return arr.map(num => Number(num)); //最终转为数字形式}Array.prototype.radixSort = function () { let arr = radixSort(this); this.splice(0, this.length, ...arr);};let arr = [1234342, 52165, 75, 1, 356, 575, 765433212, 57994, 3535];arr.radixSort();console.log(arr);
8.基数排序(MSD most significant digit first) 从高位开始，依然没有数值之间的比较。 将最初的元素序列按照各元素最高位的数值进行分组，将分组后，组中只有一个元素或者多个相等元素的组拼接到result数组中，而有多个不同元素的组再递归地向下分，取的位次依次减少。
const {max} = Math;function initBarrel() { let barrel = []; for (let i = 0; i < 10; i++) { barrel[i] = []; } return barrel;}//判断当前桶中是否只有唯一值 有的桶中可能只有一种值，但是有多个重复项function unique(barrel) { return new Set(barrel).size <= 1;}Array.prototype.radixSort = function () { let result = []; let figureNum = max(...this).toString().length; this.splice(0, this.length, ...this.map(num => num.toString().padStart(figureNum, '0'))); radixGroup(this, 0, figureNum, result); this.splice(0, this.length, ...result.map(numStr => Number(numStr)));};function radixGroup(group, index, figureNum, result) { //输入的group是一组numStr，index是当前分桶依据第几位数 if (index < figureNum) { let barrel = initBarrel(); group.forEach(numStr => { let idx = Number(numStr[index]); barrel[idx].push(numStr); }); barrel.forEach(subBarrel => { if(unique(subBarrel)) { subBarrel.forEach(num => { result.push(num); }) } else { radixGroup(subBarrel,index+1,figureNum,result); } }) }}let arr = [1234342, 52165, 75, 1, 356, 575, 765433212, 57994, 3535];arr.radixSort();console.log(arr);
9.快速排序
将数组头部的元素pivotNum作为一个基准，通过两个指针指向数组的头部和尾部，经过一次partition以后将pivotNum放在一个位置pivot，pivot前面的数小于pivotNum，后面的数大于pivotNum。 为了防止最坏情况的发生，可以在数组中随机选出一个数来与数组头部元素换位置，来降低具体实例与最坏情况的关联性。
const {floor, random} = Math;function randomIndex(start, end) { return floor(random() * (end - start + 1)) + start;}function partition(arr, start, end) { let index = randomIndex(start, end); [arr[start], arr[index]] = [arr[index], arr[start]]; let value = arr[start]; while (start < end) { while (start < end && arr[end] > value) end--; arr[start] = arr[end]; while (start < end && arr[start] < value) start++; arr[end] = arr[start]; } arr[start] = value; return start;}function quickSort(arr, start, end) { if (start < end) { let pivot = partition(arr, start, end); quickSort(arr, start, pivot - 1); quickSort(arr, pivot + 1, end); }}Array.prototype.quickSort = function (asc = true) { quickSort(this, 0, this.length - 1, asc)};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.quickSort();console.log(arr);
10.堆排序 将数组看做完全二叉树，因此节点i的左右子节点的索引分别为2i+1与2i+2。通过从根节点开始令小的值下沉，或者从最后的叶节点开始令大的值上浮的方法，将一个数组构造成一个大根堆。再将大根堆的头元素与尾元素换位置，这样就将当前最大值置换到了尾部。然后下次构建大根堆的时候，将刚置换过的尾部元素刨除在外不做为节点。
const {floor, max} = Math;function getBiggestNodeIndex(...nodes) { return nodes.indexOf(max(...nodes));}//将arr从0开始，长度为length的子数组构建为堆function constructHeap(arr, length) { let adjusted = true; //adjusted来标识本次堆是否作出了调整，若未调整说明堆已构建完毕 while (adjusted) { adjusted = false; for (let i = 0; i < floor(length / 2); i++) { //当只有左节点时 if (2 * i + 2 === length) { //当父节点比左节点小的时候 if (arr[i] < arr[2 * i + 1]) { //互换 [arr[i], arr[2 * i + 1]] = [arr[2 * i + 1], arr[i]]; adjusted = true; } } //当同时有左节点和右节点时 else { //判断三个中最大的节点 let biggestNodeIndex = getBiggestNodeIndex(arr[i], arr[2 * i + 1], arr[2 * i + 2]); //若父节点不是最大的，则和最大的交换 //如果biggestNodeIndex为0，说明自己最大，为1，说明左节点大，为2，说明右节点大 switch (biggestNodeIndex) { case 0: break; case 1: [arr[i], arr[2 * i + 1]] = [arr[2 * i + 1], arr[i]]; adjusted = true; break; case 2: [arr[i], arr[2 * i + 2]] = [arr[2 * i + 2], arr[i]]; adjusted = true; break; } } } }}function heepSort(arr) { //只将arr从0开始，长度为length的子数组构建成大根堆 let length = arr.length; while (length > 1) { constructHeap(arr, length); [arr[0], arr[length-- - 1]] = [arr[length - 1], arr[0]]; }}Array.prototype.heepSort = function () { heepSort(this);};let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];arr.heepSort();console.log(arr);
赞 (0)