基于snabbdom的diff算法的学习笔记-04最小化更新updateChildren

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量688 收藏 12
点赞数 15
文章标签： 算法 学习 笔记 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45789779/article/details/140787898
版权

最小化更新updateChildren

基本概念

文档中所用的虚拟节点模型

// 老节点
const oldVnode = h('ul', {}, [
   h('li', { key: 'A'}, '我是A'),
   h('li', { key: 'B'}, '我是B'),
   h('li', { key: 'C'}, '我是C'),
])
// 模型一
const newVnode = h('ul', {}, [
   h('li', { key: 'A'}, '我是AAA'),
   h('li', { key: 'B'}, '我是BBB'),
   h('li', { key: 'M'}, '我是M'),
   h('li', { key: 'N'}, '我是N'),
   h('li', { key: 'C'}, '我是CCC'),
])
// 模型二
const newVnode = h('ul', {}, [
   h('li', { key: 'B'}, '我是BBB'),
   h('li', { key: 'M'}, '我是M'),
   h('li', { key: 'N'}, '我是N'),
   h('li', { key: 'C'}, '我是CCC'),
])
// 模型三
const newVnode = h('ul', {}, [
   h('li', { key: 'B'}, '我是BBB'),
   h('li', { key: 'M'}, '我是M'),
   h('li', { key: 'N'}, '我是N'),
   h('li', { key: 'C'}, '我是CCC'),
   h('li', { key: 'A'}, '我是AAA'),
])
// 模型四
const newVnode = h('ul', {}, [
   h('li', { key: 'C'}, '我是CCC'),
   h('li', { key: 'A'}, '我是AAA'),
   h('li', { key: 'B'}, '我是BBB'),
   h('li', { key: 'M'}, '我是M'),
   h('li', { key: 'N'}, '我是N'),
])
// 模型五
const newVnode = h('ul', {}, [
   h('li', { key: 'A'}, '我是AAA'),
])
// 模型6
const newVnode = h('ul', {}, [
   h('li', { key: 'B'}, '我是BBB'),
    h('li', { key: 'M'}, '我是M'),
   h('li', { key: 'A'}, '我是AAA'),
   h('li', { key: 'C'}, '我是CCC'),
   h('li', { key: 'N'}, '我是N'),
])

四种指针

  • 新前：新前指针（newStartIdx)，指向新的虚拟节点未处理的第一个节点，初始化为0
  • 新后：新后指针（newEndIdx），指向新的虚拟节点未处理的最后一个节点，初始化为 newVnode.children.length - 1
  • 旧前：旧前指针（oldStartIdx），指向旧的虚拟节点未处理的第一个节点, 初始化为0
  • 旧后：旧后指针（oldEndIdx），指向旧的虚拟节点未处理的最后一个节点，初始化为oldVnode.children.length-1
    在这里插入图片描述

四种命中

  • 新前与旧前：新前指针指向的元素与旧前指针指向同一节点（同一节点定义请看第二篇），如模型一新前和旧前指针指向的都是h('li', {key: 'A'}, ''), 当命中时更新该节点，并将新前和旧前指针下移
  • 新后与旧后：新后指针和旧后指针指向同一节点，如模型二第一次循环时新后与旧后都指向h('li', { key: 'C'}, ''),，当命中时更新该节点，并将新后和旧后指针上移
  • 新后与旧前：新后指针和旧前指针指向同一节点，如模型三第一次循环时新后与旧前都指向h('li', {key: 'A'}, ，当命中该规则时，更新该元素，然后将新后指向的元素移动到旧后的后方，同时移动指针（新后指针上移，旧前指针下移）
  • 新前与旧后：新前指针和旧后指针指向同一节点，如模型四第一次循环时新后与旧前都指向h('li', { key: 'C'}, ''),，当命中该规则时，更新该元素，然后将新前指向元素移动到旧前的前方，同时移动指针（新前指针下移，旧后指针上移）

循环方式

循环目的：将旧的DOM树变更为新的Vnode能生成的DOM,新DOM时目的，旧DOM是基础。 为了节约性能，需找到对应节点更新、删除、新建、移动以实现最小化更新。

循环条件：新/旧虚拟节点未处理完毕，即newStartIdx<=newEndIdx && oldStartIdx <= oldEndIdx

循环方式：四种命中依次比较

举个例子：

以模型一为例
在这里插入图片描述

在这里插入图片描述

第一次循环，新前旧前都指向h('li', {key: 'A'}, ''), 更新这个节点（patchVnode)，及将key=A的文案变更为AAA，同时移动指针，即新前和旧前指针下移，指向h('li', { key: 'B'}, ''),，进入第二次循环。
在这里插入图片描述

第二次循环，新前和旧前指针都指向h('li', { key: 'B'}, ''),，更新节点，同时移动指针，即新前和旧前指针下移，旧前指向h('li', { key: 'C'}, ''),，新前指向h('li', { key: 'M'}, ''),，进入第三次循环。
在这里插入图片描述
在这里插入图片描述

第三次循环，新前与旧前指向节点不同，比较新后与旧后，发现都指向h('li', { key: 'C'}, ''),更新该节点，同时移动指针，即新后与旧后指针上移。此时旧后指针为1，旧前指针为2，不满足循环条件,结束循环。结束循环发现新前指针为2，新后指针为3 ， 新前指针不大于新后指针，此时新前与新后之间的节点及为新增节点，这些新增节点需新增在 h('li', { key: 'B'}, '我是CCC'),前方，及新后节点后一个节点的前方。

以模型五为例：
在这里插入图片描述

在这里插入图片描述

模型五循环结束时，旧前<=旧后，旧前与旧后节点之间的节点都需要删除。

根据以上，我们可以得到基本的最小化更新函数：

import patchVnode from "./patchVnode"
import createElement from "./createElement"
// 判断是否是同一节点
function checkSameVnode(a, b) {
    return a.sel === b.sel && a.key === b.key
}
export default function updateChildren(parentElm, oldCh, newCh) {
    console.log('我是upadate')
    // 旧前
    let oldStartIdx = 0
    // 新前
    let newStartIdx = 0
    // 旧后
    let oldEndIdx = oldCh.length - 1
    // 新后
    let newEndIdx = newCh.length - 1
    // 旧前节点
    let oldStartVnode = oldCh[0]
    // 旧后节点
    let oldEndVnode = oldCh[oldEndIdx]
    // 新前节点
    let newStartVnode = newCh[0]
    // 新后节点
    let newEndVnode = newCh[newEndIdx]
    while(oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
        // ① 新前与旧前
       if(checkSameVnode(oldStartVnode, newStartVnode)) {
            console.log('①')
           // 更新节点
            patchVnode(oldStartVnode, newStartVnode) 
           // 新前与旧前节点下移
            oldStartVnode = oldCh[++oldStartIdx] 
            newStartVnode = newCh[++newStartIdx]
        } 
        // ② 新后与旧后
        else if (checkSameVnode(oldEndVnode, newEndVnode)) {
            console.log('②')
            // 更新节点
            patchVnode(oldEndVnode, newEndVnode)
            // 新后与旧后节点上移
            oldEndVnode = oldCh[--oldEndIdx]
            newEndVnode = newCh[--newEndIdx]
        }
        // ③ 新后与旧前
        else if (checkSameVnode(oldStartVnode, newEndVnode)) {
            console.log('③')
            // 更新节点
            patchVnode(oldStartVnode, newEndVnode)
            // 如果给定的子节点是对文档中现有节点的引用，insertBefore() 会将其从当前位置移动到新位置（在将节点附加到其他节点之前，不需要从其父节点删除该节点）,若第二个参数为null，等同于appendChild()。
            // 把新后指向的vnode移动到旧后节点的后方
            parentElm.insertBefore(newEndVnode.elm, oldEndVnode.nextSibling?.elm)
            // 新后指针上移，旧前指针下移
            oldStartVnode = oldCh[++oldStartIdx]
            newEndVnode = newCh[--newEndIdx]
        }
        // ④ 新前与旧后
        else if (checkSameVnode(oldEndVnode, newStartVnode)) {
            console.log('④')
            // 更新节点
            patchVnode(oldEndVnode, newStartVnode)
            // 将新前指向的结点插入到旧前指向的节点前方
            parentElm.insertBefore(newStartVnode, oldStartVnode)
            // 新前指针下移，旧后指针上移
            oldEndVnode = oldCh[--oldEndIdx]
            newStartVnode = newCh[++newStartIdx]
        } 
        // ⑤ 四种指针命中都未命中
        else {
            
        } 
    }
    // 新增节点->新节点仍有剩余
    if (newEndIdx >= newStartIdx) {
        let before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm
        for (let i = newStartIdx; i < newEndIdx + 1; i++) {
            parentElm.insertBefore(createElement(newCh[i]), before)
        }
    }

    // 删除节点->老节点仍有剩余
    if (oldEndIdx >= oldStartIdx) {
        for (let i = oldStartIdx; i < oldEndIdx + 1; i++) {
            parentElm.removeChild(oldCh[i].elm)
        }
    }
}

在这里插入图片描述

四种命中都未命中

上文讲述了四种命中命中其一的处理场景，但是如模型6所示，我们会遇到四种命中都未命中的场景。针对这种场景，首先我们需要确定是否是新增节点，如果是就新增，如果不是就找到新前节点对应的旧节点并移动它到旧前节点的前方。

// key的MAP,降低循环的时间复杂度
let oldKeyToIdx
// 四种未命中时新节点在老节点中的位置
let idxInOld
// 四种未命中时新前节点需要移动到的位置
let elmToMove

// 构建第一次四个都未命中时未处理的老节点的key-index对象
// 经个人测试，如果存在的旧节点只是在头部复制了一份，由于缓存原因第二次进入会有bug，源码也有这个问题，但是缓存机制降低时间复杂度很牛逼，在这里保留，下方注释的方案可以解决这个bug
if (oldKeyToIdx === undefined) {
    oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
}
// oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
idxInOld = oldKeyToIdx[newCh[newStartIdx].key]
if (isUndef(idxInOld)) {
    // 新前指向的节点在未处理的老节点当中没有，需要创建这个节点并插入到旧前指向节点的上方
    parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
    // 将新前节点下移
    newStartVnode = newCh[++newStartIdx]
} else if (isUndef(oldKeyToIdx[newCh[newEndIdx].key])) {
    // 新后指向的节点在未处理的老节点当中没有，需要创建这个节点并插入到旧后节点的后方
    parentElm.insertBefore(createElement(newEndVnode), oldEndVnode.elm.nextSibling)
    // 将新后节点上移
    newEndVnode = newCh[--newEndIdx]
} else {
    // 新前和新后节点在老节点中存在，只是被移动了位子，不在旧前和旧后指针指向的位置
    elmToMove = oldCh[idxInOld]
    if (elmToMove.sel !== newStartVnode.sel) {
        // 非同一节点,处理方式同新前指向节点在旧的虚拟节点中不存在
        parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
    } else {
        // 同一节点
        patchVnode(elmToMove, newStartVnode)
        parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm)
        // 防止vnode树与Dom不匹配，如相同位置仍存在相同的DOM，且置为undefined后循环遇到该虚拟节点可以跳过
        oldCh[idxInOld] = undefined
    }
    // 新前指针下移
    newStartVnode = newCh[++newStartIdx]
}

// 存储老虚拟节点未处理的节点key值的map
function createKeyToOldIdx(children, beginIdx, endIdx) {
    const map = {}
    for(let i = beginIdx; i < endIdx; i++) {
        const chVnode = children[i]
        const key = chVnode === null || chVnode === 0 ? 0 : chVnode.key
        map[key] = i
    }
    return map
}
// 判断一个数据是否为undefined
function isUndef(data) {
    return data === undefined
}

综合以上的信息，得到一份基本的最小化更新代码：

import patchVnode from "./patchVnode"
import createElement from "./createElement"
// 判断是否是同一节点
function checkSameVnode(a, b) {
    return a.sel === b.sel && a.key === b.key
}
// 存储老虚拟节点未处理的节点key值的map
function createKeyToOldIdx(children, beginIdx, endIdx) {
    const map = {}
    for(let i = beginIdx; i < endIdx; i++) {
        const chVnode = children[i]
        const key = chVnode === null || chVnode === 0 ? 0 : chVnode.key
        map[key] = i
    }
    return map
}
// 判断一个数据是否为undefined
function isUndef(data) {
    return data === undefined
}
export default function updateChildren(parentElm, oldCh, newCh) {
    console.log('我是upadate')
    // 旧前
    let oldStartIdx = 0
    // 新前
    let newStartIdx = 0
    // 旧后
    let oldEndIdx = oldCh.length - 1
    // 新后
    let newEndIdx = newCh.length - 1
    // 旧前节点
    let oldStartVnode = oldCh[0]
    // 旧后节点
    let oldEndVnode = oldCh[oldEndIdx]
    // 新前节点
    let newStartVnode = newCh[0]
    // 新后节点
    let newEndVnode = newCh[newEndIdx]
    // key的MAP,降低循环的时间复杂度
    let oldKeyToIdx
    // 四种未命中时新节点在老节点中的位置
    let idxInOld
    // 四种未命中时新前节点需要移动到的位置
    let elmToMove
    while(oldStartIdx <= oldEndIdx && newStartIdx <= newEndIdx) {
        // 移除该节点，不需要比较直接跳过
        if (oldStartVnode == null) {
            oldStartVnode = oldCh[++oldStartIdx]; // Vnode might have been moved left
        }
        else if (oldEndVnode == null) {
            oldEndVnode = oldCh[--oldEndIdx];
        }
        else if (newStartVnode == null) {
            newStartVnode = newCh[++newStartIdx];
        }
        else if (newEndVnode == null) {
            newEndVnode = newCh[--newEndIdx];
        }
        // ① 新前与旧前
        else if(checkSameVnode(oldStartVnode, newStartVnode)) {
            // 比对同一节点
            console.log('①')
            patchVnode(oldStartVnode, newStartVnode)
            oldStartVnode = oldCh[++oldStartIdx]
            newStartVnode = newCh[++newStartIdx]
        } 
        // ② 新后与旧后
        else if (checkSameVnode(oldEndVnode, newEndVnode)) {
            console.log('②')
            patchVnode(oldEndVnode, newEndVnode)
            oldEndVnode = oldCh[--oldEndIdx]
            newEndVnode = newCh[--newEndIdx]
        }
        // ③ 新后与旧前
        else if (checkSameVnode(oldStartVnode, newEndVnode)) {
            console.log('③')
            patchVnode(oldStartVnode, newEndVnode)
            // 把新后指向的vnode移动到旧后节点的后方
            // 如果给定的子节点是对文档中现有节点的引用，insertBefore() 会将其从当前位置移动到新位置（在将节点附加到其他节点之前，不需要从其父节点删除该节点）。
            parentElm.insertBefore(newEndVnode.elm, oldEndVnode.nextSibling?.elm)
            oldStartVnode = oldCh[++oldStartIdx]
            newEndVnode = newCh[--newEndIdx]
        }
        // ④ 新前与旧后
        else if (checkSameVnode(oldEndVnode, newStartVnode)) {
            console.log('④')
            patchVnode(oldEndVnode, newStartVnode)
            // 将新前指向的结点插入到旧前指向的节点前方
            parentElm.insertBefore(newStartVnode, oldStartVnode)
            oldEndVnode = oldCh[--oldEndIdx]
            newStartVnode = newCh[++newStartIdx]
        } 
        else {
            console.log('⑤')
            // 都未命中
            // 构建第一次四个都未命中时未处理的老节点的key-index对象
            if (oldKeyToIdx === undefined) {
                oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
            }
            // oldKeyToIdx = createKeyToOldIdx(oldCh, oldStartIdx, oldEndIdx)
            idxInOld = oldKeyToIdx[newCh[newStartIdx].key]
            if (isUndef(idxInOld)) {
                // 新前指向的节点在未处理的老节点当中没有，需要创建这个节点并插入到旧前指向节点的上方
                parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
                // 将新前节点下移
                newStartVnode = newCh[++newStartIdx]
            } else if (isUndef(oldKeyToIdx[newCh[newEndIdx].key])) {
                // 新后指向的节点在未处理的老节点当中没有，需要创建这个节点并插入到旧后节点的后方
                parentElm.insertBefore(createElement(newEndVnode), oldEndVnode.elm.nextSibling)
                // 将新后节点上移
                newEndVnode = newCh[--newEndIdx]
            } else {
                // 新前和新后节点在老节点中存在，只是被移动了位子，不在旧前和旧后指针指向的位置
                elmToMove = oldCh[idxInOld]
                if (elmToMove.sel !== newStartVnode.sel) {
                    // 非同一节点
                    parentElm.insertBefore(createElement(newStartVnode), oldStartVnode.elm)
                } else {
                    // 同一节点
                    patchVnode(elmToMove, newStartVnode)
                    parentElm.insertBefore(elmToMove.elm, oldStartVnode.elm)
                    // 防止vnode树与Dom不匹配，如相同位置仍存在相同的DOM
                    oldCh[idxInOld] = undefined
                }
                // 新前指针下移
                newStartVnode = newCh[++newStartIdx]
            }
        } 
    }
    // 新增节点->新节点仍有剩余
    if (newEndIdx >= newStartIdx) {
        let before = newCh[newEndIdx + 1] == null ? null : newCh[newEndIdx + 1].elm
        for (let i = newStartIdx; i < newEndIdx + 1; i++) {
            parentElm.insertBefore(createElement(newCh[i]), before)
        }
    }

    // 删除节点->老节点仍有剩余
    if (oldEndIdx >= oldStartIdx) {
        for (let i = oldStartIdx; i < oldEndIdx + 1; i++) {
            parentElm.removeChild(oldCh[i].elm)
        }
    }
}
weixin_45789779
关注
机器学习笔记 - 基于Scikit-Learn的各种分类器进行分类并比较
学以致用 知行合一
06-15 763
scikit-learn是基于python语言构建机器学习应用程序的最佳库之一。简单易用，并且它有很多示例和教程。除了监督式机器学习（分类和回归）外，它还可用于聚类、降维、特征提取和工程以及数据预处理。该接口在所有这些方法上都是一致的，因此它不仅易于使用，而且也很容易构建一个大型分类器/回归模型集合并使用相同的命令训练它们。我们这里基于scikit-learn构建，训练，评估和验证分类器，通过超参数优化改进初始分类器。这里通过两个简单的示例数据集来进行分类。
【gcc】RtpTransportControllerSend学习笔记 3：gcc 算法
突围
10-07 1297
gcc
基于snabbdom的diff算法的学习笔记-03更新节点patchVnode
weixin_45789779的博客
07-30 266
【代码】基于snabbdom的diff算法的学习笔记-03更新节点patchVnode。
Virtual DOM 及 Diff 算法 - 学习笔记
爱玲姐姐的博客
12-15 1146
Virtual DOM 及 Diff 算法 文章出处：拉 勾 大前端 高薪训练营 1. JSX 到底是什么 使用 React 就一定会写 JSX，JSX 到底是什么呢？它是一种 JavaScript 语法的扩展，React 使用它来描述用户界面长成什么样子。虽然它看起来非常像 HTML，但它确实是 JavaScript 。在 React 代码执行之前，Babel 会对将 JSX 编译为 React API. <div className="container"> <h3&gt.
Vue源码解析之虚拟DOM和diff算法学习笔记+面试考点及回答+问题及解决+心得体会及总结+snabbdom的JS版本（阉割）
weixin_54515240的博客
04-07 996
Vue源码解析之虚拟DOM和diff算法学习笔记+问题解决+snabbdom的JS版本（阉割）+心得体会及总结+面试考点及回答
数据结构与算法----学习笔记（8）堆实战
qq_38055396的博客
05-07 267
.## 两个概念 元组 模拟大顶堆 1046.最后一块石头的重量 class Solution: def lastStoneWeight(self, stones: List[int]) -> int: # 将所有数取反，模拟小顶堆 heap = [-stone for stone in stones] # 对数组构造小顶堆 heapq.heapify(heap) while len(heap)&gt
Vue学习笔记---Vue中的虚拟DOM以及它 的Diff算法
weixin_42020084的博客
03-23 160
一、前言 Dom操作是比较浪费时间和性能的，当数据量很大的时候，更新DOM是很耗费性能的操作。Vue提供了虚拟DOM的解决办法。 Vue的核心是双向绑定和虚拟DOM（Virual DOMA），虚拟DOM是用js对象记录一个DOM节点的副本，当DOM发生更改的时候，先用虚拟DOM进行Diff，算出最小差异，然后再修改真实DOM。虚拟DOM和真实的DOM有一层映射关系，很多需要操作DOM的地方都会去...
关于“labuladong的算法小抄”的学习笔记---第0章核心框架汇总的前半部分框架（c++版）
小黑同学的博客
05-28 895
由于labuladong算法小抄大部分代码都是java，而作者其实是学c++的，因此，本笔记在记录的同时，对作者的java代码进行了转换，希望也能够帮到大家。因为怕文章太长，不好阅读，因此第0章分为了上半部分框架和下半部分技巧......
Linux学习笔记----不定时更新
Bingo的博客
02-16 452
VmWare 网络编辑器 编辑--->虚拟网络编辑 VMnet0 桥接模式 VMnet1 host-only VMnet8 NAT 网络地址转换 修改VMnet8 子网IP修改后，同步修改NAT设置和DHCP设置 Centos6.8 vi /etc/sysconfig/network-scripts/ifcfg-eth0 光标移动到 ONBOOT行： ONBOOT=ye...
[足式机器人]Part2 Dr. CAN学习笔记-Ch00-1 - 数学知识基础
LiongLoure的博客
12-26 1122
本文仅供学习使用 本文参考： B站：DR_CAN Dr. CAN学习笔记-Ch01 - 数学知识基础1. Ch0-1矩阵的导数运算1.1标量向量方程对向量求导，分母布局，分子布局1.1.1 标量方程对向量的导数1.1.2 向量方程对向量的导数1.2 案例分析，线性回归1.3 矩阵求导的链式法则2. Ch0-2 特征值与特征向量2.1 定义2.1.1 线性变换2.1.2 求解特征值，特征向量2.1.3 应用：对角化矩阵——解耦Decouple2.2 Summary3. Ch0-3线性化Linearizat
Vue2.x-虚拟DOM和diff算法（笔记）
wanghuan1020的博客
01-12 4706
虚拟DOM和diff算法虚拟DOM和diff算法简述snabbdom简介安装测试环境搭建虚拟 DOM 和 h 函数虚拟 DOMh 函数基本使用嵌套使用手写 h 函数diff 算法例子diff 处理新旧节点不是同一个节点时diff 处理新旧节点是同一个节点时手写新旧节点text的不同情况尝试书写 diff 更新子节点diff 算法的子节点更新策略手写子节点更新策略 虚拟DOM和diff算法 简述 diff 算法 以装修房子为例，如果我们仅需要在客厅新添一座沙发或者将卧室的床换个位置。那么将整个房子重新
计算左边（比自己小的元素）的最长距离
wniuniu_的博客
09-14 107
前言：一般做的题目都是使用单调栈来求出距离这个点最近的那个比这个数大或小的元素，但是如果是需要找到最远的那个元素呢？我们可以用到类似逆序对的思路，我们先进行排序从小到大，接着我们先处理左边，每次维护一个最小的下标。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1060
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1133
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 622
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
专题三_二分查找算法_算法详细总结
2301_80636070的博客
09-09 977
二分查找经典题目。首先最重要的就是判断循环的结束条件，left>right,因为在这之前，left==right的时候，仍然要判断一次nums[left]是否等于target，所以循环条件就是while(left
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 413
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 390
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
深入理解Vue的diff算法
在数据发生变化时，Vue通过diff算法来找出最小的DOM变更，以实现高效且精确的视图更新。 1. **Vue更新节点的机制** 当Vue中的数据发生变化时，它首先会根据新的数据生成一个新的虚拟DOM树（Vtree），并与旧的虚拟...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值