10个js算法题目（详细注释+源码）

最新推荐文章于 2024-04-03 03:18:20 发布
最新推荐文章于 2024-04-03 03:18:20 发布
阅读量1.8k 收藏 32
点赞数 6
分类专栏： JavaScript学习 文章标签： 前端 js 算法小题目
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43666825/article/details/96606063
版权

10个js算法题目（详细注释+源码）

1、冒泡排序调优（从小到大排序）
2、输出九九乘法表
3、输出水仙花数
4、1–10的阶乘和
5、输出1900年至2100年中的所有闰年
6、输出10–100之间的所有素数
7、1，2，3，4四个数字,能组合成多少种互不相同且没有重复的三位数
8、取出四位数中的各个位上的数字
9、猴子吃桃问题
10、用星号输出菱形

Google Chrome Console运行结果

Google Chrome Console运行结果

源代码如下：

<!-- 
    @Author: Chauncey Yuan 
    @Date: 2019-07-19 19:43:13 
    @Last Modified by: Chauncey Yuan 
    @Last Modified time: 2019-07-20 14:20:26
-->
<!DOCTYPE html>
<html>

<head>
    <meta charset="utf-8">
    <title>js算法题目练习</title>
</head>

<body>
    <!-- 1、冒泡排序调优（从小到大排序） -->
    <script type="text/javascript">
        // 内容提示
        console.log("1、冒泡排序调优（从小到大排序）");
        // 定义任意长度的数组
        var a = [6, 9, 60, 10, 13, 15, 45, 78, 89, 17, 24, 34, 3];
        // 定义结果集，提示排序前的信息
        var result1 = "共有" + a.length + "个数参与排序\n";
        // 排序前的数据排列
        result1 += "排序前：\t";
        // 循环将排序前的数组放入结果集
        for (var x = 0; x < a.length; x++) {
            result1 += a[x] + "\t";
        }
        // 结果集换行
        result1 += "\n";
        // 只要排序算法如下：
        // 外层循环主要用来取数组中的数据
        for (var i = 0; i < a.length - 1; i++) {
            // 定义标志置0
            var flag = 0;
            // 内层循环用来取外层循环中取出的数中的后面的数
            for (var j = 0; j < a.length - 1 - i; j++) {
                // 如果后一个数小于前一个数，则互换位置
                if (a[j + 1] < a[j]) {
                    // 交换位置
                    b = a[j + 1];
                    a[j + 1] = a[j];
                    a[j] = b;
                    // 标志置1，表示此处有排序操作
                    flag = 1;
                }
            }
            // 如果标志为0，即未进行排序操作
            if (flag == 0) {
                // 跳出循环
                break;
                // 若没有这一个步骤，排序会在已经排好顺序之后继续排序，
                // 但是无实际操作，直到外层循环将每个数都取出排序才会停止，
                // 因此使用这样一个简单的调优操作
            }
            // 讲每一次排序的结果存入结果集，直到未进行排序时结束
            result1 += "第" + (i + 1) + "次：\t";
            for (var c = 0; c < a.length; c++) {
                result1 += a[c] + "\t";
            }
            // 每次排序结果存入结果集后，增加换行，进行区别
            result1 += "\n";
        }
        // 讲排序后的最终结果加入结果集中
        result1 += "排序后：\t";
        for (var c = 0; c < a.length; c++) {
            result1 += a[c] + "\t";
        }
        // 输出最终的整个排序结果
        console.log(result1);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 2、输出九九乘法表 -->
    <script type="text/javascript">
        // 内容提示
        console.log("2、输出九九乘法表：");
        // 定义一个string类型的变量，用于存放乘法表结果
        var output2 = "";
        // 第一层循环，第一个因数，1~9
        for (var i = 1; i <= 9; i++) {
            // 第二层循环，第二个因数，1~i
            for (var j = 1; j <= i; j++) {
                // j*i = j * i，制表符用来对齐
                output2 += j + "*" + i + "=" + i * j + "\t";
            }
            // 每一行输出后，增加换行
            output2 += "\n";
        }
        // 输出乘法表结果
        console.log(output2);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 3、输出水仙花数 -->
    <script type="text/javascript">
        // 内容提示
        console.log("3、输出水仙花数");
        // 定义三个变量，用于取出三位数的百位，十位，千位
        var a = 0,
            b = 0,
            c = 0;
        // 定义一个string类型的变量，用于存放计算结果
        var output3 = "水仙花数有：";
        // 从101到999循环，水仙花数是一个三位数
        for (var num = 101; num <= 999; num++) {
            // 取出百位
            a = parseInt(num / 100);
            // 取出十位
            b = parseInt(num % 100 / 10);
            // 取出个位
            c = parseInt(num % 100 % 10);
            // 判断是否满足水仙花数的条件
            if (a * a * a + b * b * b + c * c * c == num) {
                // 将满足条件的数存入结果
                output3 += num + " ";
            }
        }
        // 输出结果
        console.log(output3);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 4、1--10的阶乘和 -->
    <script type="text/javascript">
        // 内容提示
        console.log("4、1--10的阶乘和");
        // 定义结果
        var result = 0;
        // 定义阶乘结果
        var factorial = 1;
        // 第一层循环表示从1到10循环
        for (var i = 1; i <= 10; i++) {
            // 第二层循环表示求1到10的每一个数的阶乘的过程
            for (var j = 1; j <= i; j++) {
                // 求阶层的方法
                factorial = factorial * j;
            }
            // 将每次循环的阶乘结果加到定义的结果中
            result = result + factorial;
            // 阶乘结果每次循环之后回到初始值
            factorial = 1;
        }
        // 输出最终的阶乘和的结果
        console.log("1--10的阶乘和为：" + result);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 5、输出1900年至2100年中的所有闰年 -->
    <script type="text/javascript">
        // 内容提示
        console.log("5、输出1900年至2100年中的所有闰年");
        // 定义结果集，并给出提示，用于储存结果
        var result5 = "1900年至2100年中的所有闰年有：\n";
        // 设置一个标志，用来判断每行是否有5个年份
        var flag = 0;
        // 1900-2100循环，依次计算
        for (var year = 1900; year <= 2100; year++) {
            // 判断是都满足闰年的条件
            if ((parseInt(year % 4) == 0) && (((parseInt(year % 100) != 0)) || (parseInt(year % 400) == 0))) {
                // 满足条件的年份放入结果集中并加入空格隔开
                result5 += year + "\t";
                // 每往结果集中放一个年份标志加1
                flag++;
            }
            // 如果标志等于5，表示每一行有了5个年份，需要换行操作
            if (flag == 5) {
                // 结果集中加入换行
                result5 += "\n";
                // 重置标志
                flag = 0;
            }
        }
        // 输出最终结果
        console.log(result5);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 6、输出10--100之间的所有素数 -->
    <script type="text/javascript">
        // 内容提示
        console.log("6、输出10--500之间的所有素数");
        // 定义结果集，用于储存后面计算得出的素数并提示
        var primeNumbers = "10--500之间的所有素数有：\n";
        // 定义一个是否到了5的标志，用于后面控制是否一行有5个数字
        var areFive = 0;
        // 10到500循环，一次利用下面的算法进行判断
        for (var num = 10; num <= 500; num++) {
            // 定义标志，用来判断能不能被除1和自己本身的其他数整除
            var flag = true;
            // 用第一次循环中的每一个数，来除以除1和他本身的之间的所有整数
            for (var i = 2; i <= num - 1; i++) {
                // 判断这个数除以除1和他本身的之间的所有整数是否有能被整除的情况
                if (num % i == 0) {
                    // 如果能被除1和他本身的之间的所有整数整除，标志设置为false
                    flag = false;
                    // 跳出本次循环，当前数字不是素数
                    break;
                }
            }
            // 如果标志flag在上一步没有被设置成false，表示该数为素数
            if (flag == true) {
                // 将该次循环中的数字放入结果集中，并增加制表符来对齐
                primeNumbers += num + "\t\t";
                // 每写入一个素数，判断是否有5个的标志增加1
                areFive++;
            }
            // 如果判断是否有5个的标志到了5
            if (areFive == 5) {
                // 给结果集增加一个换行
                primeNumbers += "\n";
                // 重置标志
                areFive = 0;
            }
        }
        // 输出最终的结果
        console.log(primeNumbers);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 7、1，2，3，4四个数字,能组合成多少种互不相同且没有重复的三位数 -->
    <script type="text/javascript">
        // 内容提示
        console.log("7、1，2，3，4四个数字,能组合成多少种互不相同且没有重复的三位数");
        // 定义记数标志
        var count = 0;
        // 定义结果集，存放结果
        var result7 = "能组合成的互不相同且没有重复的三位数有:\n";
        // 三次循环表示三位数，每次循环，都是1，2，3，4
        for (var i = 1; i <= 4; i++) {
            for (var j = 1; j <= 4; j++) {
                for (var k = 1; k <= 4; k++) {
                    // 如果三个数字都不相等
                    if (i != j && j != k && k != i) {
                        // 组合成一个三位数
                        var sum = 100 * i + 10 * j + k;
                        // 存储到结果集中
                        result7 += sum + "  ";
                        // 记数标志加1
                        count++;
                    }
                }
            }
        }
        // 换行后在结果中加入种数
        result7 += "\n一共有" + count + "种";
        // 输出结果
        console.log(result7);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 8、取出四位数中的各个位上的数字 -->
    <script type="text/javascript">
        // 内容提示
        console.log("8、取出四位数中的各个位上的数字：");
        //定义一个四位数 
        var num = 4578;
        // 输出原四位数
        console.log("原四位数是：" + num);
        // 取出千位
        var a = num / 1000;
        // 取出百位
        var b = num % 1000 / 100;
        // 取出十位
        var c = num % 1000 % 100 / 10;
        // 取出个位
        var d = num % 1000 % 100 % 10;
        //取出个位的另一种
        //var d = num % 10;
        console.log("千位是：" + parseInt(a) + "，百位是：" + parseInt(b) + "，十位是：" + parseInt(c) + "，个位是：" + parseInt(d));
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 9、猴子吃桃问题 -->
    <script type="text/javascript">
        // 内容提示
        console.log("9、猴子吃桃问题：");
        console.log("猴子吃桃子问题：猴子第一天摘下N个桃子，当时就吃了一半，还不过瘾，就又吃了一个。");
        console.log("\t\t\t第二天又将剩下的桃子吃掉一半，又多吃了一个。以后每天都吃前一天剩下的一半零一个。");
        console.log("\t\t\t到第10天在想吃的时候就剩一个桃子了。求第一天共摘下来多少个桃子？");
        // 定义总数
        var sum = 1;
        // 按照题目从第10天往前计算
        for (var i = 1; i < 10; i++) {
            sum = (sum + 1) * 2;
        }
        // 输出结果
        console.log("计算答案：第一天共摘下来的桃子个数是" + sum + "个");
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>

    <!-- 10、用星号输出菱形 -->
    <script type="text/javascript">
        // 内容提示
        console.log("10、用星号输出菱形");
        // 定义结果集，用来存放星号和空格
        var result10 = "";
        // 定义菱形宽度
        var width = 10;
        // 菱形上半部分，循环递增
        for (var i = 1; i <= width; i++) {
            // 菱形上半部分，空格递减
            for (var a = width - i; a >= 1; a--) {
                result10 += " ";
            }
            // 菱形上半部分，星号递增
            for (var j = 1; j <= i * 2 - 1; j++) {
                result10 += "*";
            }
            // 每一行结束后换行
            result10 += "\n";
        }
        // 菱形下半部分，循环递减
        for (var i = width - 1; i >= 1; i--) {
            // 菱形下半部分，空格递增（递减的递减）
            for (var a = width - i; a >= 1; a--) {
                result10 += " ";
            }
            // 菱形下半部分，星号递减（递减的递增）
            for (var j = 1; j <= i * 2 - 1; j++) {
                result10 += "*";
            }
            result10 += "\n";
        }
        console.log(result10);
        // 输出换行，区分下一块内容
        console.log("\n");
    </script>
</body>

</html>
袁成新（Chauncey Yuan）
关注
  • 6
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
js中基础算法题
LiuYQing的博客
09-02 364
1.如何实现数组中的去重，即arr = [1,1,2,3,4,3,3,5,6,4]进行代码处理变成arr = [1,2,3,4,5,6] 案例分析： 1.需要一个去重后接收数据的新数组newArr=[] 2.循环遍历旧数组中的数据i=0;i<arr.length; 3.查找newArr中是否有当前遍历的旧数组中的当前值newArr.indexOf(arr[i])==-1 4.如果等于-1就说明newA...
面试常见的js算法题
10-20
本文主要介绍了面试常见的js算法题。具有很好的参考价值。下面跟着小编一起来看下吧
js的一些简单算法（包括一些经典力扣，持续解题）
D_Z_Yong的博客
02-18 1289
//判断str是否有数字 function strnum(str) { var a1 = new RegExp('[0-9]') var new_str = a1.test(str) return new_str } //计算两个数相乘的值，未知小数(求精度) function num(a, b) { var a1 = a.toString(); var...
js算法题
茉莉蜜茶~~~
11-24 1105
字符串、数组 简单算法
JavaScript经典算法（一）—(1)，2024最新前端大厂面试真题大全
m0_57472099的博客
04-03 561
从转行到现在，差不多两年的时间，虽不能和大佬相比，但也是学了很多东西。我个人在学习的过程中，习惯简单做做笔记，方便自己复习的时候能够快速理解，现在将自己的笔记分享出来，和大家共同学习。个人将这段时间所学的知识，分为三个阶段：第一阶段：HTML&CSS&JavaScript基础第二阶段:移动端开发技术第三阶段:前端常用框架推荐学习方式：针对某个知识点，可以先简单过一下我的笔记，如果理解，那是最好，可以帮助快速解决问题；如果因为我的笔记太过简陋不理解，可以关注我以后我还会继续分享。
自己总结的二十四道js算法题
11-19
js所有的算法，自己总结的，如有遗漏，请留言。希望可以帮助到需要的人
JS常见算法题整理
weixin_41082623的博客
08-23 7312
1.排序 1) 冒泡排序法： 1.比较相邻的两个元素，如果前一个比后一个大，则交换位置。 2.第一轮的时候最后一个元素是最大的一个。 3.按照步骤一的方法进行相邻两个元素的比较，由于最后一个元素已经是最大的了，因此最后一个元素不用比较。 例1： &lt;script&gt; var arr = [10,20,5,8,21,100,99]; function test() { ...
数据挖掘大作业-葡萄酒质量分析算法python源码+项目说明+详细注释+数据.zip
最新发布
04-12
数据挖掘大作业-葡萄酒质量分析算法python源码+项目说明+详细注释+数据.zip 数据挖掘大作业-葡萄酒质量分析算法python源码+项目说明+详细注释+数据.zip 数据挖掘大作业-葡萄酒质量分析算法python源码+项目说明+详细...
基于生物启发式算法的多智能体强化学习算法python源码+项目文档+详细注释+模型+示例图片.zip
04-10
基于生物启发式算法的多智能体强化学习算法python源码+项目文档+详细注释+模型+示例图片.zip 基于生物启发式算法的多智能体强化学习算法python源码+项目文档+详细注释+模型+示例图片.zip 基于生物启发式算法的多智能...
基于双目视觉的物体体积测量算法研究 （matlab源码+详细注释+项目说明+示例图片）.zip
04-10
基于双目视觉的物体体积测量算法研究 （matlab源码+详细注释+项目说明+示例图片）.zip 本文运用基于双目立体视觉的技术，提出一种快速非接触测量目标物体的体积方法。此方法将适用于多种场景下的目标体积测量，具有...
【高频】前端面试算法题，案例+答案，一学就会！
有事儿私信。
07-14 1124
虽然前端开发工作更加注重对HTML、CSS和JavaScript等技术的掌握，但算法和数据结构也是前端工程师应该具备的基本能力之一。很多公司的面试也会有算法这一环节。今天为大家总结了一些最常见的算法题。
JS的一些简单的算法题
feifeifeiQAQ的博客
07-22 592
1.计算整数的阶乘 如果用字母n来代表一个整数，阶乘代表着所有小于或等于n的整数的乘积。 function jiecheng(num) { var result =1; for(var i=1;i<=num;i++){ result*=i; } return result; } jiecheng(5);//5*4*3*2*1=120 2.冒泡排序 var a...
javascript常用经典算法实例详解
11-24
本文实例讲述了javascript常用算法。分享给大家供大家参考，具体如下： 入门级算法-线性查找-时间复杂度O(n)–相当于算法界中的HelloWorld //线性搜索(入门HelloWorld) //A为数组，x为要搜索的值 function linearSearch(A, x) { for (var i = 0; i < A.length; i++) { if (A[i] == x) { return i; } } return -1; } 二分查找(又称折半查找) – 适用于已排好序的线性结构 – 时间复杂度O(logN) //二分搜索 /
JS处理一些简单计算题
10-18
本篇文章通过JS来实现以下日常用经常用到的计算以及换算等小工具，有兴趣的朋友可以学习下。
Javascript 程序设计基础教程(第2版)_习题答案
04-11
Javascript 程序设计基础教程(第2版)_习题答案
前端经典算法题大全
weixin_43522687的博客
04-21 7216
1.判断一个单词是否是回文？ 回文是指把相同的词汇或句子，在下文中调换位置或颠倒过来，产生首尾回环的情趣，叫做回文，也叫回环。比如 mamam redivider . 很多人拿到这样的题目非常容易想到用for 将字符串颠倒字母顺序然后匹配就行了。其实重要的考察的就是对于reverse的实现。其实我们可以利用现成的函数，将字符串转换成数组，这个思路很重要，我们可以拥有更多的自由度去进行字符串的一些操...
javaScript常见手写算法题（前端笔记二）
m0_55337573的博客
05-08 86
js算法题、防抖和节流、大数相加、手写实现Promise、异步控制并发数
前端面试算法题
cxuyuanLch的博客
03-19 4269
1. 数组扁平化 . 数组是 JS 中使用频率仅次于对象的数据结构，官方提供了众多的 API。 今天我们来谈谈如何扁平化（flatten）数组。 扁平化就是将嵌套的数组变成一维数组的过程。 通常有几种方法可以实现扁平化： 第一个就是迭代递归法 var array = [[1,2,3],4,5,6,[[7]],[]] var result = flatten(array) console.log(result) for…of 实现 function flatten(arr, result = []) {
js经典计算题
susuzhe
03-15 3770
1.利用递归实现阶乘： //阶乘----递归方法 function jiecheng(n){ if(n>1) { return n*jiecheng(n-1); }else{ return 1; } } document.write(jiecheng(1000)); 2.递归实现斐波那契数列 function fei(n){ if(n>2){ ret
用c语言写一个冒泡算法并详细注释
04-04
以下是冒泡算法的C语言实现及注释： ```c #include void bubble_sort(int arr[], int n) { // 定义冒泡排序函数，接受一个整型数组和数组长度作为参数 int i, j, temp; for (i = 0; i ; i++) { // 外层循环控制...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值