彻底理解基本排序算法(js实现)

冒泡排序

最基本的排序算法之一.

   /**
     * 冒泡排序
     * 依次比较所有相邻元素,前边值大于后边值就交换.第一遍将最大值放到最后一位,
     * 第二遍,将第二大的值放到倒数第二位置,重复上面步骤直到最小值排到第一位.
     * @param {array} arr 
     */
    sortBubble(arr) {
        var len = arr.length;
        for (var i = 0; i < len - 1; i++) {
            for (var j = 0; j < len - 1 - i; j++) {
                // 相邻元素对比
                if (arr[j] > arr[j+1]) {        
                    this._swap(arr, j, j+1)
                }
            }
        }
        return arr;
    },

冒泡排序 优化

增加 flag , 当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序.优化并不明显.

    /**
     * 冒泡排序 - 优化
     * 依次比较所有相邻元素,前边值大于后边值就交换.第一遍将最大值放到最后一位,
     * 针对每个元素重复上面步骤
     * 增加 flag , 当在一趟序列遍历中元素没有发生交换，则证明该序列已经有序.
     * @param {array} arr 
     */
    sortBubbleExtend(arr) {
        var len = arr.length;
        for (var i = 0; i < len - 1; i++) {
            var flag = true;
            for (var j = 0; j < len - 1 - i; j++) {
                if (arr[j] > arr[j+1]) {        // 相邻元素比较
                    this._swap(arr, j, j+1)
                    flag = false;
                }
            }
            if(flag){break;}
        }
        return arr;
    },

选择排序

最基本的排序算法之一.
优点:数据长度越小越好。不占用额外的内存空间;

    /**
     * 选择排序
     * 第一遍先比较选择出最小值放到最前边,
     * 然后再比较选择出从第二个开始的最小值,依次类推
     * @param {array} arr 
     */
    sortSelection(arr) {
        var len = arr.length;
        var minIndex;
        for (var i = 0; i < len - 1; i++) {
            minIndex = i;
            for (var j = i + 1; j < len; j++) {
                if (arr[j] < arr[minIndex]) {     // 寻找最小值
                    minIndex = j;                 // 保存最小值的索引
                }
            }
            this._swap(arr, i, minIndex)
        }
        return arr;
    },

插入排序

构建一个有序序列，遍历未排序数据，扫描有序序列，找到相应位置并插入;
优点: 对几乎已经排好序的数据操作时，效率高;

    /**
     * 插入排序
     * 先将第一个元素看作有序排列,其他元素看作未排序,
     * 依次扫描未排序元素,将扫描到的元素插入有序序列的合适位置.
     * @param {array} arr 
     */
    sortInsertion(arr) {
        var len = arr.length;
        var preIndex, current;
        for (var i = 1; i < len; i++) {
            preIndex = i - 1;
            current = arr[i];
            while(preIndex >= 0 && arr[preIndex] > current) {
                arr[preIndex+1] = arr[preIndex];
                preIndex--;
            }
            arr[preIndex+1] = current;
        }
        return arr;
    },

折半排序 - 插入排序优化版

在查找插入位置时使用,折半查找法查找位置,再插入.

    /**
     * 折半排序 - 插入排序优化版
     * 在插入排序的基础上，
     * 在插入的时候运用了折半查找法查找要插入的位置，再进行插入.
     * @param {array} arr 
     */
    sortInsertionExtend(arr) {
        var low, high, temp, current;

        for (var i = 1; i < arr.length; i++) {
            if (arr[i] < arr[i - 1]) {
                current = arr[i];
                low = 0;
                high = i - 1;
                // 折半查找位置
                while (low <= high) {
                    var mid = Math.floor((low + high) / 2);
                    if (current > arr[mid]) {
                        low = mid + 1;
                    } else {
                        high = mid - 1;
                    }
                }
                // 插入
                for (temp = i; temp > low; --temp) {
                    arr[temp] = arr[temp - 1];
                }
                arr[temp] = current;
            }
        }

        return arr;
    },

希尔排序 - 插入排序优化版

利用插入排序 对几乎已经排好序的数据操作时效率高 的优点进行优化,将序列分割成多组,分别对多组进行排序,然后再对总体排序.

    /**
     * 希尔排序 
     * 将整个待排序的记录序列分割成为若干组子序列分别进行直接插入排序，
     * 待整个序列中的记录"基本有序"时，再对全体记录进行依次直接插入排序。
     * @param {array} arr 
     */
    sortShell(arr, n = 3) {
        var len = arr.length,
            temp,
            gap = 1;
        while(gap < len/n) {          //动态定义间隔序列
            gap =gap*n+1;
        }
        for (gap; gap > 0; gap = Math.floor(gap/n)) {
            for (var 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;
    },

归并排序

是一种建立再归并操作基础上的排序算法,采用递归或迭代实现.牺牲空间,换速率.

    /**
     * 归并排序 - 牺牲空间换速度
     * 是建立在归并操作上的一种有效的排序算法,采用递归或迭代方法实现
     * 1.申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列；
     * 2.设定两个指针，最初位置分别为两个已经排序序列的起始位置；
     * 3.比较两个指针所指向的元素，选择相对小的元素放入到合并空间，并移动指针到下一位置；
     * 4.重复步骤 3 直到某一指针达到序列尾；
     * 5.将另一序列剩下的所有元素直接复制到合并序列尾。
     * @param {array} arr 
     */
    sortMerge(arr) {  // 采用自上而下的递归方法
        var len = arr.length;
        if(len < 2) {
            return arr;
        }
        var middle = Math.floor(len / 2),
            left = arr.slice(0, middle),
            right = arr.slice(middle);
        return this._merge(this.sortMerge(left), this.sortMerge(right));
    },
    _merge(left, right)
    {
        var 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;
    },

快速排序

建立"基准",分区 :小于基准值放到左边,大于基准值放到右边;
递归实现 两个子序列 建立基准并分区.

    /**
     * 快速排序
     * 1.从数列中挑出一个元素，称为 "基准"（pivot）;
     * 2.分区，基准值小的摆放在基准前面，比基准值大的摆在基准的后面;
     * 3.递归方式把小于基准值元素的子数列和大于基准值元素的子数列排序
     * @param {*} arr 
     * @param {*} left 
     * @param {*} right 
     */
    sortQuick(arr, left, right) {
        var len = arr.length,
            partitionIndex,
            left = typeof left != 'number' ? 0 : left,
            right = typeof right != 'number' ? len - 1 : right;
    
        if (left < right) {
            partitionIndex = this._partition(arr, left, right);
            this.sortQuick(arr, left, partitionIndex-1);
            this.sortQuick(arr, partitionIndex+1, right);
        }
        return arr;
    },
    // 分区操作
    _partition(arr, left ,right) {     
        var pivot = left,                      // 设定基准值（pivot）
            index = pivot + 1;
        for (var i = index; i <= right; i++) {
            if (arr[i] < arr[pivot]) {
                this._swap(arr, i, index);
                index++;
            }        
        }
        this._swap(arr, pivot, index - 1);
        return index-1;
    },

堆排序

堆是一种类似二叉树的结构.堆排序一种利用堆的概念来排序的选择排序

    /**
     * 堆排序 - 类似二叉树结构
     * 一种利用堆的概念来排序的选择排序
     * 1.创建一个堆 H[0……n-1]；
     * 2.把堆首（最大值）和堆尾互换；
     * 3.把堆的尺寸缩小 1，并调用 shift_down(0)，目的是把新的数组顶端数据调整到相应位置；
     * 4.重复步骤 2，直到堆的尺寸为 1。
     * @param {*} arr 
     */
    sortHeap(arr) {
        this._buildMaxHeap(arr);
    
        for (var i = arr.length-1; i > 0; i--) {
            this._swap(arr, 0, i);
            this._len--;
            this._heapify(arr, 0);
        }
        return arr;
    },
    // 建立大顶堆
    _buildMaxHeap(arr) {
        this._len = arr.length;
        for (var i = Math.floor(this._len/2); i >= 0; i--) {
            this._heapify(arr, i);
        }
    },
    // 堆调整
    _heapify(arr, i) {
        var left = 2 * i + 1,
            right = 2 * i + 2,
            largest = i;

        if (left < this._len && arr[left] > arr[largest]) {
            largest = left;
        }

        if (right < this._len && arr[right] > arr[largest]) {
            largest = right;
        }

        if (largest != i) {
            this._swap(arr, i, largest);
            this._heapify(arr, largest);
        }
    },

基数排序

要求输入的数据必须是有确定范围的整数,(可用于扑克牌排序等)

    /**
     * 计数排序 - 要求输入的数据必须是有确定范围的整数
     * 将输入的数据值转化为键存储在额外开辟的数组空间中
     * 1.找出待排序的数组中最大和最小的元素
     * 2.统计数组中每个值为i的元素出现的次数，存入数组C的第i项
     * 3.对所有的计数累加（从C中的第一个元素开始，每一项和前一项相加）
     * 4.反向填充目标数组：将每个元素i放在新数组的第C(i)项，每放一个元素就将C(i)减去1
     * @param {*} arr 
     * @param {*} maxValue 
     */
    sortCounting(arr, maxValue) {
        var bucket = new Array(maxValue+1),
            sortedIndex = 0,
            arrLen = arr.length,
            bucketLen = maxValue + 1;
    
        for (var i = 0; i < arrLen; i++) {
            if (!bucket[arr[i]]) {
                bucket[arr[i]] = 0;
            }
            bucket[arr[i]]++;
        }
    
        for (var j = 0; j < bucketLen; j++) {
            while(bucket[j] > 0) {
                arr[sortedIndex++] = j;
                bucket[j]--;
            }
        }
    
        return arr;
    },

桶排序 - 计数排序的升级版

利用了函数的映射关系,可更快处理比计数排序更复杂的数值排序.

    /**
     * 桶排序 - 计数排序的升级版
     * 利用了函数的映射关系，高效与否的关键就在于这个映射函数的确定。
     * @param {*} arr 
     * @param {*} bucketSize 
     */
    sortBucket(arr, bucketSize = 5) {
        if (arr.length === 0) {
          return arr;
        }
    
        var i;
        var minValue = arr[0];
        var maxValue = arr[0];
        for (i = 1; i < arr.length; i++) {
          if (arr[i] < minValue) {
              minValue = arr[i];                // 输入数据的最小值
          } else if (arr[i] > maxValue) {
              maxValue = arr[i];                // 输入数据的最大值
          }
        }
    
        //桶的初始化
        var bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1;  
        var buckets = new Array(bucketCount);
        for (i = 0; i < buckets.length; i++) {
            buckets[i] = [];
        }
    
        //利用映射函数将数据分配到各个桶中
        for (i = 0; i < arr.length; i++) {
            cc.log(Math.floor((arr[i] - minValue) / bucketSize))
            buckets[Math.floor((arr[i] - minValue) / bucketSize)].push(arr[i]);
        }
    
        arr.length = 0;
        for (i = 0; i < buckets.length; i++) {
            this.sortInsertion(buckets[i]);                      // 对每个桶进行排序，这里使用了插入排序
            for (var j = 0; j < buckets[i].length; j++) {
                arr.push(buckets[i][j]);                      
            }
        }
    
        return arr;
    },

基数排序

将整数按位数切割成不同的数字，然后按每个位数分别比较.
可用于 日期或特定格式的浮点数,不仅限于整数.

    /**
     * 基数排序 - 非比较型整数排序算法
     * 将整数按位数切割成不同的数字，然后按每个位数分别比较。
     * @param {*} arr 
     * @param {*} maxDigit 
     */
    radixSort(arr, maxDigit = 9) {
        var mod = 10;
        var dev = 1;
        var counter = [];
        for (var i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
            for(var j = 0; j < arr.length; j++) {
                var bucket = parseInt((arr[j] % mod) / dev);
                if(counter[bucket]==null) {
                    counter[bucket] = [];
                }
                counter[bucket].push(arr[j]);
            }
            var pos = 0;
            for(var j = 0; j < counter.length; j++) {
                var value = null;
                if(counter[j]!=null) {
                    while ((value = counter[j].shift()) != null) {
                        arr[pos++] = value;
                    }
                }
            }
        }
        return arr;
    }

交换函数

    // 交换数组 下标位m 和n 的值函数
    _swap(arr, m, n) {
        var temp = arr[m];
        arr[m] = arr[n];
        arr[n] = temp;
    },

总结:算法无至境,最适合的才是最好的.