js算法汇总

ゝ一纸荒年。 2022-03-17 09:42 172阅读 0赞

1：不创建新的变量交换a,b的值

var a = 1, b = 2;
    a = a + b;
    b = a - b;
    a = a - b;

2：冒泡排序

var a = [7,9,4,5,6,21,32,45,56,7,16,17,19,99];
    a = bubleSort(a);
    function bubleSort(a) {
       var tmp;
       var aLen = a.length;
        for(var i = 1; i < aLen; i++) {
          for(var j = 0; j < aLen- i; j++) {
            if(a[j] > a[j+1]) {
              tmp = a[j];
              a[j] = a[j+1];
              a[j+1] = tmp;
            }
          }
        }
        return a;
    }
     console.log(a);

3:插入排序

var a = [7,9,4,5,6,21,32,45,56,7,16,17,19,99];
    a = insertSort(a);
    function insertSort(a) {
      var aLen = a.length;
      var temp;
      for(var i = 1; i < aLen; i++) {
        for(var j = i; j > 0; j--) {
          if(a[j] < a[j-1]) {
            var temp = a[j];
            a[j] = a[j-1];
            a[j-1] = temp;
          }
        }
      }
      return a;
    } 
    console.log(a);

4:选择排序：

var a = [7,9,4,5,6,21,32,45,56,7,16,17,19,99];
    a = insertSort(a);
    function seceltSort(a) {
      var aLen = a.length;
      var temp;
      for(var i = 0; i < aLen - 1; i++) {
        for(var j = i+1; j < aLen; j++) {
          if(a[i] > a[j]) {
            var temp = a[i];
            a[i] = a[j];
            a[j] = temp;
          }
        }
      }
      return a;
    }
    console.log(a);

4:快速排序

var a = [7,9,4,5,6,21,32,45,56,7,16,17,19,99];
    a = quickSort(a);
    function quickSort(a) {
      var aLen = a.length;
      if(!aLen) return [];
      var mid = Math.floor(aLen / 2);
      var base  = a[mid];
      var left = [];
      var right = [];
      for(var i = 0; i < aLen; i++) {
        if(i === mid) continue;
        if(a[i] < base) left.push(a[i]);
        if(a[i] > base) right.push(a[i]);
      }
      return quickSort(left).concat(base, quickSort(right))
    }
    console.log(a);

5:折半插入排序

var a = [7, 9, 4, 5, 6, 21, 32, 45, 56, 7, 16, 17, 19, 99];
      a = halfInsertSort(a);
    
      function halfInsertSort(a) {
        var aLen = a.length;
        for (var i = 0; i < aLen; i++) {
          var pos = findInsertPos(i);
          var current = a[i];
          if (pos === i) continue;
          for (var j = i; j > pos; j--) {
            a[j] = a[j - 1];
          }
          a[pos] = current;
        }
    
        function findInsertPos(currentIndex) {
          var start = 0;
          var end = currentIndex - 1 < 0 ? 0 : currentIndex - 1;
          var currentItem = a[currentIndex];
          var mid = 0;
          while (start !== (mid = Math.floor((start + end) / 2))) {
            if (currentItem < a[mid]) end = mid - 1;
            else if (currentItem > a[mid]) start = mid + 1;
            else return mid + 1;
          }
          if (currentItem <= a[start]) return start;
          else if (currentItem >= a[end]) return end + 1;
          else return end;
        }
        return a;
      }

6:数组的扁平化  
方法一：

function flatten(a) {
        var result = [];
        for(var i = 0; i < a.length; i++) {
          var item = a[i];
          Array.isArray(item) ? result.push(flatten(item)) : result.push(item);
        }
        return result;
    }

方法二：

function isArray(a) {return Object.prototype.toString.call(a) === '[object Array]';}
    
    function flatten(arr) {
      return arr.reduce((prev, next) => {
        return prev.concat(isArray(next) ? flatten(next) : next);
      }, []);
    }
    
    var z = [1,[2,3],[4,5],6,[7,[8,9, [10, 11, [12, 13, 14, [15, 16]]]]], [17, 18, [19, 20]]];
    flatten(z);

方法三：

function flatten(a) {
      while(a.some((item) => Array.isArray(item))) {
        a = [].concat(...a);
      }
      return a;
    }
    
    var m = flatten([1,2,[3,4,[5,6,[7,8]]]]);

7:手写bind

bind的两种使用场景：
    1：改变函数的this指向，同时给函数指定固定参数
    2：作为构造函数使用
    function Foo() {
      this.b = 100;
      console.log(this.a);
      return this.a;
    }
    
    Foo.prototype.name = 'foo';
    var func = Foo.bind({a: 1});
    func(); //->1
    var foo = new Foo(); //->undefined
    console.log(foo.b); //->100
    console.log(foo.name); //->'foo'
    
    if(!Function.prototype.bind) {
      Function.prototype.bind = function(target) {
        if(typeof this)
        var args = [].slice.call(arguments, 1);
        var fNop = function() {};
        var that = this;
        var fBound = function() {
          return that.apply(this instanceof fBound ? this : target, args.concat(arguments));
        }
        fNop.prototype = this.prototype;
        fBound.prototype = new fNop();
      }
    }

8:函数的链式调用实现lazyman  
题目如下：

实现一个LazyMan， 可以按照以下方式调用:
    LazyMan(“Hank”) 输出:
    Hi!This is Hank!
    
    LazyMan(“Hank”).sleep(10).eat(“dinner”) 输出
    Hi!This is Hank!
    //等待10秒..
    Wake up after 10
    Eat dinner~
    
    LazyMan(“Hank”).eat(“dinner”).eat(“supper”) 输出
    Hi This is Hank!
    Eat dinner~
    Eat supper~
    
    LazyMan(“Hank”).sleepFirst(5).eat(“supper”) 输出
    //等待5秒
    Wake up after 5
    Hi This is Hank!
    Eat supper
    
    以此类推。

实现：

function Lazyman(name) {
      return new _Lazyman(name);
    }
    
    class _Lazyman {
      constructor(name) {
        this.tasks = []; //设置任务队列
        let task = (name => () => {
          console.log(`Hi! This is ${name} !`);
          this.next();
        })(name);
        this.tasks.push(task);
    
        setTimeout(() => {
          this.next();
        }, 0);
    
      }
      next() {
        let task = this.tasks.shift();
        task && task();
      }
    
      eat(food) {
        let task = (food => () => {
          console.log(`Eat ${food}`);
          this.next();
        })(food);
        this.tasks.push(task);
        return this;
      }
    
      sleep(time) {
        let task = (time => () => {
          setTimeout(() => {
            console.log(`Wake up after ${time} s!`);
            this.next();
          }, time * 1000)
        })(time);
        this.tasks.push(task);
        return this;
      }
    
      sleepFirst(time) {
        let task = (time => () => {
          setTimeout(() => {
            console.log(`Wake up after ${time} s!`);
            this.next();
          }, time * 1000)
        })(time);
        this.tasks.unshift(task); //sleepFirst函数需要最先执行，所以我们需要在任务队列前面放入，然后再执行后面的任务
        return this;
      }
    
    }

9：数组去重复

方法一：
    function uniq(array) {
      Array.prototype.filter.call(array, function(item, index) {
        return array.indexOf(item) === index;
      })
    }
    方法二：
    [...new Set([1,2,3,3,,4,4])]
    Array.from(new Set([1,2,3,4,3,3]))

发表评论取消回复

表情：

评论列表（有 0 条评论，172人围观）

还没有评论，来说两句吧...

相关阅读

相关精选汇总 | 软件算法

关注+星标公众号，不错过精彩内容 ![41c6e896c2bba1c210e01fe49c7684a3.gif][] 作者 | strongerHuang 微信公众号 |

梦里梦外;/ 2022年10月23日 11:09/ 0 赞/ 170 阅读

相关算法题汇总

1.冒泡排序 [https://juejin.cn/post/6948814177179795487][https_juejin.cn_post_694881417717

骑猪看日落/ 2022年10月07日 05:52/ 0 赞/ 151 阅读

相关 JS_Native.js示例汇总

[文档地址：https://ask.dcloud.net.cn/article/114][https_ask.dcloud.net.cn_article_114] ![在这

亦凉/ 2022年09月11日 01:20/ 0 赞/ 93 阅读

相关 Js继承汇总

1、原型链继承基本思想：通过原型链继承多个引用类型的属性和方法原型链扩展了原型搜素机制：在读取实例上的属性时，首先在实例上搜索这个属性，没找到则会继续搜索实

谁借莪１个温暖的怀抱￠/ 2022年09月08日 15:52/ 0 赞/ 107 阅读

相关排序算法汇总

排序是计算机数据处理中很重要的也很常见的运算，排序操作在处理过程中会占用很多时间，为提高计算机运行效率，人们提出了不断改进各种各样的计算机算法。【算法汇总

今天药忘吃喽~/ 2022年08月09日 00:42/ 0 赞/ 153 阅读

相关 JS语法汇总

函数表达式和函数声明在ECMAScript中，创建函数的最常用的两个方法是函数表达式和函数声明，两者期间的区别是有点晕，因为ECMA规范只明确了一点：函数声明必

爱被打了一巴掌/ 2022年06月09日 06:37/ 0 赞/ 246 阅读

相关算法网站汇总

算法导论答案 mitpress.mit.edu/algorithms/ MIT算法导论 ocw.mit.edu/courses/electrical-enginee

痛定思痛。/ 2022年04月21日 17:50/ 0 赞/ 141 阅读

相关 js算法汇总

1：不创建新的变量交换a,b的值 var a = 1, b = 2; a = a + b; b = a - b; a = a - b; 2：

ゝ一纸荒年。/ 2022年03月17日 09:42/ 0 赞/ 173 阅读

相关前端算法汇总

//判断是否为回文 function huiwen(str){ return str== str.split('').rever

缺乏、安全感/ 2021年11月17日 13:12/ 0 赞/ 322 阅读

相关各种距离算法汇总

1. 欧氏距离，最常见的两点之间或多点之间的距离表示法，又称之为欧几里得度量，它定义于欧几里得空间中，如点 x = (x1,...,xn) 和 y = (y1,...,y

怼烎@/ 2021年11月10日 05:56/ 0 赞/ 1455 阅读