排序算法的Javascript实现

Posted UI设计自学平台

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了排序算法的Javascript实现相关的知识,希望对你有一定的参考价值。

网页设计自学平台
一个学习前端开发的自学平台
排序算法的Javascript实现

排序算法的Javascript实现

原文:https://segmentfault.com/a/1190000013613746


1.冒泡排序:

比较相邻的两个数,如果前一个数大于后一个数,就将这两个数换位置。每一次遍历都会将本次遍历最大的数冒泡到最后。为了将n个数排好序,需要n-1次遍历。 如果某次遍历中,没有调整任何两个相邻的数的位置关系,说明此时数组已排好序,可以结束程序。

 
   
   
 
  1. Array.prototype.bubbleSort = function () {

  2.  let i, j;

  3.  for (i = 1; i < this.length; i++) {  //表示本次是第i次遍历

  4.    let changed = false;

  5.    for (j = 0; j < this.length - i; j++) {   //访问序列为arr[0:length-i]

  6.      if(this[j] > this[j + 1]){  //发现前一个数大于后一个时,互换位置

  7.        [this[j],this[j+1]] = [this[j+1],this[j]];

  8.        changed = true;

  9.      }

  10.    }

  11.    if(!changed) {      //如果本轮遍历没有发现位置调整,结束排序函数

  12.      break;

  13.    }

  14.  }

  15. };

  16. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  17. arr.bubbleSort();

  18. console.log(arr);

2.选择排序

第i轮遍历arr[0:n-i]选出最大的数,与arr[n-i]互换。

 
   
   
 
  1. Array.prototype.selectSort = function () {

  2.  let i, j;

  3.  for (i = 1; i < this.length; i++) {     //表示本次是第i次遍历

  4.    let maxIndex = 0;

  5.    for (j = 0; j <= this.length - i; j++) {  //访问子序列为arr[0:this.length-i]

  6.      if (this[j] > this[maxIndex]) {   //当前值大于当前最大值时,记录索引

  7.        maxIndex = j;

  8.      }

  9.    }

  10.    //将子数组最大值索引的值,与子数组末尾的值互换

  11.    [this[this.length - i], this[maxIndex]] = [this[maxIndex], this[this.length - i]]

  12.  }

  13. };

  14. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  15. arr.selectSort();

  16. console.log(arr);

3.插入排序 数组的前面部分已经排好序,要把当前数字插入到前面已排好序的数组的相应位置。可能有人会有疑问为什么默认数组前面部分已排好序?是怎么排好序的?是因为当排序开始时,从第2个数字开始进行向前插入,此时当前数字索引为1,当前数字前面仅有一个数字,因此可以认为前面部分已经排好序,将这个数字插入到相应位置之后数组仍然是有序的。每次都将当前数字插入到对应的位置,因此每次插入之后前面的数组仍是排好序的。

 
   
   
 
  1. Array.prototype.insertSort = function () {

  2.  let i, j;

  3.  for (i = 1; i < this.length; i++) {   //i表示当前要向前插入的数字的索引,从1(即第2个数)开始前插

  4.    let val = this[i];   //记录当前要前插的数的大小

  5.    /*

  6.    * 用指针j来遍历第i个数字前面的,已经排好序的子数组。当j没有指到头,并且j的数字大于要插入的数字时,说明

  7.    * j还要向前遍历,直到发现一个比要插入数字小的位置pos,然后将这个数字插到pos+1处。如果j已经指到头了,

  8.    * 到了-1了还没有找到比当前数字小的位置,就把当前数字放在索引0处。

  9.    * */

  10.    for (j = i - 1; j >= 0 && this[j] > val; j--) {  

  11.      this[j + 1] = this[j];

  12.    }

  13.    this[j + 1] = val;

  14.  }

  15. };

  16. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  17. arr.insertSort();

  18. console.log(arr);

 
   
   
 
  1. const {floor} = Math;

  2. //这个和插入排序相同,只不过加了step

  3. Array.prototype.shellInsertSort = function (startIndex, step) {

  4.  let i, j;

  5.  for (i = startIndex + step; i < this.length; i += step) {

  6.    let val = this[i];

  7.    for (j = i - step; j >= 0 && this[j] > val; j -= step) {

  8.      this[j + step] = this[j];

  9.    }

  10.    this[j + step] = val;

  11.  }

  12. };

  13. Array.prototype.shellSort = function () {

  14.  let i, step;

  15.  for (step = floor(this.length / 2); step > 0; step = floor(step / 2)) {

  16.    for (i = 0; i < step; i++) {

  17.      this.shellInsertSort(i, step);

  18.    }

  19.  }

  20. };

  21. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  22. arr.shellSort(true);

  23. 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后面。

 
   
   
 
  1. const {min} = Math;

  2. function merge(arr1, arr2,) {

  3.  let arr = [];

  4.  let i = 0, j = 0;

  5.  while (i < arr1.length && j < arr2.length) {

  6.    arr1[i] < arr2[j] ? arr.push(arr1[i++]) : arr.push(arr2[j++]);

  7.  }

  8.  return i < arr1.length ? arr.concat(arr1.slice(i)) : arr.concat(arr2.slice(j))

  9. }

  10. Array.prototype.mergeSort = function () {

  11.  let groupSize, i, secondPartSize, firstPart, secondPart, totalSize;

  12.  //最初合并时,每组的大小仅为1,然后将组的大小乘以2。

  13.  for (groupSize = 1; groupSize < this.length; groupSize *= 2) {

  14.    for (i = 0; i < this.length; i += 2 * groupSize) {

  15.      //前半段大小一定是groupSize,后半段则不一定

  16.      secondPartSize = min(groupSize, this.length - i - groupSize);

  17.      totalSize = secondPartSize + groupSize;

  18.      //截取前后部分数组,将其排序

  19.      firstPart = this.slice(i, i + groupSize);

  20.      secondPart = this.slice(i + groupSize, i + groupSize + secondPartSize);

  21.      this.splice(i, totalSize, ...merge(firstPart, secondPart));

  22.    }

  23.  }

  24. };

  25. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  26. arr.mergeSort();

  27. console.log(arr);

6.自然合并排序

合并排序的分组是死板的没有利用到数组中原本就是顺序的子序列。

如果数组为 43 56 79 12 33 90 66 将其分组为 43 56 79 | 12 33 90 | 66 再将相邻的,原本就是从小到大的顺序的数组进行合并,效果会更好。

 
   
   
 
  1. function merge(arr1, arr2) {

  2.  let arr = [], i = 0, j = 0;

  3.  while (i < arr1.length && j < arr2.length) {

  4.    arr.push(arr1[i] < arr2[j] ? arr1[i++] : arr2[j++])

  5.  }

  6.  return arr.concat(i < arr1.length ? arr1.slice(i) : arr2.slice(j));

  7. }

  8. function getSortedArrList(arr) {

  9.  //记录下已经原本就是从小到大顺序的子数组

  10.  let sortedArrList = [];

  11.  let childArr = [arr[0]];

  12.  for (let i = 1; i < arr.length; i++) {

  13.    //当前值小于上一个值时,将childArr加入sortedArrList中,创建新的childArr,并加入当前值。

  14.    if (arr[i] < arr[i - 1]) {

  15.      sortedArrList.push(childArr);

  16.      childArr = [arr[i]];

  17.    }

  18.    //否则,将当前值加入到childArr中

  19.    else {

  20.      childArr.push(arr[i]);

  21.    }

  22.  }

  23.  sortedArrList.push(childArr);

  24.  return sortedArrList;

  25. }

  26. Array.prototype.naturalMergeSort = function() {

  27.  let sortedArrList = getSortedArrList(this);  //获取原本从小到大顺序的子数组

  28.  while (sortedArrList.length > 1) {    //当还有两个及以上的数组没合并完成时

  29.    let newSortedArrList = [];

  30.    for (let i = 0; i < sortedArrList.length; i += 2) {

  31.      if (i !== sortedArrList.length - 1) {

  32.        newSortedArrList.push(merge(sortedArrList[i], sortedArrList[i + 1]));

  33.      }

  34.      else {

  35.        newSortedArrList.push(sortedArrList[i]);

  36.      }

  37.    }

  38.    sortedArrList = newSortedArrList;

  39.  }

  40.  this.splice(0,this.length,...sortedArrList[0]);

  41. };

  42. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  43. arr.naturalMergeSort();

  44. 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]各数组的元素依次取出,并且重新初始化二维数组。直到遍历到最高位为止,再取出的就是已经排好序的。

 
   
   
 
  1. const {max} = Math;

  2. function initBarrel() {

  3.  let barrel = [];

  4.  for (let i = 0; i < 10; i++) {

  5.    barrel[i] = [];

  6.  }

  7.  return barrel;

  8. }

  9. function radixSort(arr) {

  10.  let barrel = initBarrel();

  11.  let figureNum = max(...arr).toString().length;  //计算最大的数字的位数

  12.  arr = arr.map(num => num.toString().padStart(figureNum, '0'));  //将数字填充到figureNum位

  13.  for (let i = 0; i < figureNum; i++) {

  14.    let index = figureNum - i - 1;  //本次根据第index位来选择放入哪个桶

  15.    arr.forEach(numStr => {         //将填充过的数组放入桶中

  16.      let num = Number(numStr[index]);

  17.      barrel[num].push(numStr);

  18.    });

  19.    arr = barrel.reduce((prevArr, curArr) => prevArr.concat(curArr), []);//汇总barrel中的数

  20.    barrel = initBarrel();    //初始化barrel

  21.  }

  22.  return arr.map(num => Number(num));   //最终转为数字形式

  23. }

  24. Array.prototype.radixSort = function () {

  25.  let arr = radixSort(this);

  26.  this.splice(0, this.length, ...arr);

  27. };

  28. let arr = [1234342, 52165, 75, 1, 356, 575, 765433212, 57994, 3535];

  29. arr.radixSort();

  30. console.log(arr);

8.基数排序(MSD most significant digit first) 从高位开始,依然没有数值之间的比较。 将最初的元素序列按照各元素最高位的数值进行分组,将分组后,组中只有一个元素或者多个相等元素的组拼接到result数组中,而有多个不同元素的组再递归地向下分,取的位次依次减少。

 
   
   
 
  1. const {max} = Math;

  2. function initBarrel() {

  3.  let barrel = [];

  4.  for (let i = 0; i < 10; i++) {

  5.    barrel[i] = [];

  6.  }

  7.  return barrel;

  8. }

  9. //判断当前桶中是否只有唯一值 有的桶中可能只有一种值,但是有多个重复项

  10. function unique(barrel) {

  11.  return new Set(barrel).size <= 1;

  12. }

  13. Array.prototype.radixSort = function () {

  14.  let result = [];

  15.  let figureNum = max(...this).toString().length;

  16.  this.splice(0, this.length, ...this.map(num => num.toString().padStart(figureNum, '0')));

  17.  radixGroup(this, 0, figureNum, result);

  18.  this.splice(0, this.length, ...result.map(numStr => Number(numStr)));

  19. };

  20. function radixGroup(group, index, figureNum, result) {    //输入的group是一组numStr,index是当前分桶依据第几位数

  21.  if (index < figureNum) {

  22.    let barrel = initBarrel();

  23.    group.forEach(numStr => {

  24.      let idx = Number(numStr[index]);

  25.      barrel[idx].push(numStr);

  26.    });

  27.    barrel.forEach(subBarrel => {

  28.      if(unique(subBarrel)) {

  29.        subBarrel.forEach(num => {

  30.          result.push(num);

  31.        })

  32.      }

  33.      else {

  34.        radixGroup(subBarrel,index+1,figureNum,result);

  35.      }

  36.    })

  37.  }

  38. }

  39. let arr = [1234342, 52165, 75, 1, 356, 575, 765433212, 57994, 3535];

  40. arr.radixSort();

  41. console.log(arr);

9.快速排序

将数组头部的元素pivotNum作为一个基准,通过两个指针指向数组的头部和尾部,经过一次partition以后将pivotNum放在一个位置pivot,pivot前面的数小于pivotNum,后面的数大于pivotNum。 为了防止最坏情况的发生,可以在数组中随机选出一个数来与数组头部元素换位置,来降低具体实例与最坏情况的关联性。

 
   
   
 
  1. const {floor, random} = Math;

  2. function randomIndex(start, end) {

  3.  return floor(random() * (end - start + 1)) + start;

  4. }

  5. function partition(arr, start, end) {

  6.  let index = randomIndex(start, end);

  7.  [arr[start], arr[index]] = [arr[index], arr[start]];

  8.  let value = arr[start];

  9.  while (start < end) {

  10.    while (start < end && arr[end] > value) end--;

  11.    arr[start] = arr[end];

  12.    while (start < end && arr[start] < value) start++;

  13.    arr[end] = arr[start];

  14.  }

  15.  arr[start] = value;

  16.  return start;

  17. }

  18. function quickSort(arr, start, end) {

  19.  if (start < end) {

  20.    let pivot = partition(arr, start, end);

  21.    quickSort(arr, start, pivot - 1);

  22.    quickSort(arr, pivot + 1, end);

  23.  }

  24. }

  25. Array.prototype.quickSort = function (asc = true) {

  26.  quickSort(this, 0, this.length - 1, asc)

  27. };

  28. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  29. arr.quickSort();

  30. console.log(arr);

10.堆排序 将数组看做完全二叉树,因此节点i的左右子节点的索引分别为2i+1与2i+2。通过从根节点开始令小的值下沉,或者从最后的叶节点开始令大的值上浮的方法,将一个数组构造成一个大根堆。再将大根堆的头元素与尾元素换位置,这样就将当前最大值置换到了尾部。然后下次构建大根堆的时候,将刚置换过的尾部元素刨除在外不做为节点。

 
   
   
 
  1. const {floor, max} = Math;

  2. function getBiggestNodeIndex(...nodes) {

  3.  return nodes.indexOf(max(...nodes));

  4. }

  5. //将arr从0开始,长度为length的子数组构建为堆

  6. function constructHeap(arr, length) {

  7.  let adjusted = true;  //adjusted来标识本次堆是否作出了调整,若未调整说明堆已构建完毕

  8.  while (adjusted) {

  9.    adjusted = false;

  10.    for (let i = 0; i < floor(length / 2); i++) {

  11.      //当只有左节点时

  12.      if (2 * i + 2 === length) {

  13.        //当父节点比左节点小的时候

  14.        if (arr[i] < arr[2 * i + 1]) {

  15.          //互换

  16.          [arr[i], arr[2 * i + 1]] = [arr[2 * i + 1], arr[i]];

  17.          adjusted = true;

  18.        }

  19.      }

  20.      //当同时有左节点和右节点时

  21.      else {

  22.        //判断三个中最大的节点

  23.        let biggestNodeIndex = getBiggestNodeIndex(arr[i], arr[2 * i + 1], arr[2 * i + 2]);

  24.        //若父节点不是最大的,则和最大的交换

  25.        //如果biggestNodeIndex为0,说明自己最大,为1,说明左节点大,为2,说明右节点大

  26.        switch (biggestNodeIndex) {

  27.          case 0:

  28.            break;

  29.          case 1:

  30.            [arr[i], arr[2 * i + 1]] = [arr[2 * i + 1], arr[i]];

  31.            adjusted = true;

  32.            break;

  33.          case 2:

  34.            [arr[i], arr[2 * i + 2]] = [arr[2 * i + 2], arr[i]];

  35.            adjusted = true;

  36.            break;

  37.        }

  38.      }

  39.    }

  40.  }

  41. }

  42. function heepSort(arr) {

  43.  //只将arr从0开始,长度为length的子数组构建成大根堆

  44.  let length = arr.length;

  45.  while (length > 1) {

  46.    constructHeap(arr, length);

  47.    [arr[0], arr[length-- - 1]] = [arr[length - 1], arr[0]];

  48.  }

  49. }

  50. Array.prototype.heepSort = function () {

  51.  heepSort(this);

  52. };

  53. let arr = [43, 21, 10, 5, 9, 15, 32, 57, 35];

  54. arr.heepSort();

  55. console.log(arr);


END



JavaScript教程
一周掌握js必要的知识点


戳“阅读原文”入群免费领取前端开发教程

以上是关于排序算法的Javascript实现的主要内容,如果未能解决你的问题,请参考以下文章

7种基本排序算法的Java实现

快速排序-递归实现

2.排序算法实现(JavaScript版)-冒泡-选择-快速排序

JavaScript算法(冒泡排序选择排序与插入排序)

基于JavaScript实现的八种排序算法的可视化实现

基于JavaScript实现的八种排序算法的可视化实现