js算法汇总

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]))