前端基础算法

1、数组去重
有一个数组const a = [6, 4, 3, 4, 5, 6]
ES6:
1)、Set是一个类数组不重复的集合，可以利用这个特性处理

[...new Set(a)]

2)、indexOf() 方法可返回某个指定的字符串值在字符串中首次出现的位置.

a.filter((item,i) => a.indexOf(item) === i)

ES5:
1)、for循环和indexOf，创建一个新数组，如果没有重复的值就push进去

let a = []
for (let i = 0; i < a.length; i++){
    if(arr.indexOf(a[i]) === -1) arr.push(a[i])
}

2)、

let arr = [];
for (let i = 0; i < a.length; i++){
    if(a.indexOf(a[i]) === i) arr.push(a[i])
}

3)、使用includes

let arr = [];
for (let i = 0; i < a.length; i++){
    if(!arr.includes(a[i])) arr.push(a[i])
}

4)、双重循环

for (let i = 0; i < a.length; i++) {
    for (let j = i + 1; j < a.length; j++) {
      if (a[i] === a[j]) {
        a.splice(j, 1);
        j--;
      }
    }
}

2、冒泡排序
十大排序
冒泡排序是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

1.1 算法描述
比较相邻的元素。如果第一个比第二个大，就交换它们两个；
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
针对所有的元素重复以上的步骤，除了最后一个；
重复步骤1~3，直到排序完成。
1.2 动图演示

代码演示：

function bubbleSort(arr) {
    var len = arr.length;
    for (var i = 0; i < len - 1; i++) {
        for (var j = 0; j < len - 1 - i; j++) {
            if (arr[j] > arr[j+1]) {       // 相邻元素两两对比
                var temp = arr[j+1];       // 元素交换
                arr[j+1] = arr[j];
                arr[j] = temp;
            }
        }
    }
    return arr;
}

3、快速排序
快速排序

4、求斐波那契数列第N项
斐波那契数列（Fibonacci sequence），指的是这样一个数列：1、1、2、3、5、8、13、21、34、……在数学上，斐波那契数列以如下被以递推的方法定义：F(1)=1，F(2)=1, F(n)=F(n - 1)+F(n - 2)（n ≥ 3，n ∈ N*）
1)、递归法
数列的第n项（除第1项和第2项）是第n-1项与第n-2项的和。数列满足递归的关系，故可用递归算法求第n项的值。时间复杂度为o(2^n)

function fibonacci (n){
    if(n === 1 || n===2) return 1
    else return fibona(n - 1) + fibona(n - 2)
}

2)、时间复杂度为o(n)

function fabonacci (n) {
  if (n === 1 || n === 2) return 1
  let i = 0, n1 = 1, n2 = 1, sum = 0
  for(i = 3; i <= n; i++) {
    sum = n1 + n2
    n1 = n2
    n2 = sum
  }
  return sum
}