1.算法与数据结构概念

1.1算法定义

算法：一步接一步的方式来详细描述计算机如何将输入转化为所要求的输出的过程。是一组完成任务的指令。 比如：

你要从家里去公司上班，你可以选择步行，坐地铁，坐公交。其中 步行，坐地铁，坐公交 就是解决上班的算法。

1.2数据结构

定义

数据：被计算机识别并处理，存储在计算机设备中的数据
数据结构：是计算机存储、组织数据的方式

分类

1. 线性 常见数据结构：数组，堆栈，队列，链表

2. 树

3. 图

1.3比喻：做番茄炒蛋

• 数据：番茄和鸡蛋
• 算法：如何炒
• 数据结构：放鸡蛋篮子，鸡蛋打碎后放的碗，切开的番茄放在的碗

2.算法复杂度

定义：是指算法在编写成可执行程序后，运行时所需要的资源，资源包括时间资源和内存资源。

2.1 时间复杂度

T(n) = O(f(n))

O(1)

只要算法里没有循环和递归，时间复杂度也是 O(1)，不会因为录入的变量的增大而变长

function foo(a){
  console.log("xxxx") 
} 

O(n)

有一层循环或者递归等，时间复杂度就是 O(n)

function foo1(n){
    for( let i = 0; i < n; i++){
        console.log("xxxx")
    }
}
function foo2(n){
    while( --n > 0){
        console.log("xxxx")
    }
}
function foo3(n){
    console.log("xxxx")
    --n > 0 && foo3(n)
}

O(n²)

嵌套循环

function foo1(n){
    for( let i = 0; i < n; i++){
        for( let j = 0; j < n; j++){
            console.log("xxx")
        }
    }
}

O(logn)

通过参数 n/2 影响循环次数，这种就是 O(logn)

例子1
function foo1(n){
    let d = 0
    while(n > 1){
        n = n/2
        d++
    }
    return d
}
console.log( foo1(16) ) // 4

例子2
function foo2(n){
    for(let i = 0; i < n; i *= 2){
        console.log("xxx")
    }
}
foo2( 16 )

a的b次方 = n  读作以a为底,b的对数=n，在这道题里我们知道a和n的值，也就是  2的b次方 = 16 然后求 b

等价于

log(a)n = b 就是  log(2)16 = ?  答案就是 4

由于时间复杂度需要去掉常数和系数，而log的底数跟系数是一样的，最终为 O(logn)

O(2^n)

指数阶，如斐波那契数列，递归两次的方式

var fib = function(n) {
    if (n === 0 || n === 1) {
      return n
    }
    return fib(n - 1) + fib(n -2)
};

复杂度	名称
O(1)	常数阶
O(logn)	对数阶
O(n)	线性阶
O(nlogn)	线性对数阶
O(n²)	平方阶
O(n³)	立方阶
O(2``n``)	指数阶
O(n!)	阶乘

2.2空间复杂度

S(n) = O(f(n))

O(1)

不因为算法里的执行，导致额外的空间增长都是O(1)

function foo(){
    let n = 1
    .....
} 

O(n) 线性

动态根据 n 的数值越大，需要分配的空间就要越多，来存储数组里的值

function foo(n){
    let arr = []
    for( let i = 1; i < n; i++ ) {
        arr[i] = i
    }
}

O(n) 递归

动态根据 n ，每次调用都会把调用的方法，放入"方法调用栈"，进行入栈和出栈

function foo(n){
  if(n < 1) {
      return 
  }
  foo(n-1)
}

O(n²)

二维数组，矩阵

let arr = [
    [1,2,3,4,5],
    [1,2,3,4,5],
    [1,2,3,4,5]
]

3.leetcode刷题

1：两数之和

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。你可以假设每种输入只会对应一个答案。

但是，数组中同一个元素在答案里不能重复出现。你可以按任意顺序返回答案。

示例 1：

输入： nums = [2,7,11,15], target = 9
输出： [0,1]
解释： 因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入： nums = [3,2,4], target = 6
输出： [1,2]

答题

/**
 * @param {number[]} nums
 * @param {number} target
 * @return {number[]}
 */
// 双重循环
// 时间复杂度：O(n²)，空间复杂度O(1)
var twoSum = function(nums, target) {
   for (var i = 0; i < nums.length; i++ ) {
        for (var j = 0; j < nums.length; j++ ) {
            if((nums[i] + nums[j] ) === target && i !== j) {
                return [i,j]
            }
        }
   }
    return []
};
// map 方式存储
// 时间复杂度：O(n)，空间复杂度O(n)
var twoSum = function(nums, target) {
      let map = new Map()
    for (let i = 0; i < nums.length; i++) {
        let sub = target - nums[i] //找出下一个匹配的 
        if (map.has(sub)) { //如果当前已经记录过直接返回
            return [map.get(sub),i]
        } else {
            map.set(nums[i],i)
        }
    }
    return []
};
// obj 对象方式存储,
// 时间复杂度：O(n)，空间复杂度O(n)
var twoSum = function(nums, target) {
   var obj ={}
   for (var i = 0; i < nums.length; i++) {
       var key = nums[i]
       var sub = target - key
       if(sub in obj) {
          return [obj[sub],i]
       } else {
           obj[key] = i
       }
   }
    return []
};

//nums.lastIndexOf +   i != index判断
var twoSum = function(nums, target) {
    for (let i = 0; i < nums.length; i++) {
        let index = nums.lastIndexOf(target - nums[i])
        if(index > -1 && i != index) {
            return [i,index]
        } 
    }
    return []
 };

// 通过双指针的方式，数组一直左边移除shift ，然后 indexOf获取差值索引
var twoSum = function(nums, target) {
    const res = []
    let indexStart = 0
    while(res.length == 0 && nums.length) {
        const item = nums.shift() //从左边一直移除元素
        const indexEnd = nums.indexOf(target - item)//从剩下的数组元素里再找对应的差值
        if(indexEnd != -1) { 
            return [indexStart,indexEnd+indexStart+1]//所以这里要把移除的内容补回来，+1是因为默认先shift了元素最后再indexStart++
        }
        indexStart++
    }
    return []
 };
 

509：斐波那契数列

斐波那契数，通常用 F(n) 表示，形成的序列称为 斐波那契数列 。该数列由 0 和 1 开始，后面的每一项数字都是前面两项数字的和。也就是：

F(0) = 0，F(1) = 1
F(n) = F(n - 1) + F(n - 2)，其中 n > 1

给你 n ，请计算 F(n) 。

示例 1：

输入： 2
输出： 1
解释： F(2) = F(1) + F(0) = 1 + 0 = 1

示例 2：

输入： 3
输出： 2
解释： F(3) = F(2) + F(1) = 1 + 1 = 2

答题

/**
 * @param {number} n
 * @return {number}
 */
 // 递归
 // 时间复杂度：O(2N的平方)，空间复杂度O(1)
var fib = function(n) {
    if (n === 0 || n === 1) {
      return n
    }
    return fib(n - 1) + fib(n -2)
};
 // 递推
 // 时间复杂度：O(N)，空间复杂度O(N)
var fib = function(n) {
   var cacheList = []
   for (var i = 0; i <= n; i++ ) {
       if(i === 0 || i === 1) {
        cacheList[i] = i 
       } else {
        cacheList[i] =  cacheList[i-1] + cacheList[i-2];
       }
   }
   return cacheList[n]
};