js算法JavaScript

最新推荐文章于 2022-05-15 00:36:48 发布
最新推荐文章于 2022-05-15 00:36:48 发布
阅读量119 收藏 1
点赞数
分类专栏： js 文章标签： javascript 前端 小程序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack_rose_me/article/details/117992900
版权

18、重名的多个放前面

sortByGoods (filterSortList) {
        const groupMap = {}
        const printArray = []
        filterSortList.forEach(item => {
          if (!groupMap[item.goodsId]) {
            groupMap[item.goodsId] = []
          }
          if (item.pickedPrint !== 1) {
            groupMap[item.goodsId].push(item)
          } else {
            printArray.push(item)
          }
        })
        const repeatArray = []
        const onlyArray = []
        Object.values(groupMap).forEach(group => {
          if (group.length > 1) {
            repeatArray.push(group)
          } else {
            onlyArray.push(group)
          }
        })
        let newArray = []
        repeatArray.forEach(group => {
          newArray = newArray.concat(group)
        })
        onlyArray.forEach(group => {
          newArray = newArray.concat(group)
        })
        printArray.forEach(p => {
          newArray = newArray.concat(p)
        })
        return newArray
      },

17、字符串操作方法

// 1 字符方法
// charAt()      //获取指定位置处字符
// charCodeAt()    //获取指定位置处字符的ASCII码
// str[0]      //HTML5，IE8+支持 和charAt()等效

// // 2 字符串操作方法
// concat()      //拼接字符串，等效于+，+更常用
slice和substring接收的是起始位置和结束位置(不包括结束位置)，而substr接收的则是起始位置和所要返回的字符串长度
// slice(start, end)       //从start位置开始，截取到end位置，(不包括结束位置)
// substring(start, end)   //从start位置开始，截取到end位置，(不包括结束位置)，end不支持负数
// substr(start, end)      //从start位置开始，截取length个字符
// // 3 位置方法
// indexOf()     //返回指定内容在元字符串中的位置
// lastIndexOf()   //从后往前找，只找第一个匹配的
// // 4 去除空白   
// trim()      //只能去除字符串前后的空白
// // 5 大小写转换方法
// toUpperCase()   //转换大写
// toLowerCase()   //转换小写
// // 6 其它
// search()  比indexOf() 强大很多
// 方法用于检索字符串中指定的子字符串，或检索与正则表达式相匹配的子字符串。如果没有找到任何匹配的子串，则返回 -1。
// var str="Mr. Blue has a blue house";
// document.write(str.search(/blue/i));
// replace()
// split()

16、数组案例

<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <title>Document</title>
  <script>
    // 将一个字符串数组输出为|分割的形式，比如“刘备|张飞|关羽”。使用两种方式实现
    // var arr = ['刘备', '张飞', '关羽'];

    // // arr.toString();  ->  刘备,张飞,关羽
    // console.log(arr.join('|'));


    // 将一个字符串数组的元素的顺序进行反转。["a", "b", "c", "d"] -> [ "d","c","b","a"]。使用两种种方式实现。提示：第i个和第length-i-1个进行交换
    // 
    // var arr = ["a", "b", "c", "d"];
    // arr.reverse();
    // console.log(arr);

    // 工资的数组[1500, 1200, 2000, 2100, 1800],把工资超过2000的删除
    // var arr = [1500, 1200, 2000, 2100, 1800];

    // var newArray = arr.filter(function (item) {
    //   // item就是数组中的每一个元素
    //   return item < 2000;
    // })
    // console.log(newArray);

    // ['c', 'a', 'z', 'a', 'x', 'a']找到数组中每一个a出现的位置
    // var arr = ['c', 'a', 'z', 'a', 'x', 'a'];

    // 从前往后找元素
    // console.log(arr.indexOf('a'));
    // // 从后往前找
    // console.log(arr.lastIndexOf('a'));

    // indexOf的第二个参数 设置indexOf查找的开始位置
    // console.log(arr.indexOf('a', 2));
    // 如果没有找到元素 indexOf  会返回-1
    // 
    // while   do...while
    // var index = -1;
    // do {
    //   index = arr.indexOf('a', index + 1);

    //   if (index !== -1) {
    //     console.log(index);
    //   }
    // } while (index !== -1);
    



    // 编写一个方法去掉一个数组的重复元素['c', 'a', 'z', 'a', 'x', 'a']
    // ['c', 'a', 'z', 'a', 'x', 'a']  -> ['c', 'a', 'z', 'x']
    // 
    // 1 如何获取数组中每一个元素出现的次数
    // 1.1 遍历数组中的每一个元素
    // { c: 1
    // a: 1 + 1 + 1
    // z: 1
    // x: 1 }
    // 1.2 创建一个对象，把数组的元素作为对象的属性，并记录次数
    // 
    // var o = {};
    // console.log(o['c']);  // 我们访问对象中没有的属性，返回值是undefined
    function clear(arr) {
      // 1 如何获取数组中每一个元素出现的次数
      var o = {}; // 记录数组中元素出现的次数
      for (var i = 0; i < arr.length; i++) {
        var item = arr[i]; // 数组中的每一个元素
        // o[item] = 1;
        // 判断o对象是否有当前遍历到的属性
        if (o[item]) {
          // 如果o[item] 存在，说明次数不为1
          o[item]++;
        } else {
          // 如果o[item] 不存在，说明是第一次出现
          o[item] = 1;
        }
      }
      // console.log(o);

      // 2 生成一个新的数组，存储不重复的元素
      var newArray = [];
      // 遍历对象o中的所有属性
      for (var key in o) {
        // 判断o对象中当前属性的值是否为 1  如果为1 说明不重复直接放到新数组中
        if (o[key] === 1) {
          newArray.push(key);
        } else {
          // o对象中当前属性 次数不为1 ，说明有重复的，如果有重复的话，只存储一次
          // 判断当前的newArray数组中是否已经有该元素  
          if (newArray.indexOf(key) === -1) {
            newArray.push(key);
          }
        }
      }
      return newArray;
    } 

    var array = ['c', 'a', 'z', 'a', 'x', 'a'];
    var newArray = clear(array);
    console.log(newArray);
    
  </script>
</head>
<body>
  
</body>
</html>

15、Array 的常用方法

// toString()/valueOf()   每一个对象都具有这两个方法
// var arr = [5, 1, 8, 0];
// console.log(arr);
// // toString() 把数组转换成字符串，并且使用, 分割每一项
// console.log(arr.toString());
// // valueOf() 返回数组对象本身
// console.log(arr.valueOf());

// 1 栈操作(先进后出)
// push() // 向数组的末尾添加一个或多个元素，并返回新的长度。
// pop()     //取出数组中的最后一项，修改length属性
// // 2 队列操作(先进先出)
// push()
// shift()   //取出数组中的第一个元素，修改length属性
// unshift()   //在数组最前面插入项，返回数组的长度
// // 3 排序方法
// reverse() //翻转数组
// sort();   //即使是数组sort也是根据字符，从小到大排序 
// 使用数字排序，你必须通过一个函数作为参数来调用。
// console.log(arr.spoport(function(a,b){return a-b}));
// 根据长度排序
arr.sort(function (a, b) {
      return a.length - b.length;
    });

// 清空数组
// arr = [];
// console.log(arr);
// 
// arr.length = 0;
// console.log(arr);
// 
//  第一个参数，是从什么位置开始删除 索引
//  第二个参数，删除多少个元素
arr.splice(0, arr.length);
console.log(arr);

14、如何判断一个变量是否是数组对象

function fn(arr) {
      // 判断参数arr 是否是数组对象
      // instanceof 
      // console.log(arr instanceof Array);
      // 
      // !arr instanceof Array   
      // false instanceof Array
      // 方式1
      // if (!(arr instanceof Array)) {
      //   console.error('参数err 不是数组对象');
      //   return;
      // }
      // 
      // 
      // 方式2  Array.isArray() 浏览器兼容性问题  HTML5
      // console.log(Array.isArray(arr));
      // if (!Array.isArray(arr)) {
      //   console.error('参数err 不是数组对象');
      //   return;
      // }

13、js数据类型

数据类型
    简单数据类型，基本数据类型/值类型
    Number  String  Boolean  Null  Undefined
    复杂数据类型，引用类型，数组
    Ojbect
 
 数据在内存中存储
     简单数据类型 存储在内存中的栈上
     复杂数据类型 存储在内存中的堆上

12、JavaScript组成

1.ECMAScript（核心）
作为核心，它规定了语言的组成部分：语法、类型、语句、关键字、保留字、操作符、对象
2.DOM（文档对象模型）
DOM把整个页面映射为一个多层节点结果，开发人员可借助DOM提供的API，轻松地删除、添加、替换或修改任何节点。DOM也有级别，分为DOM1、DOM2、DOM3，拓展不少规范和新接口。
3. BOM （浏览器对象模型）
支持可以访问和操作浏览器窗口的浏览器对象模型，开发人员可以控制浏览器显示的页面以外的部分。注意：BOM未形成规范。

JavaScript版本
　　JavaScript语言是在10天时间内设计出来的，虽然语言的设计者水平非常NB，但谁也架不住“时间紧，任务重”，所以，JavaScript有很多设计缺陷。

　　此外，由于JavaScript的标准——ECMAScript在不断发展，最新版ECMAScript 6标准（简称ES6）已经在2015年6月正式发布了，所以，讲到JavaScript的版本，实际上就是说它实现了ECMAScript标准的哪个版本。
　　查文档：MDN
## 12、this出现在以下位置，分别代表什么
 
```css
    // 1 函数中   --  this 指向Window
    // 2 在方法中  --  this  指向的是这个方法所属的对象
    // 3 构造函数中  -- this 就是构造函数创建的对象

11、预解析

// 在预解析的过程中如果函数和变量的名字相同，此时函数优先
    var a;
    function a() {
      console.log('aaaaa');
    }

    console.log(a);
    a = 1;
    console.log(a);
    ---------------------------------
      function f1() {
   var a;
   a = b = c = 9;
   console.log(a); // 9
   console.log(b); // 9
   console.log(c); // 9
 }
 f1();
 console.log(c); // 9
 console.log(b); // 9
 console.log(a); // 报错

10、计算时间差，返回相差的天/时/分/秒

 // 计算时间差，返回相差的天/时/分/秒

    //1 两个日期对象如何相减

    var d1 = new Date();

    var d2 = new Date(2017, 9, 1);

    // d2.valueOf() - d1.valueOf()

    console.log(d1 - d2);  // 4692437476  两个时间相差的毫秒数


    //4692437476  相差的总的毫秒值

    //相差的天数 = 4692437476 / 1000 / 60 / 60 / 24

    //相差的小时数 = 4692437476 / 1000 / 60 / 60 % 24

    //相差的分钟数 = 4692437476 / 1000 / 60 % 60 

    //相差的秒数 = 4692437476 / 1000 % 60


function getInterval(start, end) {
      // 两个日期对象，相差的毫秒数

      var interval = end - start;

      // 求 相差的天数/小时数/分钟数/秒数

      var day, hour, minute, second;

      // 两个日期对象，相差的秒数

      // interval = interval / 1000;

      interval /= 1000;

      day = Math.round(interval / 60 / 60 / 24);

      hour = Math.round(interval / 60 / 60 % 24);

      minute = Math.round(interval / 60 % 60);

      second = Math.round(interval % 60);

      return {
        day: day,

        hour: hour,

        minute: minute,

        second: second

      }

    }

    var d1 = new Date();

    var d2 = new Date(2017, 9, 1);

    var o = getInterval(d2, d1);

    console.log(o);

9、写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式

function formatDate(date) {
      var year = date.getFullYear(),

          month = date.getMonth() + 1,

          day = date.getDate(),

          hour = date.getHours(),

          minute = date.getMinutes(),

          second = date.getSeconds();

 

      month = month < 10 ? '0' + month : month;

      day = day < 10 ? '0' + day : day;

      hour = hour < 10 ? '0' + hour : hour;

      minute = minute < 10 ? '0' + minute : minute;

      second = second < 10 ? '0' + second : second;

 

      //return year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second;

      console.log(year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second);

    }

    formatDate(new Date());

   //  var d = new Date();

   //  var dateStr = formatDate(d);

   //  console.log(dateStr);

 

   //  var d = new Date(2017, 8, 10);

   //  var dateStr = formatDate(d);

   //  console.log(dateStr);

8、Date，Math

1.0 Date案例，

1、写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式
2、计算时间差，返回相差的天/时/分/秒
3、函数如何返回多个值
4、如何计算相差的 天/时/分/秒
// 写一个函数，格式化日期对象，返回yyyy-MM-dd HH:mm:ss的形式
    // function formatDate(date) {
    //   // 判断参数date是否是日期对象
    //   // instanceof  instance 实例(对象)   of 的
    //   // console.log(date instanceof Date);
    //   if (!(date instanceof Date)) {
    //     console.error('date不是日期对象')
    //     return;
    //   }

    //   var year = date.getFullYear(),
    //       month = date.getMonth() + 1,
    //       day = date.getDate(),
    //       hour = date.getHours(),
    //       minute = date.getMinutes(),
    //       second = date.getSeconds();

    //   // if (month < 10) {
    //   //   month = '0' + month;
    //   // }
    //   month = month < 10 ? '0' + month : month;
    //   day = day < 10 ? '0' + day : day;
    //   hour = hour < 10 ? '0' + hour : hour;
    //   minute = minute < 10 ? '0' + minute : minute;
    //   second = second < 10 ? '0' + second : second;

    //   return year + '-' + month + '-' + day + ' ' + hour + ':' + minute + ':' + second;
    // }

    // var d = new Date();
    // var dateStr = formatDate(d);
    // console.log(dateStr);


    // d = new Date(2017, 8, 10);
    // var dateStr = formatDate(d);
    // console.log(dateStr);



    // 计算时间差，返回相差的天/时/分/秒
    //1 两个日期对象如何相减
    // var d1 = new Date();
    // var d2 = new Date(2017, 9, 1);
    // // d2.valueOf() - d1.valueOf()
    // console.log(d2 - d1);  // 4692437476  两个时间相差的毫秒数


    //2 函数如何返回多个值
    // function fn() {
    //   return {
    //     year: 1,
    //     day: 2,
    //     hour: 3
    //   };
    // }
    
    //3 如何计算相差的 天/时/分/秒
    //
    //4692437476  相差的总的毫秒值
    //相差的总的秒数 = 4692437476 / 1000
    //相差的天数 = 4692437476 / 1000 / 60 / 60 / 24
    //相差的小时数 = 4692437476 / 1000 / 60 / 60 % 24
    //相差的分钟数 = 4692437476 / 1000 / 60 % 60 
    //相差的秒数 = 4692437476 / 1000 % 60
    //
    function getInterval(start, end) {
      // 两个日期对象，相差的毫秒数
      var interval = end - start;
      // 求 相差的天数/小时数/分钟数/秒数
      var day, hour, minute, second;

      // 两个日期对象，相差的秒数
      // interval = interval / 1000;
      interval /= 1000;

      day = Math.round(interval / 60 / 60 / 24);
      hour = Math.round(interval / 60 / 60 % 24);
      minute = Math.round(interval / 60 % 60);
      second = Math.round(interval % 60);

      return {
        day: day,
        hour: hour,
        minute: minute,
        second: second
      }
    }

    var d1 = new Date();
    var d2 = new Date(2017, 9, 1);

    var o = getInterval(d1, d2);
    console.log(o);

1.1 Date

var d = new Date();

    // 打印日期对象的时候。内部调用了toString()

    console.log(d);

    console.log(d.toString());

    console.log(d.toDateString());

    console.log(d.toTimeString());

    console.log(d.toLocaleDateString());

    console.log(d.toLocaleTimeString());

    // 获取日期中的指定部分

    var  d = new Date();

    console.log(d.getFullYear());

    // !--------注意：月份是从0开始的-------------

    console.log(d.getMonth() + 1);

    console.log(d.getDate());

    console.log(d.getHours());

    console.log(d.getMinutes());

    console.log(d.getSeconds());

    // 获取当前时间的毫秒值    静态成员

    var num = Date.now();   // 浏览器兼容问题  HTML5

    console.log(num);

    var num2 = new Date();   // 浏览器兼容问题  HTML5

    console.log(num2);

    // 如何获取日期对象的毫秒值

    var d = new Date();

    // 获取日期对象的毫秒值  不用我们调用

 console.log(d.valueOf());

    // 和valueOf的作用是一样的

    console.log(d.getTime());

1.2 Math

    // - 求10-20之间的随机数  [10, 20]   整数
    // Math.random()  ->  [0, 1)  小数
    // Math.random() * 20   ->   [0, 20)  包含小数部分
    // Math.random() * (20 - 10)  -> [0, 10)  包含小数部分
    // Math.random() * (20 - 10) +  10 -> [10, 20)  包含小数部分


    // Math.floor(Math.random() * (max - min + 1) + min);
    // Math.floor(Math.random() * (20 - 10 + 1) + 10);
    // Math.floor(Math.random() * 11 + 10);  -> Math.floor([0, 11) + 10) ->                 Math.floor([10, 21)) -> ->  Math.floor([10, 20])  -> [10, 20] 整数
    
    // function random(min, max) {
    //   return Math.floor(Math.random() * (max - min + 1) + min);
    // }
    // console.log(random(10, 20));

    // - 随机生成颜色RGB   [0, 255] 整数
    // rgb(100, 100, 100)
    // function random(min, max) {
    //   return Math.floor(Math.random() * (max - min + 1) + min);
    // }

    // function randomRGB(min, max) {
    //   var color1 = random(min, max);
    //   var color2 = random(min, max);
    //   var color3 = random(min, max);

    //   return 'rgb(' + color1 + ', ' + color2 + ', ' + color3 + ')';
    // }

7、Math对象和Date对象的区别

 // Math 不是一个构造函数，里面提供是静态成员
    // var MyMath = {
    //   PI: 3.14,
    //   max: function () {
    //   }
    // }
    // 静态成员
    // MyMath.PI
    // MyMath.max();
    // 
    // Date 是一个构造函数，首先要通过new Date() 来创建日期实例(对象)，实例成员
    // var d = new Date();
   console.log(d);
    // GMT 格林威治时间   世界标准时间
    // GMT+0800 (中国标准时间)
    // 
    // 距离1970-1-1相差的毫秒数
 console.log(d.valueOf());

6、静态成员和实例成员

var MyMath = {
    PI: 3.1415926,
    max: function () {
    },
    min: function () {
    }
  }
  // 工具中使用静态成员
  // 静态成员 ： 直接使用对象来调用的
  console.log(MyMath.PI);
  // MyMath.max()
  //
  // 当有很多个对象的时候  使用构造函数的形式来创建对象
  // 实例成员 : 构造函数中的成员就是实例成员
  // 什么是实例：对象的另一种说法
  function Person(name, age) {
    this.name = name;
    this.age = age;
    this.sayHi = function () {
      console.log("sayHi");
    }
  }
  // 通过构造函数创建对象
  var p = new Person('zs', 18);
  p.sayHi();

5、js自带函数

  Math.max
  var arr = [1,3,2,9,6];
  console.log(Math.max(1,3,2,9,6));
  console.log(Math.max.apply(null, arr));

var MyMath = {
  max: function () {
    var max = arguments[0];
    for (var i = 1; i < arguments.length; i++) {
      if (max < arguments[i]) {
        max = arguments[i];
      }
    }
    return max;
  },
  min: function () {
    var min = arguments[0];
      for (var i = 1; i < arguments.length; i++) {
        if (min > arguments[i]) {
          min = arguments[i];
        }
      }
      return min;
 }
};
console.log(MyMath.max(10, 1, 100, 20));
console.log(MyMath.min(10, 1, 100, 20));

4、取10-20之间的随机整数

        var num1 = 10;
        var num2 = 20;
        var arry = [];
        for(var i=0;i<20;i++){
            var suiji = Math.floor((num2-num1+1)*Math.random())+num1;
            arry.push(suiji);
        }
        alert(arry);

3、 生成 min 到 max 之间的随机数，parseInt() 函数可解析一个字符串，并返回一个整数。

var min = 10;
var max = 100;
console.log( parseInt(Math.random() * (max - min) + min));

2、优化数组排序 – 冒泡排序

var num = 0;
    function sort(array) {
        for (var i = 0; i < array.length -1; i++) {
          var isSort = true;
          for (var j = 0; j < array.length -1 - i; j++) {   //num =  9
            num++;
              if (array[j] > array[j+1]) {
                 isSort = false;
                 var tem = array[j];
                 array[j] = array[j+1];
                 array[j+1] = tem;
              }
          }
          // 判断是否排好了
          if (isSort) {
            break;
          }
        }
      }
    var array = [34, 12, 88, 20, 30];
    sort(array);
    console.log(array);
    console.log(num);

1、数组排序-- 冒泡排序

var num = 0;
    function sort(array) {
        for (var i = 0; i < array.length; i++) {
          console.log(i+"##########");
          // for (var j = 0; j < array.length; j++) {   num = 20
          // for (var j = i; j < array.length; j++) {   num = 15
          for (var j = array.length-1; j > i; j--) {   //num =  10
            console.log(array[i]);
            console.log(array[j]);
            console.log(i+"//");
            num++;
              if (array[i] > array[j]) {
                 var tem = array[i];
                 array[i] = array[j];
                 array[j] = tem;
              }
          }
        }
      }
    var array = [34, 12, 88, 20, 30];
    sort(array);
    console.log(array);
    console.log(num);
林间风雨
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
js算法实现
12-28
js算法实现,包括最短路径问题，常见的排序问题，md5加密算法,DES算法，等等...
JavaScript前端算法.zip
06-12
本压缩包包含了一系列与JavaScript算法相关的学习资料和代码示例，主要涉及了数据结构如链表、树，以及排序算法等主题。 1. **链表**：在"2链表.js"中，你可以找到关于链表操作的实现，如插入、删除、遍历等。链表...
JS家的排序算法
Android系统攻城狮
09-15 1693
引子 有句话怎么说来着： 雷锋推倒雷峰塔，Java implements JavaScript. 当年，想凭借抱Java大腿火一把而不惜把自己名字给改了的JavaScript（原名LiveScript），如今早已光芒万丈。node JS的出现更是让JavaScript可以前后端通吃。虽然Java依然制霸企业级软件开发领域（C/C + +的大神们不要打我。。。），但在W
js算法
hutao2333的博客
07-22 193
1 典型的算术运算会操作两个数（或表达式）并返回一个新的数。 2 典型的算术运算会操作两个数（或表达式）并返回一个新的数。 3 典型的算术运算会操作两个数（或表达式）并返回一个新的数。 4 + 运算符 5 - 运算符 6 * 运算符 7 / 运算符 8 9 ++ 运算符 10 – 运算符 ...
JS算法
潇蓝诺依的博客
09-16 300
十大经典算法排序总结对比 冒泡排序Bubble Sort 选择排序Selection Sort 插入排序Insertion Sort 希尔排序Shell Sort 归并排序Merge Sort 快速排序Quick Sort 计数排序Counting Sort 桶排序Bucket Sort 基数排序Radix Sort 十大经典算法排序总结对比
javascript算法训练营
05-29
JavaScript算法训练营是一个专注于提升JavaScript开发者算法能力的学习资源。在这个训练营中，参与者将深入学习和实践各种算法，从而提高编程技巧，理解数据结构，并掌握解决复杂问题的方法。JavaScript作为前端开发...
基于JavaScript的算法集合
最新发布
07-27
基于JavaScript的算法集合
JavaScript算法和数据结构
09-13
数据结构是在计算机中组织和存储数据的一种特殊方式，以便可以有效地访问和修改数据。更准确地说，数据结构是数据值、它们之间的关系以及可应用于数据的功能或操作的集合...这是基于 JavaScript 的算法和数据结构教程。
Javascript实用算法集锦大放送
09-20
Javascript实用算法集锦大放送 Javascript 是一种广泛应用于 web 开发的编程语言，Javascript 算法是指使用 Javascript 语言来实现的算法。在这个标题下，我们将对 Javascript 实用算法进行总结和整理，从而帮助...
js 算法
jack_rose_me的博客
06-10 151
4、 3、 //生成min到max之间的随机数，parseInt() 函数可解析一个字符串，并返回一个整数。 varmin=10; varmax=100; console.log(parseInt(Math.random()*(max-min)+min)); 2、//优化数组排序 varnum=0; functionsort(array){ ...
JS 算法
qq_34870529的博客
09-04 163
1：如何返回斐波那契数列中下标为n的元素 斐波那契数列：（1：无限数列 2：前两项数值都为1，从第三项起每一项的数值为前两项数值之和） // 如何返回斐波那契数列中下标为n的数据 function fib(n) { const numbers = [1, 1]; for (let i = 2; i < n + 1; i++) { numbers.push(numbers[i - 2] + numbers[i - 1]); } co...
JS 算法
weixin_44756893的博客
06-08 74
JS 求平方根 实现函数 int sqrt(int x). 计算并返回x的平方根（向下取整） 用二分法 function sqrt( x ) { // write code here //二分查找 var left = 0; var right = x; var res = -1; while(left<=right){ var mid = Math.floor(left+(right-left)/2); if(mid*
js中的算法
Jsoning的博客
01-11 570
var arr = [1,3,5,7,9,2,4,6,8]冒泡排序 function bubbleSort(arr){ var tmp; var len = arr.length; for (var i = 0; i <len-1; i++) { for (var j = 0; j < len-1-i; j++) {
简单js算法
weixin_44957831的博客
05-15 125
1.冒泡排序数组 var arr=[9,2,3,6]; for(i=0;i<arr.length-1;i++) { for(j=0;j<arr.length-1;j++) { if(arr[j]>arr[j+1]) { var temp =arr[j+1]; arr[j+1]=arr[j] arr[j]=temp } } } console.l
JS一般算法
Sherry's Blog
07-23 876
回文算法（去除标点和空格，看字符串是否正反相同） function palindrome(str) { var strno = str.replace(/[\ |\~|\`|\!|\@|\#|\$|\%|\^|\&amp;|\*|\(|\)|\-|\_|\+|\=|\||\\|\[|\]|\{|\}|\;|\:|\"|\'|\,|\&lt;|\.|\&gt;|\/|\?]|\s+/g,"")...
JS 简单算法介绍
kylongCSDN的博客
11-13 259
1、冒泡排序 - 依次比较相邻两元素，若前一元素大于后一元素则交换之，直至最后一个元素即为最大；然后重新从首元素开始重复同样的操作，直至倒数第二个元素即为次大元素；依次类推。如同水中的气泡，依次将最大或最小元素气泡浮出水面。 function bubbleSort(arr) { let len = arr.length; for(let i = 0; i < len; i +...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值