一、图
（一）图是什么
图是网络结构的抽象模型，是一组由边连接的节点。图可以表示任何二元关系，比如道路、航班…
JS中没有图，但是可以用 Object 和 Array 构建图。图的表示法：邻接矩阵、邻接表…
1、邻接矩阵：用矩阵表示节点之间是否存在连接关系
2、邻接表：用对象和数组表示一个节点都和哪个节点有链接，还可以用链表等表示
（二）图的常用操作
-
深度优先遍历：尽可能深的搜索图的分支。
深度优先遍历算法口诀
① 访问根节点。
② 对根节点的没访问过的相邻节点挨个进行深度优先遍历。
由于图中节点的连接关系可能是双向的，所以在访问之前要先判断是否已经访问过，否则就会在两个相互连接的节点之间来回访问。
先创建一个可以共用的图，并且导出const graph = { 0: [1, 2], 1: [2], 2: [0, 3], 3: [3] } module.exports = graph;// 深度优先遍历 const gragh = require('./gragh') // 记录访问过的节点 let visited = new Set() const dfs = n =>{ // 访问当前节点 console.log(n) visited.add(n) // 没有访问过的相邻节点再进行深度优先遍历 gragh[n].forEach(item=>{ if(!visited.has(item)){ dfs(item) } }) } dfs(2)输出结果：
-
广度优先遍历：先访问离根节点最近的节点。
广度优先遍历算法口诀
① 新建一个队列，把根节点入队。
② 把队头出队并访问。
③ 把队头的没访问过的相邻节点入队。
④ 重复第二、三步，直到队列为空。const gragh = require('./gragh') const visited = new Set(); const bfs = n => { // 创建队列 let queue = [n]; // 队头直接加进去 visited.add(n) while (queue.length > 0) { // 访问队头并出队 const head = queue.shift() console.log(head) // 没有访问过的相邻节点再进行深度优先遍历 gragh[head].forEach(item => { if (!visited.has(item)) { queue.push(item) // 只要入队就加入visited，避免下次再push visited.add(item) } }) } } bfs(2)输出结果：
二、堆
（一）堆是什么
-
堆是一种特殊的完全二叉树。每层节点都完全填满，如果最后一层不满，则只缺少右节点
-
所有的节点都大于等于（最大堆）或小于等于（最小堆）它的子节点。
-
js中的堆：通常使用数组表示堆
我们可以使用一些总结出来的公式来计算节点的位置：
1、索引为index的节点的左侧子节点的位置是 2index+ 1
2、索引为index的节点的左侧子节点的位置是 2index+ 2
3、索引为index的节点的父节点位置是 (index- 1)/2 的商 -
堆的应用
堆能高效、快速地找出最大值和最小值，它的时间复杂度：0(1)。
找出第K个最大（小）元素。
例：求第K个最大元素
① 构建一个最小堆，并将元素依次插入堆中。
② 当堆的容量超过 K，就删除堆顶。
③ 插入结束后，堆顶就是第K 个最大元素。
最小堆的堆顶元素是堆的最小值
（二）js实现最小堆类
实现最小堆类主要是要实现堆的四个功能，其实就类似于数组
1、插入元素
2、删除堆顶
3、获取堆顶
4、获取堆的长度
// 最小堆类
class MinHeap {
constructor() {
// 用数组模拟堆
this.heap = [];
}
// 交换两个索引位置的值
swap(i1, i2) {
const temp = this.heap[i1]
this.heap[i1] = this.heap[i2]
this.heap[i2] = temp
}
// 获取父节点的index
getParantIndex(i) {
// 二进制的操作，把二进制的数字往右边移动一位
// 就是除以2得到的商
return (i - 1) >> 1
}
// 获取左侧子节点
getLeftIndex(i) {
return i * 2 + 1;
}
// 获取右侧子节点
getRightIndex(i) {
return i * 2 + 2
}
// 上移
shiftUp(index) {
// 如果上移到了堆顶，就结束上移
if (index == 0) return;
// 上移操作
const parentIndex = this.getParantIndex(index);
// 比较父节点和当前节点谁大
if (this.heap[parentIndex] > this.heap[index]) {
this.swap(parentIndex, index)
this.shiftUp(parentIndex)
}
}
// 下移
shiftDown(index) {
// 如果下移到了堆底则结束下移
if (index == this.heap.length - 1) return;
// 左子节点
const leftIndex = this.getLeftIndex(index)
if(this.heap[leftIndex]<= this.heap[index]){
this.swap(leftIndex, index)
this.shiftDown(leftIndex)
}
// 右子节点
const rightIndex = this.getRightIndex(index)
if(this.heap[rightIndex]<= this.heap[index]){
this.swap(rightIndex, index)
this.shiftDown(rightIndex)
}
}
// 一、插入元素
// 1 插入到堆的底部，即数组的尾部
// 2 然后上移：将这个值和它的父节点进行交换，直到父节点小于等于这个插入的值。
// 3 大小为 k 的堆中插入元素的时间复杂度为 O(logk)。
// 因为上移操作最多移动的次数就是堆的高度。所以时间复杂度是 O(logk)
insert(value) {
this.heap.push(value);
this.shiftUp(this.heap.length - 1)
}
// 二、删除堆顶
// 1 用数组尾部元素替换堆顶（直接删除堆顶，后面所有的元素会往前移动一位，会破坏堆结构）。
// 2 然后下移：将新堆顶和它的子节点进行交换，直到子节点大于等于这个新堆顶。
// 3 大小为k的堆中删除堆顶的时间复杂度为 O(logk)。
pop() {
this.heap[0] = this.heap.pop();
this.shiftDown(0)
}
// 三、获取堆顶
// 直接返回数组的头部
peek(){
return this.heap[0]
}
// 四、获取堆的长度
size(){
return this.heap.length
}
}
三、搜索排序算法
排序：把某个乱序的数组变成升序或者降序的数组。
搜索：找出数组中某个元素的下标。
js中的排序：sort()
js中的搜索：indexOf()
虽然javascript中提供的有现成的排序和搜索的方法，但是其中的实现原理也是值得我们深入学习的
排序算法常见的有以下几种·：
冒泡排序
选择排序
插入排序
归并排序
快速排序
搜索算法常见的有以下几种：
顺序搜索
二分搜索
（一）排序算法
1、冒泡排序
① 比较所有相邻元素，如果第一个比第二个大，则交换它们。
② 一轮下来，可以保证最后一个数是最大的。
③ n-1 轮下来，可以实现正序排列
冒泡排序需要进行两次for循环，时间复杂度是O(n的二次方)
// 冒泡排序
Array.prototype.bubbleSort = function () {
// 数组执行bubbleSort()方法的时候，this指向数组本身
for (let i = 0; i < this.length - 1; i++) {
for (let j = 0; j < this.length - 1 -i; j++) {
if (this[j] > this[j + 1]) {
[this[j], this[j + 1]] = [this[j + 1], this[j]]
}
}
}
}
2、选择排序
① 找到数组中的最小值，选中它并将其放置在第一位。
② 接着找到第二小的值，选中它并将其放置在第二位。
③ 以此类推，执行n-1轮。
// 选择排序
// 时间复杂度 两个嵌套循环 O(n的二次方)
Array.prototype.selectionSort = function () {
// 遍历元素，标记最小值
// 将最小值和数组的第一个元素进行交换
for (let i = 0; i < this.length - 1; i++) {
// i之前的元素都已经按从小到大的顺序排好了，只需要从i开始寻找最小值
let indexMin = i;
for (let j = i; j < this.length; j++) {
if (this[j] < this[indexMin]) {
indexMin = j
}
}
// 如果最小值不是第一个元素才需要交换
if (indexMin != i) [this[indexMin], this[i]] = [this[i], this[indexMin]]
}
}
4、插入排序
① 从第二个数开始往前比。
② 遇到比它大的数就往后面移动一位。例如下图，发现第一个数字是 46，第二个数字是44，就把第一个数字往后移动一位，和后面的数字交换数值
一直往前找，只要比当前数字大，就往后移动一位
③ 以此类推进行到最后一个数。
// 插入排序
// 时间复杂度 O(n的二次方)
Array.prototype.insertSort = function () {
// 先考虑第一次比较
// 从第二个数开始往前比
for (let i = 1; i < this.length; i++) {
const temp = i;
// 用j来表示往前找最小值找到的下标
let j = i;
while (j > 0) {
if (this[j - 1] > temp) {
this[j] = this[j - 1]
} else {
break
}
j -= 1;
}
// j就是要插入的位置并且原来的元素已经往后移动了
this[j] = temp
}
console.log(this)
}
4、归并排序
性能比前几种逗号
① 分：把数组劈成两半，再递归地对子数组进行“分”操作，直到分成一个个单独的数。
② 合：把两个数合并为有序数组，再对有序数组进行合并，直到全部子数组合并为一个完整数组。
合并有序数组：
① 新建一个空数组res，用于存放最终排序后的数字
② 比较两个有序数组的头部，较小者出队并推入res中。
③ 如果两个数组还有值，就重复第二步。
// 归并排序
// 时间复杂度：
// 分的时间复杂度是O(logn)
// 合的时间复杂度是O(n)
// 由于分和合是嵌套关系，所以整体的时间复杂度是O(n*logn)
Array.prototype.mergeSort = function () {
// 将所有元素分成单个元素的数组
const rec = (arr) => {
if (arr.length <= 1) {
// 此时的arr就已经是单个元素的数组的
return arr;
}
// 从中间开始劈成两半
const mid = Math.floor(arr.length / 2)
const left = arr.slice(0, mid)
const right = arr.slice(mid, arr.length)
// 单独的元素组成的数组
const orderLeft = rec(left)
const orderRight = rec(right)
// 合并两个有序数组
const res = []
while (orderLeft.length || orderRight.length) {
if (orderLeft.length && orderRight.length) {
// 找两个有序数组中头部更小的数组
// 将这个数组的头推出，并且push到res里面
res.push(orderLeft[0] < orderRight[0] ? orderLeft.shift() : orderRight.shift())
} else if(orderLeft.length) {
// 如果orderLeft还有值，就将orderLeft中的元素不断推出并push进res
res.push(orderLeft.shift())
}else if(orderRight.length) {
res.push(orderRight.shift())
}
}
return res
}
const res = rec(this)
// // 把res上面的值copy到this上
res.forEach((n,i)=>this[i] = n)
}
5、快速排序
① 分区：从数組中任意选择一个 “基准”，所有比基准小的元素放在基准前面，比基准大的元素放在基准的后面。
② 递归：递归地对基准前后的子数组进行分区。
// 时间复杂度
// 递归的时间复杂度是 O(logn)
// 分区的时间复杂度是 O(n)
// 总体的时间复杂度是 O(n*logn)
Array.prototype.quickSort = function () {
// 也需要递归，先创建一个递归方法
const rec = (arr) => {
if (arr.length <= 1) {
return arr;
}
// 创建left和right分别存放比基准小和比基准大的元素
const left = [];
const right = [];
// 基准元素设置为第一个元素
const mid = arr[0]
for (let i = 1; i < arr.length; i++) {
if (arr[i] < mid) {
left.push(arr[i])
} else {
right.push(arr[i])
}
}
return [...rec(left), mid, ...rec(right)]
}
const res = rec(this);
res.forEach((n,i)=>{
this[i] = n
})
}
（二）搜索算法
1、顺序搜索
顺序搜索是最基本的搜索，比较低效
① 遍历数组。
② 找到跟目标值相等的元素，就返回它的下标。
③ 遍历结束后，如果没有搜索到目标值，就返回-1。
// 顺序搜索
// 时间复杂度 O(n)
Array.prototype.sequentialSearch = function (target){
for(let i=0;i<this.length;i++){
if(this[i] == target) return i
}
return -1
}
2、二分搜索
① 从数组的中间元素开始，如果中间元素正好是目标值，则搜索结束。
② 如果目标值大于或者小于中间元素，则在大于或小于中间元素的那一半数组中搜索。
// 二分搜索
// 时间复杂度 每一次比较都使搜索范围缩小一半 O(logn)
// 假设数组是有序的
Array.prototype.binarySearch = function (target) {
// 搜索范围中的最小下标
let low = 0;
// 搜索范围中的最大下标
let high = this.length - 1;
while (low <= high) {
// 找中间索引
const mid = Math.floor((low + high) / 2)
const element = this[mid]
if (element < target) {
// 说明目标值在数值比较大的那一半里面
low = mid + 1;
} else if (element > target) {
high = mid - 1
}else{
return mid
}
}
return -1
}
四、算法设计思想
这一章是讲解决问题的方法、思路
（一）分而治之
① 分而治之是算法设计中的一种方法。
⑤ 它将一个问题分成多个和原问题相似的小问题，递归解决小问题，再将结果合并以解决原来的问题。
- 场景一：归并排序
✳️ 分：把数组从中间一分为二。
✳️ 解：递归地对两个子数组进行归并排序。
✳️ 合：合并有序子数组。 - 场景二：快速排序
✳️ 分：选基准，按基准把数组分成两个子数组。
✳️ 解：递归地对两个子数组进行快速排序。
✳️ 合：对两个子数组进行合并。
（二）动态规划
① 动态规划是算法设计中的一种方法。
② 它将一个问题分解为相互重叠的子问题，通过反复求解子问题，来解决原来的问题。
”动态规划“强调把问题分解为相互重叠的子问题，而”分而治之“强调把问题分解为相互独立的子问题
相互重叠的含义：子问题之间不会相互独立的，需要依赖其他子问题的结果
举一个例子帮助理解什么是相互重叠的子问题：斐波那契数列
其实就类似于数学里面的找规律，当前节点的解决依赖于前一个节点的解决
1、定义子问题：F(n) = F(n-1) + F(n-2)。
2、反复执行：从2循环到n，执行上述公式。
相互独立的含义：子问题之间没有任何关系，是独立的问题，例如翻转二叉树，拆分为翻转左子树和翻转右子树这两个问题，这两个问题之间没有任何关系
（三）贪心算法
① 贪心算法是算法设计中的一种方法。
② 期盼通过每个阶段的局部最优选择，从而达到全局的最优。
③ 结果并不一定是最优。
举个🌰帮助理解：
上面这道题coins给出了零钱的所有面值，以及要兑换的总额amount，求解最少需要几个零钱。如果使用贪心算法，每一步都使用可选择的最大面值，那么可能就不是最优解，比如第二种情况，选择两个3才是最优解
虽然贪心算法并不是在所有情况下都能得到最优解，但是有一些题目就比较适合使用贪心算法求解，以下题目：
力扣：455 分饼干； 122 买卖股票的最佳时机 II
（四）回溯算法
① 回潮算法是算法设计中的一种方法。
② 回溯算法是一种渐进式寻找并构建问题解决方式的策略。
③ 回潮算法会先从一个可能的动作开始解決问题，如果不行，就回潮并选择另一个动作，直到将问题解決。
就像在岔路口选择一条正确的路，先选一条路走一走，如果不行，就回到岔路口选另一条
什么问题适合用回溯算法来解决？
1、有很多路（路就是序列）
2、其中有死路也有活路
3、要用到递归
例如全排列问题
