JavaScript中的常见算法

已于 2024-02-13 22:18:25 修改
阅读量931 收藏 17
点赞数 19
文章标签： 算法 前端 javascript 开发语言
于 2024-02-13 22:17:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_73810008/article/details/136107903
版权

一.排序算法

1.冒泡排序

        冒泡排序比较所有相邻的两个项，如果第一个比第二个大，则交换它们。元素项向上移动至 正确的顺序，就好像气泡升至表面一样。

function bubbleSort(arr) {
    const { length } = arr
    for (let i = 0; i < length - 1; i++) {
        for (let j = 0; j < length - i - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                [arr[j], arr[j + 1]] = [arr[j + 1], arr[j]]
            }
        }
    }
    return arr
}

arr = [3, 2, 5, 4, 7, 1]
console.log(bubbleSort(arr));  //[1, 2, 3, 4, 5, 7]

2.选择排序

         选择排序算法是一种原址比较排序算法。选择排序大致的思路是找到数据结构中的最小值并 将其放置在第一位，接着找到第二小的值并将其放在第二位，以此类推。

function selectSort(arr) {
    const { length } = arr
    let min
    for (let i = 0; i < length - 1; i++) {
        min = i
        for (let j = i; j < length; j++) {
            if (arr[j] < arr[min]) {
                min = j
            }
        }
        if (min !== i) {
            [arr[i], arr[min]] = [arr[min], arr[i]]
        }
    }
    return arr
}

3.插入排序 

如图所示，只可意会不可言传 

function insertSort(arr) {
    const { length } = arr
    let temp
    for (let i = 1; i < length; i++) {
        temp = arr[i]
        let j = i
        while (j > 0 && arr[j - 1] > temp) {
            arr[j] = arr[j - 1]
            j--
        }
        arr[j] = temp
    }
    return arr
}

4.归并排序 

        归并排序是一种分而治之算法。其思想是将原始数组切分成较小的数组，直到每个小数组只 有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组。

 图片详解：

function mergeSort(array) {
    if (array.length > 1) {
        const {
            length
        } = array;
        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;
}

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++]
        );
        console.log(result)
        //先push ，再++
    }
    return result.concat(i < left.length ? left.slice(i) : right.slice(j));
}

例如，如果 left = [3, 4] 和 right = [1, 2]，那么 merge 函数会按以下步骤操作：

  • 比较 left[0] 和 right[0]（3 和 1），因为 1 < 3，所以将 1 添加到 result，打印 [1]。
  • 然后比较 left[0] 和 right[1]（3 和 2），因为 2 < 3，所以将 2 添加到 result，打印 [1, 2]。
  • 由于 right 已经被完全遍历，将 left 剩余的元素（3 和 4）添加到 result，最终 result 为 [1, 2, 3, 4]。

 5.快速排序

         确立基准元素，根据其它元素与基准元素的大小比较，大的分为一组，小的分为一组，再在连接字符串的时候递归调用相应的方法，直至碰到递归调用的结束条件。

function quickSort(arr) {
    const { length } = arr
    //结束条件
    if (length < 2) {
        return arr
    }
    let base = arr[0]
    let minArr = arr.slice(1).filter(item => item <= base)
    let maxArr = arr.slice(1).filter(item => item >= base)
    return quickSort(minArr).concat(base).concat(quickSort(maxArr))
}

6.计数排序

        计数排序使用一个用来存储每个元素在原始数组中出现次数的临时数组。在所有元素都计数完成后，临时数组已排好序并可迭代以构建排序 后的结果数组。  

//缺点是浪费数组空间，最好是在要排序的数字比较连续紧凑的时候使用
function countSort(arr) {
    if (arr.length < 2) {
        return arr
    }
    const maxValue = Math.max(...arr)
    const counts = new Array(maxValue + 1)
    //让数组的值作为新数组的索引值，再进行计数
    arr.forEach(item => {
        if (!counts[item]) {
            counts[item] = 0
        }
        counts[item]++
    });

    let newArr = []
    let sortIndex = 0
    counts.forEach((item, index) => {
        while (item > 0) {
            newArr[sortIndex++] = index
            item--
        }
    })
    return newArr
}

7.桶排序

         桶排序（也被称为箱排序）也是分布式排序算法，它将元素分为不同的桶（较小的数组）， 再使用一个简单的排序算法，例如插入排序（用来排序小数组的不错的算法），来对每个桶进行 排序。然后，它将所有的桶合并为结果数组。  

function bucketSort(arr, bucketSize = 3) {
    if (arr.length < 2) {
        return arr
    }
    //根据数字的个数和大小，以及桶的容量创建数量合适的桶，将各数字分配到相应的桶里
    const buckets = createBuckets(arr, bucketSize)
    //调用相应的方法并返回成功排序了的数组
    return sortBucketsElement(buckets)
}

function createBuckets(arr, bucketSize) {
    let maxValue = Math.max(...arr)
    let minValue = Math.min(...arr)
    const bucketCount = Math.floor((maxValue - minValue) / bucketSize) + 1
    const buckets = [...Array(bucketCount)].map(() => [])
    for (let i = 0; i < arr.length; i++) {
        const bucketIndex = Math.floor((maxValue - minValue) / bucketSize)
        buckets[bucketIndex].push(arr[i])
    }
    return buckets
}

function sortBucketsElement(buckets) {
    const sortArr = []
    for (let i = 0; i < buckets.length; i++) {
        if (buckets[i]) {
            let newBucket = insertSort(buckets[i])
            sortArr.push(...newBucket)
        }
    }
    return sortArr

}

function insertSort(arr) {
    const { length } = arr
    let temp
    for (let i = 1; i < length; i++) {
        temp = arr[i]
        let j = i
        while (j > 0 && arr[j - 1] > temp) {
            arr[j] = arr[j - 1]
            j--
        }
        arr[j] = temp
    }
    return arr
}

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

8. 基数排序

         基数排序也是一个分布式排序算法，它根据数字的有效位或基数（这也是它为什么叫基数排 序）将整数分布到桶中。简单来说是根据最大数的位数来确定排序的次数，排序的时候分别从个位，十位，百位等分别进行排序。

function radixSort(arr) {
    const base = 10
    let divider = 1
    let max = Math.max(...arr)
    while (divider <= max) {
        const buckets = [...Array(10)].map(() => [])
        for (let i of arr) {
            buckets[Math.floor(i / divider) % base].push(i)
        }
        arr = [].concat(...buckets)
        console.log(arr);
        divider *= 10
    }
    return arr
}

二.搜索算法 

1.顺序搜索

        顺序或线性搜索是最基本的搜索算法。它的机制是，将每一个数据结构中的元素和我们要找 的元素做比较。顺序搜索是最低效的一种搜索算法。

function search(arr, value) {
    for (let i = 0; i < arr.length; i++) {
        if (value === arr[i]) {
            return i
        }
    }
    return -1
}

2. 二分搜索

function binarySearch(find, arr, start, end) {
    start = start || 0
    end = end || arr.length - 1
    arr = quickSort(arr)
    if (start <= end && find >= arr[start] && find <= arr[end]) {
        if (find === arr[start]) {
            return start
        }
        if (find === arr[end]) {
            return end
        }
        let mid = Math.ceil((start + end) / 2)
        if (arr[mid] === find) {
            return mid
        } else if (arr[mid] > find) {
            return binarySearch(find, arr, start, mid - 1)
        } else {
            return binarySearch(find, arr, mid + 1, end)
        }
    }
    return -1
}


function quickSort(arr) {
    const { length } = arr
    if (length < 2) {
        return arr
    }
    let base = arr[0]
    let minArr = arr.slice(1).filter(item => item <= base)
    let maxArr = arr.slice(1).filter(item => item >= base)
    return quickSort(minArr).concat(base).concat(quickSort(maxArr))
}

3.内插搜索 

        内插搜索是改良版的二分搜索。二分搜索总是检查 mid 位置上的值，而内插搜索可能会根 据要搜索的值检查数组中的不同地方。

//适合数值分布比较均匀的数组
function insertSearch(find, arr, start, end) {
    start = start || 0
    end = end || arr.length - 1
    arr = quickSort(arr)
    if (start <= end && find >= arr[start] && find <= arr[end]) {
        if (find === arr[start]) {
            return start
        }
        if (find === arr[end]) {
            return end
        }
        let mid = start + Math.floor((find - arr[start]) / (arr[end] - arr[start]) * (end - start))
        if (arr[mid] === find) {
            return mid
        } else if (arr[mid] > find) {
            return insertSearch(find, arr, start, mid - 1)
        } else {
            return insertSearch(find, arr, mid + 1, end)
        }
    }
    return -1
}



function quickSort(arr) {
    const { length } = arr
    if (length < 2) {
        return arr
    }
    let base = arr[0]
    let minArr = arr.slice(1).filter(item => item <= base)
    let maxArr = arr.slice(1).filter(item => item >= base)
    return quickSort(minArr).concat(base).concat(quickSort(maxArr))
}

 三.随机算法(洗牌算法)

        迭代数组，从最后一位开始并将当前位置和一个随机位置进行交换。这个随机位置比当前位置小。这样，这个算法可以保证随机过的位置不会再被随机一次。

function shuffleArray(array) {
  let n = array.length
  let random
  while (n != 0) {
    //对非负数进行向下取整
    random = (Math.random() * n--) >>> 0;
    [arr[n], arr[random]] = [arr[random], arr[n]]
  }
}

四.算法设计

1.分而治之

分而治之算法可以分成三个部分。

(1) 分解原问题为多个子问题（原问题的多个小实例）。

(2) 解决子问题，用返回解决子问题的方式的递归算法。递归算法的基本情形可以用来解决子 问题。

(3) 组合这些子问题的解决方式，得到原问题的解。

2.动态规划 

 2.1背包问题

背包问题是一个组合优化问题。它可以描述如下：给定一个固定大小、能够携重量 W 的背 包，以及一组有价值和重量的物品，找出一个最佳解决方案，使得装入背包的物品总重量不超过 W，且总价值最大。  

function knapSack(weights, values, w) {
    let n = weights.length - 1
    let f = [[]]
    for (let j = 0; j <= w; j++) {
        if (j < weights[0]) {
            f[0][j] = 0
        } else {
            f[0][j] = values[0]
        }
    }
    for (let j = 0; j <= w; j++) {
        for (let i = 1; i <= n; i++) {
            if (!f[i]) {
                f[i] = []
            }
            if (j < weights[i]) {
                f[i][j] = f[i - 1][j]
            } else {
                f[i][j] = Math.max(f[i - 1][j], f[i - 1][j - weights[i]] + values[i])
            }
        }
    }
    return f[n][w]
}

console.log(knapSack([2, 2, 6, 5, 4], [6, 3, 5, 4, 6], 10));

2.2找出最长公共子序列

找出两个字符 串序列的最长子序列的长度。最长子序列是指，在两个字符串序列中以相同顺序出现，但不要求 连续（非字符串子串）的字符串序列。  

 

function LCS(str1, str2) {
    var m = str1.length
    var n = str2.length
    var dp = [new Array(n + 1).fill(0)] //第一行全是0
    console.log(dp);
    for (var i = 1; i <= m; i++) { //一共有m+1行
        dp[i] = [0] //第一列全是0
        for (var j = 1; j <= n; j++) { //一共有n+1列
            if (str1[i - 1] === str2[j - 1]) {
                //注意这里，str1的第一个字符是在第二列中，因此要减1，str2同理
                dp[i][j] = dp[i - 1][j - 1] + 1 //对角＋1
            } else {
                dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - 1])
            }
        }
    }
    let res = printLCS(dp, str1, str2, m, n)
    return dp[m][n];
}


function printLCS(dp, str1, str2, i, j) {
    if (i === 0 || j === 0) {
        return ''
    }
    if (str1[i - 1] === str2[j - 1]) {
        return printLCS(dp, str1, str2, i - 1, j - 1) + str1[i - 1]
    } else {
        if (dp[i][j - 1] > dp[i - 1][j]) {
            return printLCS(dp, str1, str2, i, j - 1)
        } else {
            return printLCS(dp, str1, str2, i - 1, j)
        }
    }

}

console.log(LCS("abcadf", "acbaed")) //4

3.贪心算法

 在对问题求解时，总是做出在当前看来是最好的选择。也就是说，不从整体最优上加以考虑，他所做出的仅是在某种意义上的局部最优解。贪心算法不是对所有问题都能得到整体最优解，但对范围相当广泛的许多问题他能产生整体最优解或者是整体最优解的近似解。

function tanxin(capacity, weights, values) {
    let list = []
    let select = []
    let total = 0
    for (let i = 0; i < weights.length; i++) {
        list.push({
            num: i + 1,
            weight: weights[i],
            value: values[i],
            rate: values[i] / weights[i]
        })
    }
    list.sort((a, b) => b.rate - a.rate) //降序

    for (let j = 0; j < list.length; j++) {
        let item = list[i]
        if (item.weight <= capacity) {
            select.push({
                num: item.num,
                weight: item.weight,
                value: item.value,
                rate: 1
            })
            total = total + item.value
            capacity = capacity - item.weight
        } else if (item.capacity > capacity && capacity > 0) {
            let rate = capacity / item.weight
            select.push({
                num: item.num,
                weight: item.weight * rate,
                value: item.value * rate,
                rate
            })
            total = total + item.value * rate
            break
        } else {
            break
        }
    }
    return { select, total }
}

 4.回溯算法

 回溯法采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。

 给定一个 二维字符网格 board 和一个字符串单词 word
如果 word 存在于网格中，返回 true ；否则，返回 false
单词必须按照字母顺序，通过相邻的单元格内的字母构成
**二维数组：** board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]],
**目标：** word = "ABCCED"

function exist(board, word) {
    let row = board.length;  //行
    let col = board[0].length;  //列

    for (let i = 0; i < row; i++) {
        for (let j = 0; j < col; j++) {
            const ret = find(i, j, 0);
            if (ret) {
                return ret;
            }
        }
    }
    return false;

    function find(r, c, cur) {
        if (r >= row || r < 0) return false;
        if (c >= col || c < 0) return false;
        if (board[r][c] !== word[cur]) return false;
        if (cur == word.length - 1) return true;

        let letter = board[r][c];
        board[r][c] = null;

        const ret =
            find(r - 1, c, cur + 1) ||
            find(r + 1, c, cur + 1) ||
            find(r, c - 1, cur + 1) ||
            find(r, c + 1, cur + 1);
        //用null做标记是避免重复查找
        board[r][c] = letter;
        return ret;
    }
};

 五.总结

        还有诸多算法没有详细解读，随着自己的学习慢慢补充吧。 

GIS小小白
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JavaScript中常见排序算法详解共19页.pdf.z
11-21
JavaScript中常见排序算法详解共19页.pdf.zip
JS面试中常见的算法题
HAI_GUI的博客
03-11 3596
JavaScript面试中常见算法题
JavaScript常用基础算法
weixin_33805992的博客
05-06 345
为什么80%的码农都做不了架构师？>>> ...
JavaScript 中常见的搜索算法
玖尘的博客
06-13 626
JavaScript 中常见的搜索算法
JavaScript中常见排序算法详解共19页.pdf.zip
10-28
JavaScript中常见排序算法详解共19页.pdf.zip
Javascript中的常见排序算法
10-30
用JavaScript实现的常见排序算法:冒泡排序,选择排序,插入排序,谢尔排序,快速排序(递归),快速排序(堆栈),归并排序,堆排序。
Leetcode 41. 缺失的第一个正数和Leetcode 155. 最小栈
2301_79614379的博客
04-20 1078
定义一个结构体，数组 data 用于存放推进的数据，数组 min 用于存放最小值，变量 top 存放最后进入的数在 data 的下标，变量 mintop 记录最小值在 min 中的下标。循环遍历数组 nums ，如果该位置的值大于 0 并且不小于数组长度，让哈希表 table 在该值的位置自加。获取堆栈中的最小元素时，根据 mintop 的值返回数组 miin 中的元素。返回栈顶元素时，根据 top 的值返回数组 data 中的元素。--> 返回 -3.输入：nums = [3,4,-1,1]
力扣---从中序与后序遍历序列构造二叉树
m0_71536793的博客
04-20 462
力扣 中序遍历 后序遍历 建树
算法刷题-16
qq_45773834的博客
04-21 676
学习来源： leetcode，牛客 https://programmercarl.com https://www.yuque.com/taxing-qarr6/hxitgt/dedugmp09knerdi1
力扣HOT100 - 543. 二叉树的直径
qq_61504864的博客
04-23 171
【代码】力扣HOT100 - 543. 二叉树的直径。
视频质量评价 BRISQUE算法详细介绍
小金牛来了
04-21 67
视频质量评价 BRISQUE算法详细介绍
【算法学习】线段树基础版
weixin_55939638的博客
04-23 498
根结点维护的是区间1 到 4，结点权值是该区间的和，再将区间一份为二，其左儿子维护的是 1 - 2，右儿子维护的是 3 - 4 ，以此类推，直到结点维护的区间长度为1。线段树可以理解为一个二叉树，如果是利用线段树求区间的和，那么每个结点的权值维护的是结点所维护区间的和，再将该区间一分为二，分别交由左右儿子维护。从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；从根节点开始，目标区间和左子树有交集，递归左子树，目标区间和右子树有交集 ，递归右子树；
c语言-快速排序
ls3614140的博客
04-19 465
【代码】c语言-快速排序。
【Leetcode每日一题】 分治 - 数组中的第K个最大元素（难度⭐⭐）（63）
m0_73150338的博客
04-23 438
分治 - 数组中的第K个最大元素
代码随想录算法训练营DAY32|C++贪心算法Part.2|122.买卖股票的最佳时机II、55.跳跃游戏、45.跳跃游戏II
糖炒栗子
04-23 955
从上文可以看出，我们要比较当前范围下能扩充的最终范围。
38-数组 _ 一维数组
最新发布
weixin_63260114的博客
04-24 372
本文主要对一维数组进行了讲解，对数组的定义、创建以及初始化进行了阐述与代码介绍，并展示了一维数组的使用与在内存中的存储方式。
LeetCode39：组合总和
m0_50127633的博客
04-22 266
给你一个 无重复元素 的整数数组 candidates 和一个目标整数 target ，找出 candidates 中可以使数字和为目标数 target 的 所有 不同组合 ，并以列表形式返回。你可以按 任意顺序 返回这些组合。如果至少一个数字的被选数量不同，则两种组合是不同的。上个代码对于sum已经大于target的情况，其实是依然进入了下一层递归，只是下一层递归结束判断的时候，会判断sum > target的话就返回。对于给定的输入，保证和为 target 的不同组合数少于 150 个。
每日OJ题_BFS解决拓扑排序①_力扣207. 课程表
参考书籍：《C语言程序设计》《数据结构》、《C++ Primer》、《Effective C++》、《STL源码剖析》、《现代操作系统》、《图解TCP/IP》、《图解HTTP》、《Linux高性能服务器编程》、《剑指Offer》、《算法导论》
04-23 853
每日OJ题_BFS解决拓扑排序①_力扣207. 课程表（拓扑排序简单来说就是找到做事情的先后顺序（拓扑排序的结果可能不是唯一的）。原问题可以转换成一个拓扑排序问题。用BFS 解决拓扑排序即可。将所有入度为 0 的点加入到队列中。当队列不空的时候，一直循环以下三步：取出队头元素。将于队头元素相连的顶点的入度 - 1。然后判断是否减成 0。如果减成 0，就加入到队列中。）
Javascript算法
05-05
JavaScript算法是指在JavaScript语言中实现的各种算法。下面是一些常见的JavaScript算法： 1. 快速排序算法：快速排序是一种高效的排序算法，可以用JavaScript实现。它的时间复杂度为O(nlogn)。 2. 归并排序算法：归并排序也是一种高效的排序算法，可以用JavaScript实现。它的时间复杂度为O(nlogn)。 3. 二分查找算法：二分查找是一种常用的查找算法，可以用JavaScript实现。它的时间复杂度为O(logn)。 4. 哈希表算法：哈希表是一种常用的数据结构，可以用JavaScript实现。它的时间复杂度为O(1)。 5. 动态规划算法：动态规划是一种常用的优化算法，可以用JavaScript实现。它的时间复杂度根据具体问题而定。 6. 贪心算法：贪心算法是一种常用的求解最优解的算法，可以用JavaScript实现。它的时间复杂度根据具体问题而定。 7. 广度优先搜索算法：广度优先搜索是一种常用的搜索算法，可以用JavaScript实现。它的时间复杂度为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边数。 8. 深度优先搜索算法：深度优先搜索也是一种常用的搜索算法，可以用JavaScript实现。它的时间复杂度为O(|V|+|E|)，其中|V|表示顶点数，|E|表示边数。 以上是一些常见的JavaScript算法，还有很多其他的算法也可以用JavaScript实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值