sort.js

JavaScript to achieve the ten common sorting algorithm library

  1 ;
 (function (global, factory) {
     // 兼容amd和cmd的写法
     // 基本的新式是 cmd ? cmd : amd ? amd : global || window
     typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
         typeof define === 'function' && define.amd ? define(factory) :
         (global.PAS = factory());
 })(this, (function () {
     // 判断是否数组
     function isArray(arr) {
         return typeof Array.isArray === 'function' ?
             Array.isArray(arr) :
             Object.prototype.toString.call(arr) === '[object Array]';
     }

     // 交换两个元素
     function swap(v1, v2, context) {
         [context[v1], context[v2]] = [context[v2], context[v1]];
         return void 0;
     }

     // 冒泡排序
     function bubble(arr) {
         let len = arr.length;
         for (let i = 0; i < len; i++) {
             for (let j = 0; j < len - 1 - i; j++) {
                 if (arr[j] > arr[j + 1]) {
                     swap(j, j + 1, arr)
                 }
             }
         }
         return arr;
     }

     // 插入排序
     function insert(arr) {
         let len = arr.length;
         let pIndex, current; // 前一个元素的索引，当前元素的值
         for (let i = 1; i < len; i++) {
             pIndex = i - 1;
             current = arr[i];

             // 依次把当前元素和前面的元素进行比较
             while (pIndex >= 0 && arr[pIndex] > current) {
                 // 比当前的元素大，向后移一位
                 arr[pIndex + 1] = arr[pIndex];
                 pIndex--;
             }
             // 插入当前元素到合适的位置
             arr[pIndex + 1] = current;
         }
         return arr;
     }

     // 快速排序 -- 这个方法不改变原数组
     function quick(arr) {
         let len = arr.length;

         if (len < 2) {
             return arr;
         }

         let middleIndex = Math.floor(len / 2); // 中间元素的索引值
         let baseValue = arr.splice(middleIndex, 1); // 基准值

         let left = []; // 保存小于基准值元素
         let right = []; // 保存大于或等于基准值元素

         for (let i = 0; i < arr.length; i++) {
             if (arr[i] < baseValue) {
                 left.push(arr[i]);
             } else {
                 right.push(arr[i]);
             }
         }
         return quick(left).concat(baseValue, quick(right));
     }

     // 选择排序
     function selection(arr) {
         let len = arr.length;
         let minIndex = 0; // 用于保存最小值的索引

         for (let i = 0; i < len - 1; i++) {
             minIndex = i;
             // 遍历后面的元素和当前认为的最小值进行比较
             for (let j = i + 1; j < len; j++) {
                 if (arr[minIndex] > arr[j]) {
                     // 比认为的最小值小 交换索引
                     minIndex = j;
                 }
             }
             // 找到最小值和当前值交换
             if (minIndex !== i) {
                 swap(minIndex, i, arr);
             }
         }
         return arr;
     }

     // 归并排序
     function merge(arr) {
         let len = arr.length;
         if (len < 2) {
             return arr;
         }
         let middleIndex = Math.floor(len / 2); // 获取中间元素的索引
         let left = arr.slice(0, middleIndex); // 获取左半部分的元素
         let right = arr.slice(middleIndex); // 获取右半部分的元素

         let merges = function (left, right) {
             // 保存结果的数组
             let result = [];

             while (left.length && right.length) {
                 if (left[0] < right[0]) {
                     result.push(left.shift())
                 } else {
                     result.push(right.shift())
                 }
             }

             // 如果左半边还有元素
             while (left.length) {
                 result.push(left.shift());
             }

             // 如果右半边还有元素
             while (right.length) {
                 result.push(right.shift());
             }

             return result;
         }

         return merges(merge(left), merge(right));
     }

     // 希尔排序
     function shell(arr) {
         let len = arr.length,
             temp,
             gap = 1;

         while (gap < len / 3) {
             gap = gap * 3 + 1;
         }

         for (gap; gap > 0; gap = Math.floor(gap / 3)) {
             for (let i = gap; i < len; i++) {
                 temp = arr[i];
                 for (var j = i - gap; j >= 0 && arr[j] > temp; j -= gap) {
                     arr[j + gap] = arr[j];
                 }
                 arr[j + gap] = temp;
             }
         }
         return arr;
     }

     // 堆排序
     function heap(arr) {
         let len = arr.length;

         let heapify = function (
             arr // 待排序的数组
             , x // 元素的下标
             , len // 数组的长度
         ) {
             let l = 2 * x + 1;
             let r = 2 * x + 2;
             let largest = x;

             if (l < len && arr[l] > arr[largest]) {
                 largest = l;
             }

             if (r < len && arr[r] > arr[largest]) {
                 largest = r;
             }

             if (largest !== x) {
                 swap(x, largest, arr);
                 heapify(arr, largest, len);
             }
         }

         for (let i = Math.floor(len / 2); i >= 0; i--) {
             heapify(arr, i, len);
         }

         for (let i = len - 1; i >= 1; i--) {
             swap(0, i, arr);
             heapify(arr, 0, --len);
         }
         return arr;
     }

     // 基数排序
     function radix(arr) {
         const SIZE = 10;
         let len = arr.length;
         let buckets = [];
         let max = Math.max.apply(null, arr); // 数组中的最大值
         let maxLength = String(max).length; // 最大数字的长度

         // 进行循环将桶中的数组填充成数组
         for (let i = 0; i < SIZE; i++) {
             buckets[i] = [];
         }

         // 进行循环--对数据进行操作--放桶的行为
         for (let i = 0; i < maxLength; i++) {
             // 第二轮循环是将数据按照个位数进行分类
             for (let j = 0; j < len; j++) {
                 let value = String(arr[j]);
                 // 判断长度--进行分类
                 if (value.length >= i + 1) {
                     let num = Number(value[value.length - 1 - i]); // 依次的从右到左获取各个数字
                     //放入对应的桶中
                     buckets[num].push(arr[j]);
                 } else {
                     // 长度不满足的时候，就放在第一个桶中
                     buckets[0].push(arr[i]);
                 }
             }
             // 将原数组清空
             arr.length = 0;

             //这次循环是依次取出上面分类好的数组存放到原数组中
             for (let j = 0; j < SIZE; j++) {
                 // 获取各个桶的长度
                 let l = buckets[j].length;
                 // 循环取出数据
                 for (let k = 0; k < l; k++) {
                     arr.push(buckets[j][k]);
                 }
                 // 将对应的桶清空，方便下次存放数据
                 buckets[j] = [];
             }
         }
         return arr;
     }

     // 桶排序 -- 不改变原数组
     function bucket(arr, size = 5) {
         let len = arr.length;
         if (len < 2) {
             return arr;
         }

         // 获取最大值和最小值
         const max = Math.max.apply(null, arr);
         const min = Math.min.apply(null, arr);

         // 计算出桶的数量  size是截距
         const bucketCount = Math.floor((max - min) / size) + 1;
         // 根据桶的个数创建指定长度的数组
         const buckets = new Array(bucketCount);
         // 将每个桶塞到大桶里面去
         for (let i = 0; i < bucketCount; i++) {
             buckets[i] = [];
         }
         // 利用映射函数将数据分配到各个桶里面去
         for (let i = 0; i < arr.length; i++) {
             // 逢size进1
             let index = Math.floor((arr[i] - min) / size);
             buckets[index].push(arr[i]);
         }
         //对每个桶中的数据进行排序--借助于快速排序算法
         for (let i = 0; i < buckets.length; i++) {
             buckets[i] = quick(buckets[i]);
         }

         // flatten数组--有点不足就是会将原数组中的String改变为Number
         return buckets.join(',').split(',').filter(v => v !== '').map(Number);
     }

     // 计数排序
     function count(arr) {
         let index = 0;
         let len = arr.length;
         let min = Math.min.apply(null, arr); // 最小值
         let max = Math.max.apply(null, arr); // 最大值
         let result = []; // 结果数组

         // 向新数组中填充0
         for (let i = min; i <= max; i++) {
             result[i] = 0;
         }
         // 把各个数组中对应的元素计数加一
         for (let i = 0; i < len; i++) {
             result[arr[i]]++;
         }
         // 按照计数的元素进行排序
         for (let i = min; i <= max; i++) {
             while (result[i]-- > 0) {
                 arr[index++] = i;
             }
         }
         return arr;
     }

     const PAS = {};

     [
         bubble,
         insert,
         quick,
         selection,
         merge,
         shell,
         heap,
         radix,
         bucket,
         count
     ].forEach(function (func) {
         let name = func.name;
         //增加层外包装，判断参数是不是数组
         Object.defineProperty(PAS, name, {
             get: function () {
                 return function (args) {
                     if (!isArray(args)) {
                         throw new Error('the arguments of PAS.' + name + ' must be Array');
                     }
                     return func.call(null, args);
                 }
             },
             configurable: true
         })

         // 在数组的原型上添加方法
         Object.defineProperty(Array.prototype, name, {
             get: function () {
                 var vm = this;
                 return function () {
                     return func.call(vm, vm);
                 }
             },
             configurable: true
         })
     })

     return PAS;
 }))