算法类

最新推荐文章于 2024-05-10 18:03:43 发布
最新推荐文章于 2024-05-10 18:03:43 发布
阅读量63 收藏
点赞数
文章标签： 数据结构与算法 javascript ViewUI
原文链接：https://juejin.im/post/5bd6c36ce51d457a9b6c8604
版权
本文深入讲解了快速排序、选择排序和希尔排序等经典排序算法的实现原理与步骤，通过JavaScript代码示例，帮助读者理解算法背后的逻辑。同时，探讨了递归调用栈的概念，以及如何通过尾递归优化递归函数，避免调用栈溢出，提高程序运行效率。
摘要由CSDN通过智能技术生成

快速排序：

【参考资料】 https://segmentfault.com/a/1190000009426421

算法步骤
  • 先从数列中取出一个数作为“基准”。
  • 分区过程：将比这个“基准”大的数全放到“基准”的右边，小于或等于“基准”的数全放到“基准”的左边。
  • 再对左右区间重复第二步，直到各区间只有一个数。

var quickSort = function(arr) {
    if (arr.length <= 1) { return arr; }
    var pivotIndex = Math.floor(arr.length / 2);   //基准位置（理论上可任意选取）
    var pivot = arr.splice(pivotIndex, 1)[0];  //基准数
    var left = [];
    var right = [];
    for (var i = 0; i < arr.length; i++){
        if (arr[i] < pivot) {
            left.push(arr[i]);
        } else {
            right.push(arr[i]);
        }
    }
    return quickSort(left).concat([pivot], quickSort(right));  //链接左数组、基准数构成的数组、右数组
};复制代码

选择排序：

【参考资料】segmentfault.com/a/119000000…

算法步骤
  • 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置
  • 从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。
  • 重复第二步，直到所有元素均排序完毕。

function selectionSort(arr) {
    var len = arr.length;
    var minIndex, temp;
    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;                 // 将最小数的索引保存
            }
        }
        temp = arr[i];
        arr[i] = arr[minIndex];
        arr[minIndex] = temp;
    }
    return arr;
}复制代码

希尔排序：

【参考资料】segmentfault.com/a/119000000…

算法步骤
  • 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
  • 按增量序列个数 k，对序列进行 k 趟排序；
  • 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

function shellSort(arr) {
    var len = arr.length,
        temp,
        gap = 1;
    while(gap < len/3) {          //动态定义间隔序列
        gap = gap*3+1;
    }
    for (gap; gap > 0; gap = Math.floor(gap/3)) {
        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;
}复制代码

javaScript中递归的调用栈：

【参考资料】 segmentfault.com/a/119000000…

为了理解调用栈，我们回到factorial函数的例子。

function factorial(n) {
    if (n === 0) {
        return 1
    }

    return n * factorial(n - 1)
}

复制代码

如果我们传入参数3，将会递归调用factorial(2)、factorial(1)和factorial(0)，因此会额外再调用factorial三次。

每次函数调用都会压入调用栈，整个调用栈如下:

factorial(0) // 0的阶乘为1 
factorial(1) // 该调用依赖factorial(0)
factorial(2) // 该调用依赖factorial(1)
factorial(3) // 该掉用依赖factorial(2)复制代码

现在我们修改代码，插入console.trace()来查看每一次当前的调用栈的状态：

function factorial(n) {
    console.trace()
    if (n === 0) {
        return 1
    }

    return n * factorial(n - 1)
}

factorial(3)复制代码

接下来我们看看调用栈是怎样的。
第一个：

Trace
    at factorial (repl:2:9)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
    at REPLServer.onLine (repl.js:513:10)
    at emitOne (events.js:101:20)复制代码

你会发现，该调用栈包含一个对factorial函数的调用，这里是factorial(3)。接下来就更加有趣了，我们来看第二次打印出来的调用栈：

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
    at REPLServer.onLine (repl.js:513:10)复制代码

现在我们有两个对factorial函数的调用。

第三次：

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at repl:1:1
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)复制代码

第四次：

Trace
    at factorial (repl:2:9)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at factorial (repl:7:12)
    at repl:1:1
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)复制代码

设想，如果传入的参数值特别大，那么这个调用栈将会非常之大，最终可能超出调用栈的缓存大小而崩溃导致程序执行失败。那么如何解决这个问题呢？使用尾递归。

尾递归

尾递归是一种递归的写法，可以避免不断的将函数压栈最终导致堆栈溢出。通过设置一个累加参数，并且每一次都将当前的值累加上去，然后递归调用。

我们来看如何改写之前定义factorial函数为尾递归：

function factorial(n, total = 1) {
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}复制代码

factorial(3)的执行步骤如下：

factorial(3, 1) 
factorial(2, 3) 
factorial(1, 6) 
factorial(0, 6) 复制代码

调用栈不再需要多次对factorial进行压栈处理，因为每一个递归调用都不在依赖于上一个递归调用的值。因此，空间的复杂度为o(1)而不是0(n)。

接下来，通过console.trace()函数将调用栈打印出来。

function factorial(n, total = 1) {
    console.trace()
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}

factorial(3)复制代码

很惊讶的发现，依然有很多压栈!

// ...
// 下面是最后两次对factorial的调用
Trace
    at factorial (repl:2:9) // 3次压栈
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)
    at REPLServer.runBound [as eval] (domain.js:293:12)
Trace
    at factorial (repl:2:9) // 最后第一调用再次压栈
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at factorial (repl:7:8)
    at repl:1:1 // 请忽略以下底层实现细节代码
    at realRunInThisContextScript (vm.js:22:35)
    at sigintHandlersWrap (vm.js:98:12)
    at ContextifyScript.Script.runInThisContext (vm.js:24:12)
    at REPLServer.defaultEval (repl.js:313:29)
    at bound (domain.js:280:14)复制代码

这是为什么呢？
在Nodejs下面，我们可以通过开启strict mode, 并且使用--harmony_tailcalls来开启尾递归(proper tail call)。

'use strict'

function factorial(n, total = 1) {
    console.trace()
    if (n === 0) {
        return total
    }

    return factorial(n - 1, n * total)
}

factorial(3)复制代码

使用如下命令：

node --harmony_tailcalls factorial.js复制代码

调用栈信息如下：

Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)
Trace
    at factorial (/Users/stefanzan/factorial.js:3:13)
    at Object.<anonymous> (/Users/stefanzan/factorial.js:9:1)
    at Module._compile (module.js:570:32)
    at Object.Module._extensions..js (module.js:579:10)
    at Module.load (module.js:487:32)
    at tryModuleLoad (module.js:446:12)
    at Function.Module._load (module.js:438:3)
    at Module.runMain (module.js:604:10)
    at run (bootstrap_node.js:394:7)
    at startup (bootstrap_node.js:149:9)复制代码

你会发现，不会在每次调用的时候压栈，只有一个factorial。

注意：尾递归不一定会将你的代码执行速度提高；相反，可能会变慢。不过，尾递归可以让你使用更少的内存，使你的递归函数更加安全 (前提是你要开启harmony模式)。


转载于:https://juejin.im/post/5bd6c36ce51d457a9b6c8604

weixin_34290390
关注
计算机算法类毕业论文,算法论文范文 算法类有关大学毕业论文范文3000字
weixin_39663729的博客
07-17 3336
《基于模糊算法的教育群体评价》本文是关于算法方面硕士学位论文范文跟模糊算法和教育群体评价和算法有关本科毕业论文范文.摘 要：当前,能够对教师的劳动成果进行比较公正和合理的评价成为比较迫切的教学需要,而在进行评价的时候,首先考虑的是教师的教学质量情况以及教师的教学态度和科研成果等内容,而使得教师的绩效评价标准不断成为学校教学管理中比较重要的内容,而在对教师教学成果加以评价的传统方式为评估小组加以评价...
150道基础算法分类总结（2022）
小朱小朱绝不认输的博客
03-02 3162
在刷了一部分leetcode算法题之后，想要回头系统复习一下，发现刷的比较乱，特此整理一下，方便后续二刷，主要是对各种类型算法的一个分类，以及比较典型的题目的整理。 学习说明 题目来源lettcode 参考代码是用Java写的 供自己方便学习 算法分类 1. 二叉树 树也是一种非常重要的数据结构，因为很多容器的底层都设计到树，所以树也成了面试常问的重点了。特别是二叉树及二叉搜索树的算法。 二叉树的考点 题目来源 扩展 题解参考 二叉树的遍历（递归和迭代实现） 102. 二叉树的层序遍历
算法种类
zr7116的博客
07-08 196
算法类型
边做饭别写代码~！
08-25 691
（来源知乎） 二分还有扩展的 三分法 尺取法。 补充参考紫书。
算法工程师——算法岗的分类及要求汇总
SmiledrinkCat的博客
04-29 2373
对于计算机专业的毕业生而言，算法岗基本上就是 「高薪」 的代名词。在当今 IT 行业，算法工程师相比于开发工程师，技术要求会更高，当然工作难度也更大。大家可能会觉得：如果我没有名校光环，没有顶会论文，是不是根本不可能在算法岗的 PK 中脱颖而出？对于这样的疑问，我们希望能够为大家树立一点信心：名校光环/顶会论文不是顶级 offer 的充要条件，普通高校毕业却能拿到 SSP 的也大有人在。是否应试成功的关键，还是在于其本身的能力是否过关，以及与应聘岗位的需求是否 match。
雪花算法工具类（java文件下载直接用）
09-28
分布式全局唯一ID生成算法，
加密算法的重要性以及了解加密算法分类
dlfls0710的博客
07-21 6775
首先什么是加密算法： 加密算法的作用就是把一段信息（明文） 通过某种算法 转化为不能（易）看懂的信息 ->既密文 为什要用到加密算法 （加密算法的重要性）： 不论政府企业还是个人，运用加密算法的目的莫非与一下几点： 1）保密性 -> 防止个人情报的泄漏 例如我们的用户名与密码是user/password 而通过“加密”保护后就成为了 ee11cbb19052e40b07aac0ca060c23ee/ 5f4dcc3b5aa765d61d8327deb882cf99 (这里用的是MD5
十五个经典算法研究与总结
01-22
十五个经典算法研究与总结
算法的类型：
Java教程
03-14 3020
所有的算法可以大概分为以下三种类型： 1．贪婪算法(greedy algorithm) 该算法每一步所做的都是当前最紧急、最有利或者最满意的，不会考虑所做的后果，直到完成任务。这种算法的稳定性很差，很容易带来严重后果，但是，如果方向正确，那该算法也是高效的。 2．分治算法(divide-and-conquer algorithm) 该算法就是将一个大问题分解成许多小问题，然后单独处理这些小
面向对象——类设计（六）——算法类
03-16 1607
对于一个基于面向对象的数据聚类的基础类库（Class Library）而言，算法类（Algorithm）的设计是必不可少的一环。
算法精华版
oPerform的专栏
12-29 445
算法 具体类型 相关题目 讲解文章 排序算法 1. 冒泡排序 2. 插入排序 3. 选择排序 4. 希尔 Shell 排序 5. 快速排序 6. 归并排序 7. 堆排序 8. 线性排序算法 9. 自省排序 10. 间接排序 11. 计数排序 12. 基数排序 13. 桶排序 14. 外部排序 - k 路归并败者树 15. 外部排序 - 最佳归并树 递归与分治 ...
算法类（人工智能）公司城市分布
杰径通幽
10-24 4142
算法类公司城市分布 青岛 海信  海尔  鼎信  歌尔  小鸟看看 杭州 阿里  网易  海康  大华  蚂蚁金服  蘑菇街  深信服  华为  中移杭研  招银网络科技  宇视科技  中软国际  虹软  诺基亚  同花顺  有赞  九阳  花瓣网  贝贝网  曹操专车  丁香园  19楼  华数传媒  顺网科技  边锋科技  思科  亚信  个推 深圳 腾讯  华为  中...
算法有哪些分类
最新发布
qq_23314263的博客
05-10 807
这些分类只是算法领域中的一部分，实际上算法的种类非常丰富，并且随着技术的发展和问题的复杂化，新的算法和算法思想不断涌现。
几种典型的算法类型
Thomas_Cai的记忆殿堂
08-18 1858
文章目录一、 单调栈1. 套路2. 模板：3. leetcode例题：二、 并查集1. 套路：2. 模板：3. leetcode例题：三、 滑动窗口1. 套路2. 模板3. leetcode例题 一、 单调栈 https://leetcode-cn.com/problems/next-greater-element-i/solution/dan-diao-zhan-jie-jue-next-greater-number-yi-lei-w/ 1. 套路 1. 从已知容器的后往前存栈 2. 如果单调栈不为
推荐算法种类总结
Rnan_prince的博客
08-11 7874
（一）协同过滤（CF）大致可分为：基于邻域的推荐、基于模型的推荐 1.基于邻域的协同过滤有： 基于用户的协同过滤：与用户A相似的用户B，推荐用户A喜欢的物品给B 基于物品的协同过滤：推荐与用户A历史上喜欢的物品相近的物品 2.基于模型的推荐：使用部分机器学习算法，找出用户与项的相互作用模型，从而找出数据中的特定模式。 其中之前研究的NMF模型就是其中的一种，NMF属于基于模型的协同过滤算法...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值