常见排序算法和搜索算法的js实现

/**排序和搜索算法 
 * 以下算法实现顺序为从小到大
 * 以下算法按照一般情况下性能逐渐提升排列的
 * 首先要学会如何排序，然后在搜索我们需要的信息
*/

/**
 * 冒泡排序
 * 最简单但是运行时间最长
 * 思想：比较所有相邻的两项，如果第一个比第二个大，则交换它们。元素项向上移动至正确的顺序，就好像气泡升至表面一样，冒泡排序因此得名
 * @param {*} array
 */
function bubbleSort(array){
    for(let i = 0; i < array.length; i++){
        for(let j = 0; j < array.length - 1; j++){
            if(array[j] > array[j+1]){
                /** 经典换值方式
                    let temp = array[j];
                    array[j] = array[j+1];
                    array[j+1] = temp;
                */

               [array[j], array[j+1]] = [array[j+1], array[j]]/**es6值互换 */
            }
        }
    }
    return array;
}

// console.log(bubbleSort([3,6,2,8,7,10,9,4,0,5,1]));

/**
 * 改进后的冒泡排序
 * 思想：从内循环减去外循环已经遍历过得次数，则可以避免内循环中所有不必要的比较
 * @param {*} array
 */
function modifiedBubbleSort(array){
    for(let i=0; i<array.length; i++){
        for(let j=0; j<array.length - 1 - i; j++){
            if(array[j] > array[j+1]) [array[j], array[j+1]] = [array[j+1], array[j]];
        }
    }
    return array;
}

// console.log(modifiedBubbleSort([3,6,2,8,7,10,9,4,0,5,1]));

/**
 * 选择排序
 * 选择排序是一种原址比较排序算法。
 * 思想：找到数据结构中的最小值并将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。
 * @param {*} array
 */
function selectionSort(array){
    for(let i=0; i<array.length-1; i++){
        let indexMin = i;
        for(let j=i+1; j<array.length; j++){
            if(array[indexMin] > array[j]) {
                indexMin = j;  //寻找最小值位置
            }
        }
        if(indexMin !== i){
            [array[i], array[indexMin]] = [array[indexMin], array[i]];  //交换当前遍历位置与最小值位置
        }
    }
    return array;
}

// console.log(selectionSort([3,6,2,8,7,10,9,4,0,5,1]));


/**
 * 插入排序
 * 思想：插入排序每次排一个数组项，以此方式构建最后的排序数组。假定第一项已经排序了。接着，它和第二项进行比较，判断第二项是待在原位还是插入第一项之前，然后头两项就正确排序，再比较第三项，判断第三项是插入到第一、第二还是第三的位置，然后前三项就排好了顺序，以此类推，直至数组排序完成
 * 排序小型数组时，插入排序比选择排序和冒泡排序性能要好
 * @param {*} array
 */
function insertSort(array){
    let temp;
    for(let i=0; i<array.length; i++){
        let j = i;
        temp = array[i];
        while(j > 0 && array[j-1] > temp){
            array[j] = array[j-1];
            j--;
        }
        array[j] = temp;
    }
    return array;
}
// console.log(insertSort([3,6,2,8,7,10,9,4,0,5,1]));

/**
 * 归并排序
 * 归并排序是第一个可以实际使用的排序算法，上述三个算法性能不好，但归并排序性能不错
 * 归并排序是一种分而治之算法。
 * 思想：将原始数组切分成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。
 * 由于是分治法，归并排序也是递归的。要将算法分为两个函数：第一个负责将一个大数组分为多个小数组并调用另一个用来排序的辅助函数。
 * @param {*} array
 */
function mergeSort(array){
    //用来排序的辅助函数, 负责合并和排序小数组来产生大数组，直到回到原始数组并已排序完成
    function merge(left, right){
        let i = 0;
        let j = 0;
        const result = [];
        while(i < left.length && j < right.length){
            result.push(
                left[i] < right[j] ? left[i++] : right[j++]
            );
        }
        return result.concat(i < left.length ? left.slice(i) : right.slice(j));
    }

    //分割成小数组
    if(array.length > 1){
        const {length} = array.length;
        const middle = Math.floor(length / 2);  //向下取整
        const left = mergeSort(array.slice(0, middle));
        const right = mergeSort(array.slice(middle, length));
        array = merge(left, right);
    }
    return array;
}


// console.log(insertSort([3,6,2,8,7,10,9,4,0,5,1]));


/**快速排序
 * 快速排序也是最常用的排序算法了，它的时间复杂度为o(nlog(n))，且性能通常比其他时间复杂度为O(nlog(n))的排序算法要好。
 * 和归并排序一样，快速排序也使用分而治之的方法，将原始数组分为较小的数组（当它并没有像归并排序那样将它们分割开）。
 * 思想：（快速排序比上述的排序算法要复杂一些）
 * （1）首先，从数组中选择一个值作为主元(pivot)，一般选择数组中间的那个值。
 * （2）创建两个指针(引用)，左边一个指向数组第一个值，右边一个指向数组最后一个值。移动左指针直到找到一个比主元大的值，接着，移动右指针直到找到一个比主元小的值，然后交换它们，重复这个过程，直到左指针超过了右指针。这个过程将使得比主元小的值都排在主元之前，而比主元大的值都排在主元之后。这一部叫做划分(partition)操作。
 * （3）接着，算法对划分后的小数组（较主元小的值组成的子数组，以及较主元大的值组成的子数组）重复之前的两个步骤，直至数组已完全排序。
 */
function quickSort(array){
    return function quick(array, left, right){
        if(array.length > 1){
            //第一件事是选择主元，有好几种方式。
            //最简单的一种是选择数组的第一个值(最左边的值)。然而，研究表明对于几乎排序的数组，这不是一个好的选择，它将导致该算法的最差表现。
            //另外一种方式是随机选择数组的一个值或是选择中间的值
            let index = Math.floor((left + right) / 2);
            let pivot = array[index]; //主元，这里选择了数组的中间值
            let i = left;
            let j = right;
            while(i <= j){
                while(array[i] < pivot){
                    i++;
                }
                while(array[j] > pivot){
                    j--;
                }
                if(i <= j){
                    [array[i], array[j]] = [array[j], array[i]];
                    i++;
                    j--;
                }
            }//划分过程
            index = i; //在划分结束后，将左指针的索引设置为新主元，用来创建子数组

            if(left < index - 1){
                //对小数组重复快排过程(值比主元小)
                quick(array, left, index - 1);
            }
            if(right > index){
                //对小数组重复快排过程(值比主元大)
                quick(array, index, right);
            }
        }
        return array;
    }(array, 0, array.length - 1);
}

// console.log(quickSort([3,6,2,8,7,10,9,4,0,5,1]));


/**分布式排序：使用已组织好的辅助数据结构（称为桶），然后进行合并，得到排好序的数组 */
/**计数排序
 * 计数排序是分布式排序。
 * 计数排序使用一个用来存储每个元素在原始数组中出现次数的临时数组。在所有元素都计数完成后，临时数组已排好序并可迭代以构建排序后的结果数组。
 * 计数排序是用来排序整数的优秀算法（它是一个整数排序算法），时间复杂度为 O(n+k)，其中k是临时计数数组的大小；但是，它确实需要更多的内存来存放临时数组。
 */
function contingSort(array){
    if(array.length < 2) return array;  //空或只有一个元素的数组无需排序

    const maxValue = function(array){
        let max = array[0];
        for(let i=1; i<array.length-1; i++){
            if(max < array[i]) max = array[i];
        }
        return max;
    }(array); //找到数组中的最大值，以便可以创建计数数组

    const counts = new Array(maxValue + 1); //创建计数数组，从索引0开始 直到 最大值索引+1
    array.forEach( element => {
        if(!counts[element]){
            counts[element] = 0; //为了确保递增操作成功，如果counts数组中用来计数某个元素的位置一开始没有用0初始化的话，将其复制为0
        }
        counts[element]++; //在counts数组中增加元素计数值。由于可能有多个元素有相同的值，要将元素按照原始数组中的出现次数进行相加。
    });//迭代数组中的每个元素
    let sortedIndex = 0; //需要一个辅助索引将值赋值到结果数组中的正确位置
    counts.forEach((count, i) => {
        while(count > 0){
            array[sortedIndex++] = i; //
            count--; 
        }//减少计数值，直到它的值为零，将值(i)加入结果数组
    }); //所有元素都计数后，迭代counts数组并构建排序后的结果数组。
    return array;
}

// console.log(contingSort([9,3,6,2,9,4,6,5,3]));



/**
 * 桶排序（也被称为箱排序）
 * 桶排序也是分布式排序算法
 * 思想：将元素分为不同的桶（较小的数组），再使用一个简单的排序算法，例如插入排序（用来排序小数组的不错的算法），来对每个桶进行排序。然后，将所有的桶合并为结果数组。
 * 我们将算法分为两个部分：第一个用于创建桶并将元素分布到不同的桶中，第二个包含对每个桶执行插入排序算法和将所有的桶合并为排序后的结果数组。
 * @param {*} array
 * @param {number} [bucketSize=5] 对于桶排序我们需要指定需要多少桶来排序各个元素，默认情况下会使用5个桶。桶排序在所有元素平均分到各个桶中时的表现最好。如果元素非常稀疏，则使用更多的桶会好。如果元素非常密集，则使用更少的桶会更好。因此我们允许 bucketSize 以参数形式传递。
 * @returns
 */
function bucketSort(array, bucketSize = 5){ 
    if(array.length < 2) return array;

    //创建桶并将元素分布到不同的桶中
    let minValue = array[0];
    let maxValue = array[0];
    for(let i=1; i<array.length; i++){ //迭代数组找到最大值和最小值
        if(array[i] < minValue){
            minValue = array[i];
        }
        else if(array[i] > maxValue){
            maxValue = array[i];
        }
    }
    const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1; //计算需要的桶的数目，最大值与最小值的差值除以桶的大小(即每个桶中分布的元素的个数)  【+1 保证最大值分布到对应索引的桶中】
    const buckets = []; //定义一个矩阵（多维数组），buckets中的每个位置包含了另一个数组
    for(let i=0; i<bucketCount; i++){
        //初始化每个桶
        buckets[i] = [];
    }
    for(let i=0; i<array.length; i++){
        //将元素分布到桶中，迭代数组中的每个元素
        const bucketIndex = Math.floor((array[i] - minValue)/bucketSize); //计算要将元素放到那个桶中
        buckets[bucketIndex].push(array[i]); //将元素插入正确的桶中
    }
     
    //将每个桶进行排序
    const sortedArray = []; //创建一个用作结果的新数组，这表示元素组不会被修改，我们会返回一个新数组
    for(let i=0; i<buckets.length; i++){ 
        //迭代每个可迭代的桶并应用插入排序
        if(buckets[i] != null){
            //可迭代的桶
            insertSort(buckets[i]); //应用插入排序，根据场景，还可以应用其他的排序算法，例如快速排序
        }
        sortedArray.push(...buckets[i]); //将排好序的桶中的所有元素加入结果数组中
    }
    return sortedArray;
}

// console.log(bucketSort([9,3,6,2,9,4,6,5,3]));


/**
 * 基数排序
 * 基数排序也是一种分布式排序算法。
 * 思想：它根据数字的有效位或基数（这也是它为什么叫基数排序）将整数分布到桶中。基数是基于数组中值的记数制的。
 * 比如，对于十进制数，使用的基数是10.因此，算法将会使用10个桶用来分布元素并且首先基于个位数字进行排序，然后基于十位数字，然后基于百位数字，以此类推。 
 * @param {*} array
 * @param {*} radixBase   基数
 */
function radixSort(array, radixBase = 10){
    if(array.length < 2) return array;

    let minValue = array[0];
    let maxValue = array[0];
    for(let i=1; i<array.length; i++){
        if(minValue > array[i]){
            minValue = array[i];
        }
        else if(maxValue < array[i]){
            maxValue = array[i];
        }
    }

    let significantDigit = 1; //既然基数排序也是用来排序整数，我们就从最后一位开始排序所有数。（这个算法也被修改成支持排序字母字符）
    while((maxValue - minValue) / significantDigit >= 1){
        //首先只会基于最后一位有效位(个位)对数字进行排序，在下次迭代时，会基于第二个有效位(十位)进行排序，然后是第三个有效位(百位)，以此类推，直到没有待排序的有效位，因此需要知道数组的最大最小值
        //若数组中包含的值都在1~9，则只会循环执行一次，若值都小于99，则循环会执行第二次，以此类推

        //基于当前有效位进行排序
        let bucketsIndex;
        const buckets = [];
        const aux = [];
        for(let i=0; i<radixBase; i++){
            //基于基数初始化桶
            buckets[i] = 0;
        }

        for(let i=0; i<array.length; i++){
            //基于数组中数的有效位进行计数排序
            bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase);
            console.log('bucketsIndex: ', bucketsIndex);
            buckets[bucketsIndex]++; //进行计数排序, buckets[bucketsIndex]包含等于bucketsIndex的个数
        }

        console.log(buckets);

        for(let i=1; i<radixBase; i++){
            //由于进行的是计数排序，还需要计算累计结果来得到正确的计数值
            buckets[i] += buckets[i-1]; //buckets[bucketsIndex]包含小于等于bucketsIndex的个数
        }

        console.log(buckets);

        for(let i=array.length - 1; i>=0; i--){
            //迭代原始数组中的每个元素
            bucketsIndex = Math.floor(((array[i] - minValue) / significantDigit) % radixBase); //再次获取它的有效位
            aux[--buckets[bucketsIndex]] = array[i]; //将其值移入到aux数组中（从buckets数组中减去它的计数值）
        }
        for(let i=0; i<array.length; i++){
            array[i] = aux[i]; //将aux数组中的每个值转移到原始数组中
        }
        significantDigit *= radixBase; //继续基于下一位有效位进行排序
    }
    return array;
}
// console.log(radixSort([9,3,6,2,9,4,6,5,3, 100, 1000]));



/**
 * 顺序搜索
 * 顺序或线性搜索是最基本的搜索算法。它的机制是： 将每一个数据将结构中的元素和我们要找的元素作比较。、
 * 顺序搜索是最低效的一种搜索算法
 *
 * @param {*} array
 * @param {*} value
 */
function sequentialSearch(array, value){
    for(let i=0; i<array.length; i++){
        if(array[i] === value){
            return i
        }
    }
    return -1;
}
// console.log(sequentialSearch([9,3,6,2,9,4,6,5,3, 100, 1000], 3));


/**
 * 二分搜索
 * 二分搜索算法的原理和猜数字游戏类似，就是有人说”我正想着一个1~100的数“的游戏，每回应一个数，那个人就会说这个数是高了、低了还是对了
 * 这个算法要求被搜索的数据结构已排序。以下是该算法遵循的步骤
 * （1）选择数组的中间值
 * （2）如果选中值是待搜索值，那么算法执行完毕（值找到了）
 * （3）如果待搜索值比选中值要小，则返回步骤1并在选种植左边的子数组中寻找（较小）
 * （4）如果待搜索值比选中值要大，则返回步骤1并在选中值右边的子数组中寻找（较大）
 *
 * @param {*} array
 * @param {*} value
 */
function binarySearch(array, value){
    const sortedArray = quickSort(array);  //先排序
    let low = 0; //设置边界指针
    let high = sortedArray.length - 1; //设置边界指针
    while(low <= high){ //当low小于等于high时
        const mid = Math.floor((low + high) / 2); //计算中间项索引
        const element = sortedArray[mid]; //获取中间项索引值
        //比较选中值和待搜索值
        if(element < value){
            //选中值小于待搜索值，则选择数组高半边并重新开始
            low = mid + 1;
        }
        else if(element > value){
            //选中值大于待搜索值，则选择数组低半边并重新开始
            high = mid - 1;
        }
        else {
            //选中值等待搜索值，返回选中值索引
            return mid;
        }
    }
    return -1; //未搜索到，返回-1
}

// console.log(binarySearch([9,3,6,2,9,4,6,5,3, 100, 1000], 6));  //注意最后输出的位置是排序后数组的元素位置


/**内插搜索
 * 内插搜索是改良的二分搜素。
 * 二分搜素总是检查mid位置上的值，而内插搜索可能会根据要搜索的值检查数组中的不同地方。
 * 这个算法要求被搜索的数据结构已排序，以下是该算法遵循的步骤：
 * （1）使用position公式选中一个值（公式的做法是：如果查找的值更接近array[high]则查找position旁更大的值，如果查找的值更接近array[low]则查找position位置旁更小的值。这个算法在数组中的值都是均匀分布时性能最好【delta会非常小】）
 * （2）如果这个值是待搜索值，则算法执行结束（值找到了）
 * （3）如果待搜索值比选中值要小，则返回步骤1并在选中值左边的子数组中寻找（较小）；
 * （4）如果待搜索值比选中值要大，则返回步骤1并在选中值右边的子数组中寻找（较大）。
 */
function interpolarionSearch(array, value){
    const sortedArray = quickSort(array);
    const {length} = sortedArray;
    let low = 0;
    let high = length - 1;
    let position = -1;
    let delta = -1;
    while(low <= high && value >= sortedArray[low] && value <= sortedArray[high]){
        delta = (value - sortedArray[low])/(sortedArray[high] - sortedArray[low]);
        position = low + Math.floor((high - low) * delta);
        if(sortedArray[position] === value) return position;
        if(sortedArray[position] < value){
            low = position + 1;
        }
        else{
            high = position - 1;
        }
    }
    return -1;
}

// console.log(interpolarionSearch([9,3,6,2,9,4,6,5,3, 100, 1000], 2)); //注意最后输出的位置是排序后数组的元素位置


/**
 * 随机算法：
 * 应用场景是： 需要将一个数组中的值进行随机排列。现实中的一个常见场景是洗扑克牌。
 * 下面介绍的是一种最有名的算法：Fisher-Yates随机
 * 它的含义是迭代数组，从最后一位开始并将当前位置和一个随机位置进行交换。这个随机位置比当前位置小。这样，这个算法可以保证随机过的位置不会再被随机一次（洗扑克牌的次数越多，随机效果越差）
 *
 * @param {*} array
 */
function shuffle(array){
    for(let i = array.length - 1; i > 0; i--){
        const randomIndex = Math.floor(Math.random() * (i + 1));
        [array[randomIndex], array[i]] = [array[i], array[randomIndex]];
    }
    return array;
}
console.log(shuffle([9,3,6,2,9,4,6,5,3,100,10000])); 



/**分而治之算法
 * 例如：归并排序和快速排序算法
 * 分而治之算法可以分成三个部分
 * （1）分解原问题为多个子问题（原问题的多个小实例）。
 * （2）解决子问题，用返回解决子问题的方式的递归算法。递归算法的基本情形可以用来解决子问题。
 * （3）组合这些子问题的解决方式，得到原问题的解。
 */

 /**动态规划（dynamic programming, DP）
  * 动态规划是一种将复杂问题分解成更小的子问题来解决的优化技术
  * 注意：动态规划和分而治之是不同的方法。分而治之方法是把问题分解成相互独立的子问题，然后组合它们的答案。而动态规划则是将问题分解成相互依赖的子问题。
  * 动态规划的一个例子：斐波那契问题。我们将斐波那契问题分解成了一些小问题。
  * 用动态规划解决问题时，要遵循三个重要步骤：
  * （1）定义子问题；
  * （2）实现要反复执行来解决子问题的部分（这一步要参递归的步骤）；
  * （3）识别并解出基线条件。
  * 能用动态规划解决的一些著名问题：
  * 背包问题：给出一组项，各自有值和容量，目标是找出总值最大的项的集合。这个问题的限制是：总容量必须小于等于”背包“的容量
  * 最长公共子序列：找出一组序列的最长公共子序列（可由另一序列删除元素但不改变余下元素的顺序而得到）
  * 矩阵链相乘：给出一系列矩阵，目标是找到这些矩阵相乘的最高效办法（计算次数尽可能少）。相乘运算不会进行，解决方案是找到这些矩阵各自相乘的顺序。
  * 硬币找零：给出面额为d1,...,dn的一定数量的硬币和要找零的钱数，找出有多少种找零的方法。
  * 图的全源最短路径：对所有定点对(u,v)，找出从顶点u到顶点v的最短路径。
  **/

以上都是根据《学习JavaScript数据结构和算法》一书中的算法章节整理的，还有一些未尽之处，留待后期整理吧。