JavaScript算法

1.斐波那契数列

1，1，2，3，5，8，13，21

（1）递归（性能最不好）

function fn(n) {
    if(n == 1 || n == 2) {
        return 1;
    } else {
        return fn(n-1) + fn(n-2)
    }
}
fn(8)

函数的时间复杂度为O(2^n)，空间复杂度为O(n);

为什么该函数的时间复杂度为O(2^n)？

拆解：
fn(8)

                      fn(7) + fn(6)                                    2^1
          fn(6)+ fn(5)      +      fn(5)+fn(4)                         2^2
  fn(5)+fn(4)+fn(4)+fn(3)   +    fn(4)+fn(3)+fn(3)+fn(2)               2^3
 

复杂度对比：（时间复杂度和空间复杂度）
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n)

（2）for循环

function fn1(n) {
    var res1 = 1;
    var res2 = 1;
    var sum;
    for(var i = 0; i < n; i++) {
        sum = res1 + res2;
        res1 = res2;
        res2 = sum;
    }
    return sum;
}
fn1(45);




function fn2(n) {
    let arr = [];
    for (var i = 0; i < n; i++) {
        i <= 1 ? arr.push(1) : arr.push(arr[i - 1] + arr[i - 2]);
    }
    return arr;
}
fn2(10);

（3）数组实现

function fn(n) {
    let arr = [];
    arr[0] = 1;
    arr[1] = 1;
    for (var i = 2; i < n; i++) {
        arr[i] = arr[i-1] + arr[i-2];
    }
    return arr;
}
fn(10)

2.最长公共字符串

（1）排列组合思维

let str1 = "asdfgh";
let str2 = "dfghjkl";
let arr = [];
function fn(str1, str2) {
  if (str1.length > str2.length) {
    let str3;
    str3 = str1;
    str1 = str2;
    str2 = str3;
  }
  fnStr(str1)
}
fn(str1, str2);
function fnStr(str) {
  let strtmp = "";
  for (var i = 0; i < str.length; i++) {
    if (i < str.length) {
      strtmp = strtmp + str[i];
      arr.push(strtmp);
      if (i == str.length - 1) {
        fnStr(str.substr(1, str.length-1));
      }
    }

  }
}
console.log(arr);     
//["a", "as", "asd", "asdf", "asdfg", "asdfgh", "s", "sd", "sdf", "sdfg", "sdfgh", "d", "df", "dfg", "dfgh", "f", "fg", "fgh", "g", "gh", "h"]

let result = [];

arr.map((item, index) => {
  let obj = {};
  if (str2.indexOf(item) != -1) {
    obj.a = index;
    obj.b = item;
    obj.c = item.length;
    result.push(obj);
  }
})
console.log(result)
let resultStr;
let objMax = {"c": 0};
result.map((item, index) => {
  if (item.c > objMax.c) {
    objMax = {...item};
  }
})
console.log(objMax);
//{a: 14, b: "dfgh", c: 4}

3.数组扁平化

let arr = [1,2,3, {"a": 19, "x": [12,13,14]}, [4,5], [6,7,[8,9]], {"b": 10, "c": {"d": 11}}];
let result = [];
function fnObj(obj) {
    for (var key in obj) {
        if (Object.prototype.toString.call(obj[key]) == "[object Number]") {
            result.push(obj[key]);
        } else if (Object.prototype.toString.call(obj[key]) == "[object Object]") {
            fnObj(obj[key]);
        } else if (Object.prototype.toString.call(obj[key]) == "[object Array]") {
            fnArr(obj[key]);
        }
    }
}
function fnArr(arr) {
    arr.map((item, index) => {
        if (Object.prototype.toString.call(item) == "[object Array]") {
            fnArr(item);
        } else if (Object.prototype.toString.call(item) == "[object Object]") {
            fnObj(item);
        } else if (Object.prototype.toString.call(item) == "[object Number]") {
            result.push(item);
        }
    })
}
fnArr(arr)
console.log(result);

4.最长未重复字符串的长度

let str = "asdafagdf";  //4
let arr = [];
let count = 0;
let strtmp = "";
function fn (str) {
    for(var i = 0; i < str.length; i++) {
        if (strtmp.indexOf(str[i]) == -1) {
            strtmp = strtmp + str[i];
        } else {
            console.log(strtmp)
            arr.push(strtmp);
            count = count + 1;
            strtmp = "";
            fn(str.substr(count, str.length - count));
        }
    }
}
fn(str);
let maxNum = 1;
if (arr.length > 0) {
    arr.map((item, index) => {
        let tmpNum = item.length;
        if(tmpNum > maxNum) {
            maxNum = tmpNum;
        }
    })
}
console.log(maxNum);