时间复杂度
描述运行时间与问题规模之间的增长关系。通常用大O表示法（O(n))来表示，其中n表示输入的规模，时间复杂度越低，算法运行效率越低。O(n^2)效率最低
空间复杂度
空间复杂度：内存空间与问题规模之间的增长关系。同样使用大O表示法(O(n)),其中n也表示输入的规模。空间复杂度越低，算法使用的内存空间越少
递归
1.递归应该一种比较常见的实现一些特殊代码逻辑时需要做的，但常常也是最绕的一种方式，在解释递归 之前，我们用循环和递归来做个比较
1.1.如果你打开一扇门后，同样发现前方也有一扇们，紧接着你又打开下一扇门...直到打开最后一扇门出去， 或者一直没有碰到尽头 （死循环）——'这就是循环'
1.2.如果你打开一扇门，紧接着你又用钥匙打开了这扇门，然后你又看到一扇们...但是当你开到某扇门时， 发现前方是一堵墙无路可走了，你选择原路返回——'这就是递归'
2.通过上面的故事可以发现递归其实是两个过程
2.1.'递'问题分解去的过程叫'递' -- 就像故事打开的门
2.2.'归'遇到终止'递'的条件叫'归' -- 就像故事里的墙 满足递归的条件
1.递归是一种解决问题的方法，它从解决问题的各个小部分开始，直到解决最初的大问题。递
归通常涉及函数调用自身
2.还是上面开门的故事，你想知道你开启的第一个门，实际是距离墙的第几扇门，这个问题想要解决
根据第一条的概念进行拆分
2.1.'分解成各个小部分'，也就是我要知道我下一扇门距离墙是第几扇门
2.2.'这个问题与分解之后的子问题，除了数据规模不同，求解思路完全一样',我想知道开启第一扇门距离墙
是第几扇门，和我想知道下一扇门距离墙的位置是第几扇门是一样的
2.3.'存在递归终止条件',也就这些问题一层一层解析后，直到我知道扇的位置后终止，在一个个回来数如何编写递归
1.写出递推公式，找到终止条件
2.写递归代码的关键就是找到如何将大问题分解为小问题的规律，并且基于此写出递推公式，然后再推敲终止条件，
最后将递推公式和终止条件翻译成代码
3.编写递归代码的关键是，只要遇到递归，我们就把它抽象成一个递推公式，不用想一层层的调用关系，不要试图用人
脑去分解递归的每个步骤递归到底是个什么
1.递归就是栈一种应用场景，也遵循着'先进后出的原则（后进先出）'递归阶乘
1.求5*4*3*2*1 的问题，用递归来解决三步走
1.1.分解成各个小部分
5 * fn(4) 参数n = 5-1
5 * (4*fn(3)) 参数n = 4-1
5 * 4 * (3*fn(2)) 参数n = 3-1
5 * 4 * 3 * (2*fn(1)) 参数n =2-1
1.2.推到成递归公式 fn(n) = n*fn(n-1) ,且fn(1) = 1
1.3.终止条件 fn(1) = 1
// 代码
1.递归是栈的结构表现，所以它'递'的过程是在做压栈，'归'的过程在做出栈，其实本质，先算的是
终止条件，然后在依次向上传递
2.如图一，通过浏览器的控制台可以更形象的看出这个过程
function factorial(n){
console.trace()
if(n === 1 || n === 0){
return 1
}
console.log(n)
return n * factorial(n-1)
}
factorial(5)
斐波那契数列
0，1，1，2，3，5，8，13，21
// 斐波那契数列
function fibonacciIterative(n){
if(n < 1) return 0 // 结束条件
if(n <=2) return 1 // 结束条件
return fibonacciIterative(n-2) + fibonacciIterative(n-1) // 递归公式 fn(n) = fn(n-1)+fn(n-2)
}
这段代码是一个使用递归方式求解斐波那契数列的函数。该函数接收一个整数参数 n，表示要求解的斐波那契数列的第 n 项（n 从 1 开始计数）。
首先判断 n 是否小于 1，如果是，则返回 0；如果 n 小于等于 2，返回 1，这两个条件是递归的结束条件。
如果 n 大于 2，则通过递归公式 fn(n) = fn(n-1)+fn(n-2) 计算第 n 项的值，即该项的前两项之和，继续调用 fibonacciIterative 函数求解第 n-1 和 n-2 项的值。
递归函数会不断地向下调用自身，直到满足结束条件才返回结果值。由于递归函数会反复调用自身，并且存在重复计算，因此在计算较大的斐波那契数列时，可能会出现性能问题。
// 优化的代码
1.向求解斐波那契数列时候，将求解过程图形化，可以看出，有些已经
求过的结点我们还会反复在求，如果把这些一求过的数存起来直接用，也会
提高效率
function fibonacciMemoization(n){
const memo = [0,1]
const fibonacci = (n) => {
if(meno[0] != null) return memo[n]
return memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo);
}
return fibonacci(n);
}树
二叉树搜索树 （快速查找）二叉树查找法
1.首先左侧节点存储（比父节点）小的值，右侧节点存储（比父节点）大的值，也就当我们每次去查的时候，
只要去比较查询节点和当前比较父节点大小，来决定他是走左面查询，还是右面查询，这样就不用去遍历
整个树
插入
1.插入后的数据一定要符合左侧节点存储（比父节点）小的值，右侧节点存储（比父节点）大的值，因此插入的时候也是要先和根节点比较，直到找到末尾，来决定插入的值是作为叶节点左侧还是右侧
插入重复数据解决
1.二叉查找树中每一个节点不仅会存储一个数据，因此我们通过链表和支持动态扩容的数组等数据结构，把值相同的数据存储在同一个节点上
2.每个节点仍然只存储一个数据。在查找插入位置过程中，如果碰到一个节点的值，与要插入数据的值相同，就将这个要插入的数据放到这个节点的右子树，也就是说，把这个新插入的数据当作大于这个节点的值来处理
排序
选择排序
思路：
1.找到数据中最小值并将放到第一位，然后找到第二小的将其放到第二位
2.选择排序分成两个区间，分别是“排序区间”和“未排序区间”，选择排序每次会从“未排序区间”中找到最小元素，将其放到末尾
3.对引用图说明一下，引用第一个图中的第二个数据说明
‘1 5 6 3 2 4’,现在的1是排序区间，‘5 6 3 2 4’是为了排序区间，说明图虽然是5和2直接交换，但实际末尾的'4'也是比较过了的，只是图上没参与本次运算
1.这里有个思维转换，当我们求一个数组中最小值和最大值的时候，我们用等价替换的方法，只是 循环了一次，
问题来了当我们要把数组中所有的都进行排序那单单的一次循环肯定不够的，这时候就是双层for 循环
2.这里还要注意的是'选择排序'的概念，我们其实会将整个数组分成两个区域，'排序区间'和'未排序区间'，其中'排序区间'
是在数组前半部分，因此已经排序过的地方肯定是不需要在进行排序因此第二层的循环条件也变成了'let j = i; j < length; j++'
// 选择排序
function selectionSort(array, compareFn = defaultCompare) {
const {
length
} = array
let indexMin
for (let i = 0; i < length-1; i++) {
// 等价替换
indexMin = i
for (let j = i; j < length; j++) {
if (compareFn(array[indexMin], array[j]) === Compare.BIGGER_THAN) {
indexMin = j
}
}
if (i !== indexMin) {
swap(array, i, indexMin)
}
}
return array
}
console.log(selectionSort(array))插入排序
1.插入排序每次排一个数组项，以此方式构建最后的排序数组。假定第一项已经排序了，接着，它和第二项进行比较第二项是应该待在原位还是插入到第一项之前呢？这样，头两项就正确排序，接着和第三项比较，以此类推
2.通俗的理解'插入排序'和'选择排序' 在整体思路方面差不多，首先'插入排序'也是将整个排序分成两个区间，分别是'排序区间'和'未排序区间',每次会从'未排序区间'中取值去以排序区间中比较，比较后将这个值插入到'以排序区间'
3.'插入排序'和'选择排序' 做个比较理解，'插入'是从'未排序区间'取值在'以排序区间去比较'，'选择'是从'未排序区间'
依次找到最小值放到'以排序区间'
4.如图红色区域就是'已排序区间'，黄色就是'未排序'区间，依次从黄色区域取值去红色区域比较，并且将值插入到合适的红色区域
1.这里默认将第一个元素作为'已排序'区间中的内容，这样方便后续逻辑
2.通过过动态图来理解下面插入算法中的while逻辑，首先是吧整个数组分成两个区域
'已排序区域' 一个是 '为排序区域'，第一层for是从为排序区域取出一个，'已排序区域'就是
从当前这个值往后都是以排序区域，因此while 的判断循环j 是从取点位置开始的，注意
动图插入的那个动作，如果你比我小我就把你往后移动，如果你比我大我就到大了位置，
整个while 就结束了，这个值就到了j的位置
// 插入排序
function insertionSort(array, compareFn = defaultCompare) {
const {
length
} = array;
let temp;
for (let i = 1; i < length; i++) {
let j = i;
temp = array[i];
while (j > 0 && compareFn(array[j - 1], temp) ===
Compare.BIGGER_THAN) {
array[j] = array[j - 1];
j--;
}
array[j] = temp;
}
return array;
};
insertionSort(array)
console.log(array)归并排序
1.‘归并算法’：将原始数组切成较小的数组，直到每个小数组只有一个位置，接着将小数组归并成较大的数组，直到最后只有一个排序完毕的大数组
2.如图和定义分析首先需要两步（因此我们需要连个方法）；
2.1. 第一个方法是分解需要将两个大数组不停的分割，直到每个项变成单独一个这个，这个过程需要一个递归方法
2.2 第二个方法需要合并在比较完成后，将每个小块依次比较最后形成一个大数组
3.上面用到思想较“分治思想”。将一个大问题分解成小的子问题来解决。小的子问题解决了，大问题也就解决了 
代码实现：
// 生成随机数数组
function randomArray(max,min,len){
let randomNum = 0
const array = []
for(let i = 0;i < len;i++){
randomNum = Math.floor((Math.random() * (max - min + 1)) + min)
array.push(randomNum)
}
return array
}
const Compare = {
LESS_THAN: -1,
BIGGER_THAN: 1,
EQUALS: 0
}
function defaultCompare(a,b){
if(a === b){
return Compare.EQUALS;
}
return a < b ? Compare.LESS_THAN : Compare.BIGGER_THAN;
}二分查找
在有序数组中查找某个元素的搜索算法。每一次比较都用中间的元素去比较，如果被搜索元素小于中间元素，则在左半区域重复搜索，如果被搜索元素大于中间元素，则在右半区域搜索。直到找到元素或确定数组中不存在该元素
function binarySearch(arr,target){
// left,right 用来做为整个数组的范围，索引0-数组长度-1
let left = 0;
let right = arr.length - 1;
while(left <= right){
let mid = Math.floor((left + right) / 2)
if(arr[mid] === target){
return mid;
} else if(arr[mid] < target){
left = mid + 1; // 在右半区查找
} else{
right = mid - 1; // 在左半去查找
}
}
return -1;
}
搜索插入位置 ：给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。时间复杂度为
O(log n)
输入: nums = [1,3,5,6], target = 5
输出: 2
输入: nums = [1,3,5,6], target = 2
输出: 1
输入: nums = [1,3,5,6], target = 7
输出: 4
const searchInsert = (nums,target) =>{
let start = 0;
let end = nums.length - 1
while(start <= end){
let mid = Math.floor((start + end) / 2)
if(nums[mid] === target){
return mid
}else if(nums[mid] > target){
end = mid - 1
}else{
start = mid + 1
}
}
return start;
}快速排序：将要排序的数据分割成独立的“两部分”，其中一部分所有数据比另一部分所有数据都要‘小’，用这个方法对这两部分数据进行快速排序，整个排序过程可以递归进行，达到有序序列
让一边数据比另一边数据都‘小’，思想：找到这一组数据中任意一个值作为“基准”在快速排序中叫做“主元”，这个“主元”会将数据分割成左右两部分，这两部分数据依次和“主元”比较，最后大的在一侧，小的在一侧
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
