精华内容
下载资源
问答
  • 虚幻引擎4蓝图节点

    千次阅读 多人点赞 2020-04-13 19:09:32
    收集一些自己了解的蓝图节点,以便更好地学习。

    前言

    此文章为收集虚幻引擎蓝图中的节点所写,随着学习的深入会继续添加其他的蓝图节点,有些自己都不大理解的节点就不介绍了。
    节点的作用以及接口大多是博主自己描述的,如果有出现描述与实际不符时可以在文章下方留言。

    虚幻引擎在新的版本有将节点进行汉化,如果你找不到该节点有可能是英汉转换过的,也有可能是还没有收录到文章中的节点。
    注:此篇文章并非官方文档节点的汉化版,仅为个人学习收集。

    虚幻引擎版本:4.23.1

    节点简介
    节点的左侧为输入的接口
    节点右侧为输出的接口
    节点执行的顺序为从左到右
    通过事件节点可触发执行节点
    执行节点可通过读取节点获取所需的值
    节点类型介绍
    事件节点红色标题,可以用于触发其他的节点
    执行节点蓝色标题,需要被触发才能执行某种功能
    读取节点绿色标题,可以对某个值进行运算,然后传出给其他节点

    为了方便查阅相应的节点,节点会根据虚幻蓝图中所属的分类来进行区分。

    类型将会以序号开头(① ②…),如果是蓝图节点的话将会在标题后添加“节点”

    在这里插入图片描述

    虚幻引擎4文档

    虚幻引擎蓝图API参考文档

    HelloCJC虚幻引擎社区

    蓝图节点导航

    ①AI

    ②Behavior Tree

    Finish Execute-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:结束一个任务Task

    输入接口介绍
    目标连接需要结束的任务蓝图
    Success是否完成任务蓝图,默认为OFF

    Set Blackboard Value as Vector-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变黑板中的键值为某个坐标

    输入接口介绍
    Key连接需要变更的黑板键值
    Value变更的坐标值

    ②Navigation

    GetRandomPointInNavigableRadius-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获得某个圆形区域内的一个随机坐标

    输入接口介绍
    Origin圆点的位置
    Radius圆的半径,类型为浮点型
    Nav Data导航数据
    Filter Class过滤器类别
    输出接口介绍
    Random Location输出该圆形区域的一个随机坐标
    Return Value是否成功生成随机坐标,是则返回true,类型为布尔型

    ②Run Behavior Tree-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:执行AI行为树,实现AI功能

    输入接口介绍
    目标执行AI行为树的物体
    BTAsset需要执行的AI行为树
    输出接口介绍
    Return Value是否成功执行了AI行为树,类型为布尔型

    ①Appearance

    Set Brush from Texture-节点

    该节点只能通过image组件的输出接口搜索创建,不能直接搜索创建

    在这里插入图片描述
    在这里插入图片描述
    作用:设置Image组件的Brush贴图

    输入接口介绍
    目标默认为自身
    Texture需要设置的图片
    Match Size是否根据组件大小对图片进行缩放,默认为False,类型为布尔

    ①Audio

    ②Components

    ③Audio

    Is Playing-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:判断音频组件是否正在播放音效

    输入接口介绍
    目标连接需要判断的Audio组件
    输出接口介绍
    Return Value若组件正在播放输出true,否则输出false,类型为布尔

    Play-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:触发指定的音频组件进行播放

    输入接口介绍
    目标连接需要播放的Audio组件
    Start Time播放的开始时间,单位为秒,类型为浮点型,默认为0,如果有一段音频共20秒长度,Start Time设置为10,表示直接在音频的第10秒处开始播放,前面的10秒将会忽略不播放。

    Stop-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:停止某个音频组件的播放(并非暂停)

    输入接口介绍
    目标连接需要停止播放的Audio组件

    Stop Delayed-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:延迟一段时间后,停止某个音频组件的播放(并非暂停)

    输入接口介绍
    目标连接需要停止播放的Audio组件
    Delay Time延迟的时间,单位为秒,类型为浮点型,默认值为0

    ①Character

    Jump-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:让目标跳跃。

    输入接口介绍
    目标连接一个执行跳跃的物体

    Stop Jumping-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:停止目标的跳跃。

    输入接口介绍
    目标连接一个执行停止跳跃的物体

    ①Collision

    Break Hit Result-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:从碰撞信息中分离出更细的内容

    输入接口介绍
    Hit需要分离的碰撞信息
    输出接口介绍
    Blocking Hit如果存在阻挡命中返回True,否则为false,类型为布尔型
    Initial Overlap如果命中在一个初始重叠中开始,则为True,类型为布尔型
    Time发生命中所需的时间,范围为0.0到1.0,若值为1.0时表示无命中,类型浮点型
    Distance从射线起始点到碰撞体位置的距离,类型为浮点型
    Location碰撞体在场景中的坐标
    Impact Point射线与碰撞体接触点的坐标
    Normal场景空间中命中的法线,用于被扫描的对象
    Impact Normal场景空间中命中的法线,用于被扫描的对象
    Phys Mat碰撞体的物理材质
    Hit Actor被射线命中的碰撞体
    Hit Component被射线命中的碰撞体相应的组件
    Hit Bone Name命中的骨架名称,仅在命中骨架网格体时有效
    Hit Item基元特定的数据,记录基元中被命中的项目(推测是射线被命中的物体数量),类型为整型
    Face Index与三角网格图或地形发生碰撞时,被命中面的索引(下标)
    Trace Start射线的开始坐标
    Trace End射线的结束坐标

    LineTraceByChannel-节点

    在这里插入图片描述

    在这里插入图片描述
    作用:发射射线进行碰撞检测,并将该碰撞体的信息输出

    输入接口介绍
    Start射线开始的位置
    End射线结束的位置
    Trace Channel追踪通道
    Trace Complex复杂追踪,默认为OFF
    Actors to Ignore碰撞检测忽略的对象,类型为数组
    Draw Debug Type调试类型
    Ignore Self碰撞检测是否忽略自身,默认为ON
    Trace Color射线颜色
    Trace Hit Color射线接触点的颜色
    Draw Time射线的持续时间,类型为浮点型
    输出接口介绍
    Out Hit输出碰撞结果
    Return Value是否有检测到碰撞,类型为布尔型
    Draw Debug Type介绍
    None
    For One Frame每帧
    For Duration一段时间
    Persistent持续存在

    ①Components

    ②Activation

    Activate-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:激活场景组件,使其可被控制,但执行此节点不会获取该场景组件的控制。

    输入接口介绍
    目标连接一个需要激活的组件
    Reset是否进行激活(不大清楚具体的效果,可以不用勾选)

    Deactivate-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:停用场景组件,若还有其他已激活的场景组件时,将会转到该组件的控制。

    输入接口介绍
    目标连接一个需要停用的组件

    ①Game

    ②Cinematic

    Set Game Paused-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:暂停游戏

    输入接口介绍
    Paused是否暂停游戏,类型为布尔,默认为OFF
    输出接口介绍
    Return Value暂停成功输出True,失败则输出False,类型为布尔

    Is Game Paused-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:输出游戏的暂停状态

    输出接口介绍
    Return Value当游戏处于暂停状态时,输出True,否则输出False类型为布尔

    Get Player Character-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:返回玩家角色

    输入接口介绍
    Player Index填写相应玩家索引,类型为整型(值为0时表示player 0,即自身)
    输出接口介绍
    Return Value输出相应的玩家角色

    Get Player Controller-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:返回玩家控制器

    输入接口介绍
    Player Index填写相应玩家索引,类型为整型(值为0时表示player 0,即自身)
    输出接口介绍
    Return Value输出相应的玩家控制器

    Quit Game-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:退出游戏操作

    输入接口介绍
    Specific Player需要退出的玩家,默认为玩家0(即自身)
    Quit Preference退出的方式
    Ignore Platform Restrictions是否忽略平台限制,类型为布尔型

    打开关卡-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:打开一个关卡地图

    输入接口介绍
    Level Name关卡地图的名字,默认为空,类型为字符串
    Absolute默认为True,类型为布尔
    Options可选项,类型为字符串

    ① HUD

    Draw Text-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:在HUD上绘制一个字符串

    输入接口介绍
    目标需要绘制字符串的HUD目标,默认为自身
    Text绘制的字符串内容,类型为字符串
    Text Color字符串颜色
    Screen X横轴,默认为0,值为0时为屏幕最左边的点,类型为浮点型
    Screen Y竖轴,默认为0,值为0时为屏幕最上角的点,类型为浮点型
    Font字体
    ScaleHUD的大小,类型为浮点型
    Scale Positionscale的缩放值是否会影响HUD的位置,类型为布尔

    Draw Texture-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:在HUD中绘制图形

    注:对图形的延伸相当于,将原本一个固定的Texture区域划分成多个块,每个块都是同样的Texture

    输入接口介绍
    目标需要绘制字符串的HUD目标,默认为自身
    Texture需要绘制的图形
    Screen X横轴,默认为0,值为0时为屏幕最左边的点,类型为浮点型
    Screen Y竖轴,默认为0,值为0时为屏幕最上角的点,类型为浮点型
    Screen W图形宽度,默认为0,类型为浮点型
    Screen H图形高度,默认为0,类型为浮点型
    Texture U图形锚点的X轴坐标,默认为0,类型为浮点型
    Texture V图形锚点的Y轴坐标,默认为0,类型为浮点型
    Texture UWidth图形在X轴方向的复制延伸,默认为0,类型为浮点型
    Texture VHeight图形在Y轴方向的复制延伸,默认为0,类型为浮点型

    Draw Texture Simple-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:是Draw Texture节点的简化版,在HUD上绘制图形

    输入接口介绍
    目标需要绘制字符串的HUD目标,默认为自身
    Texture需要绘制的图形
    Screen X横轴,默认为0,值为0时为屏幕最左边的点,类型为浮点型
    Screen Y竖轴,默认为0,值为0时为屏幕最上角的点,类型为浮点型
    ScaleHUD的大小,类型为浮点型
    Scale Positionscale的缩放值是否会影响HUD的位置,类型为布尔

    ①Math

    ②Byte

    %(Byte)-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:输出上接口对下接口的求余结果。

    ②Conversions

    ToBool(integer)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将整型的数据转换成布尔型数据输出

    ToInt(bool)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将布尔型的数据转换成整型数据输出

    ②Date Time

    GetDate-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取传入参数的日期,并输出

    ②Float

    Equal(float)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:判断两个float变量值是否相等,相等则返回True,若不相等时不输出。

    NoEqual(float)-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:判断两者是否不等,如果不等则输出True,否则不输出

    Truncate-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将输入的数值截断小数后,输出整数

    Truncate(Vector)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将输入的数值截断小数后,输出整数

    %(float)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:输出上接口对下接口的求余结果。

    ②Integer

    Equal(integer)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:判断两个整型值是否相等,相等则输出True,若不相等时不输出。

    integer + integer 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将多个整型变量的值相加,并输出。通过添加引脚可以添加新的输入接口。

    integer - integer 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将两个整型变量的值相减,输出值=上接口变量 - 下接口变量。

    integer * integer 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将多个整型变量的值相乘,并输出。通过添加引脚可以添加新的输入接口。

    integer / integer 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将两个整型变量的值相除,输出值=上接口变量 / 下接口变量。

    NoEqual(integer)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:判断两个值是否不等,如果不等则输出True,否则不输出

    %(integer)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:输出上接口对下接口的求余结果

    Make Literal Int-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:输出整数

    输入接口介绍
    Value连接需要输出的整数,不连接时默认为0
    输出接口介绍
    Return Value输出整数

    ②Rotator

    Make Rotator-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:根据Roll、Pitch、Yaw值创建旋转向量并输出

    输入接口介绍
    X (Roll)Roll值,默认为0,类型为浮点型
    Y (Pitch)Pitch值,默认为0,类型为浮点型
    Z (Yaw)Yaw值,默认为0,类型为浮点型
    输出接口介绍
    Return Value输出Roll、Pitch、Yaw三者组成的向量

    ②String

    Equal(string)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:判断两个字符串值是否相等,相等则输出True,若不相等时不输出。

    ②Transform

    Make Transform-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将所需不同物体的位置、旋转和缩放创建一个变换

    输入接口介绍
    Location获取相应的坐标
    Rotation获取旋转
    Scale获取相应的缩放
    输出接口介绍
    Return Value输出一个变换

    ②Vector

    RotateVector-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将旋转和坐标位置进行结合,输出一个向量

    输入接口介绍
    A连接需要结合的坐标
    B连接需要结合的旋转

    vector + float 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将一个浮点数添加到一个向量中,并输出向量

    vector + int 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将一个整数添加到一个向量中,并输出向量

    vector + vector 节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将两个向量进行结合,输出结合后的向量

    ①Online

    ②Session

    Create Session-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:创建会话,可让其他玩家加入

    输入接口介绍
    Player Controller玩家控制器,用于连接需要创建会话的角色
    Public Connections会话的最大加入玩家数,默认为0,类型为整型
    Use LAN是否启用局域网,类型为布尔
    输出接口介绍
    On Success创建会话成功时将会执行与其连接的节点
    On Failure创建会话失败时将会执行与其连接的节点

    Find Sessions-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:搜索一个会话,并返回搜索到的会话信息

    输入接口介绍
    Player Controller玩家控制器,用于连接需要查找会话的角色
    Max Results查找的会话最大玩家数,默认为0,类型为整型
    Use LAN查找的会话是否为局域网类型,类型为布尔
    输出接口介绍
    On Success查找会话成功时将会执行与其连接的节点
    On Failure查找会话失败时将会执行与其连接的节点
    Results保存了该会话的所有信息,可与其他节点连接使用这些信息,类型为数组

    Get Current Players-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取当前玩家数

    输入接口介绍
    Result连接一个包含会话信息的数组,类型为数组
    输出接口介绍
    Return Value输出当前玩家数量,类型为整型

    Get Max Players-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取会话最大玩家数

    输入接口介绍
    Result连接一个包含会话信息的数组,类型为数组
    输出接口介绍
    Return Value输出该会话最大可容纳的玩家数量,类型为整型

    Get Ping in Ms-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取会话的延迟

    输入接口介绍
    Result连接一个包含会话信息的数组,类型为数组
    输出接口介绍
    Return Value输出该会话当前的延迟大小,类型为整型

    Get Server Name-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取服务器的名称

    输入接口介绍
    Result连接一个包含会话信息的数组,类型为数组
    输出接口介绍
    Return Value输出服务器的名称,类型为字符串

    Join Session-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:加入一个已有的会话

    输入接口介绍
    Player Controller玩家控制器,用于连接需要加入会话的角色
    Search Result查找会话的结果,类型为数组
    输出接口介绍
    On Success加入会话成功时将会执行与其连接的节点
    On Failure加入会话失败时将会执行与其连接的节点

    ①Pawn

    ②Input

    Add Controller Pitch Input-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:调用val值来变更目标的Yaw值,从而实现目标在Pitch方向的旋转。(绕Y轴的旋转方向)
    在这里插入图片描述

    接口介绍
    目标连接一个需要旋转的物体
    Val可连接传值接口,类型为浮点型,获取Pitch的变化值。

    Add Controller Roll Input-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:调用val值来变更目标的Roll值,从而实现目标在Roll方向的旋转。(绕X轴的旋转方向)
    在这里插入图片描述

    接口介绍
    目标连接一个需要旋转的物体
    Val可连接传值接口,类型为浮点型,获取Roll的变化值。

    Add Controller Yaw Input-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:调用val值来变更目标的Yaw值,从而实现目标在Yaw方向的旋转。(绕Z轴的旋转方向)
    在这里插入图片描述

    输入接口介绍
    目标连接一个需要旋转的物体
    Val可连接传值接口,类型为浮点型,获取Yaw的变化值。

    Add Movement Input-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变某个物体在世界轴当中的位置。

    输入接口介绍
    目标连接需要移动的物体
    World Direction可连接Get Forward VectorGet Right Vector节点来获取物体在世界当中的方向
    Scale Value移动的距离,类型为浮点型
    Force布尔类型(目前尚不清楚其作用)

    Possess-节点

    该节点可通过某些节点的输出引用来创建,不能单独搜索创建

    在这里插入图片描述
    在这里插入图片描述
    作用:设置某一个蓝图类的控制者

    输入接口介绍
    目标需要变更成哪个玩家控制
    In Pawn连接需要变更控制权的蓝图类

    ①Physics

    Add Impulse at Location-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:为一个组件添加冲量,冲量越大物体撞击的力度越大。

    输入接口介绍
    目标连接需要添加冲量的组件
    Impulse冲量相应的数值
    Location可连接GetActorLocation节点来获取物体在世界轴的位置
    Bone Name冲量的名称

    ①Progress

    Set Percent-节点

    该节点可通过某些节点的输出引用来创建,不能单独搜索创建

    在这里插入图片描述
    在这里插入图片描述
    作用:设置血条的百分比

    输入接口介绍
    目标连接需要设置的Progress Bar血条
    Inpercent设置血条的百分比,类型为浮点型,默认值为0

    ①Rendering

    ②Components

    ③Text Render

    Set Text-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变文本值

    输入接口介绍
    目标需要变更文本目标
    Value连接变更的文本值

    ①Save Game

    Create Save Game Object-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:创建一个SaveGame类,可输出相应的对象以供使用。

    输入接口介绍
    Save Game Class需要创建的Save Game类(该类用于保存游戏数据)
    输出接口介绍
    Return Value输出Save Game类的对象

    Does Save Game Exist-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:检查指定名称的存档是否存在。

    输入接口介绍
    Slot Name存档名称,类型为字符串
    User Index玩家索引,类型为整型
    输出接口介绍
    Return Value输出该存档是否存在,存在则输出True,否则输出False,类型为布尔

    Load Game from Slot-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:从指定的存档中加载游戏数据,可输出相应的对象以供使用。

    输入接口介绍
    Slot Name存档名称,类型为字符串
    User Index玩家索引,类型为整型
    输出接口介绍
    Return Value输出Save Game类的对象

    ①User Iterface

    ②Viewport

    Add to Player Screen-节点

    无法通过搜索直接创建

    在这里插入图片描述
    在这里插入图片描述
    作用:添加界面到屏幕,适用于分屏游戏

    输入接口介绍
    目标需要添加的目标控件
    ZOder控件层级,数值越大层级越高
    输出接口介绍
    Return Value如果添加成功则输出True,否则输出False,类型为布尔

    Add to Viewport-节点

    无法通过搜索直接创建

    在这里插入图片描述
    在这里插入图片描述
    作用:添加界面到屏幕

    输入接口介绍
    目标需要添加的目标控件
    ZOder控件层级,数值越大层级越高

    ①Utilities

    ②Array

    ADD-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将某个元素添加到数组的末尾,并将添加的元素输出

    Append Array-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将下接口数组的元素添加到上接口数组的末尾

    Length-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取数组中元素的数量,并输出

    Remove Index-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:删除数组中的某个索引(下标)的元素,删除该索引后,之后的元素将会前移。

    Set Array Elem-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:对数组的某个元素进行变更

    输入接口介绍
    Target Array目标数组
    Index数组相应的索引(下标)
    Item需要变成什么值
    Size to Fit若索引(下标)超过数组原本的个数时,将会将数组扩展

    DestroyActor-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:通过执行该节点,来清除某个物体

    输入接口介绍
    目标连接需要被清除的物体,不连接时默认清除自身(即清除该蓝图类)

    ②Flow Control

    Delay-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:延迟执行

    输入接口介绍
    Duration延迟时间的设置,可调用外部值

    ②Transformation

    AddActorLocalOffset-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变物体的位置,在原基础上添加

    输入接口介绍
    目标执行的物体
    Delta Rotation执行一次节点时,所添加的坐标值
    Sweep是否扫描到目标位置,默认为False,类型为布尔
    Teleport是否传送物理状态,默认为False,类型为布尔
    输出接口介绍
    Sweep Hit Result输出该物体移动或旋转后命中的物体结果

    AddActorLocalRotation-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变物体的旋转,在原基础上添加

    输入接口介绍
    目标执行的物体
    Delta Rotation执行一次节点时,所添加的旋转值
    Sweep是否扫描到目标位置,默认为False,类型为布尔
    Teleport是否传送物理状态,默认为False,类型为布尔
    输出接口介绍
    Sweep Hit Result输出该物体移动或旋转后命中的物体结果

    AddActorWorldOffset-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变物体位置,在原物体的位置上添加

    输入接口介绍
    目标执行节点的物体
    Delta Location执行一次节点时,所添加的坐标值
    Sweep是否扫描到目标位置,默认为False,类型为布尔
    Teleport是否传送物理状态,默认为False,类型为布尔
    输出接口介绍
    Sweep Hit Result输出该物体移动或旋转后命中的物体结果

    AddActorWorldRotation-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:改变物体的旋转,在原基础上添加

    输入接口介绍
    目标执行的物体
    Delta Rotation执行一次节点时,所添加的旋转值
    Sweep是否扫描到目标位置,默认为False,类型为布尔
    Teleport是否传送物理状态,默认为False,类型为布尔
    输出接口介绍
    Sweep Hit Result输出该物体移动或旋转后命中的物体结果

    AddActorWorldTransform-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:改变物体的旋转和位置,在原基础上添加

    输入接口介绍
    目标执行的物体
    Delta Rotation执行一次节点时,所添加的旋转和位置值组成的向量
    Sweep是否扫描到目标位置,默认为False,类型为布尔
    Teleport是否传送物理状态,默认为False,类型为布尔
    输出接口介绍
    Sweep Hit Result输出该物体移动或旋转后命中的物体结果

    GetActorLocation-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取一个物体在世界中的坐标,输出该坐标
    在这里插入图片描述

    输入接口介绍
    目标连接一个需要获取坐标的物体
    输出接口介绍
    Return Value输出目标物体在世界中的坐标

    GetActorRotation-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取一个物体在世界中的旋转角度(Roll、Pitch、Yaw),输出旋转角度.
    在这里插入图片描述

    输入接口介绍
    目标连接一个需要获取旋转角度的物体
    输出接口介绍
    Return Value输出目标物体在世界中的旋转角度

    GetWorldRotation-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:获取一个物体在世界中的旋转角度(Roll、Pitch、Yaw),输出旋转角度.
    在这里插入图片描述

    输入接口介绍
    目标连接一个需要获取旋转角度的物体
    输出接口介绍
    Return Value输出目标物体在世界中的旋转角度

    ②String

    Append-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将按从上到下的顺序将字符串组合,并输出

    输出接口介绍
    Return Value输出组合后的字符串
    添加引脚添加新的字符串接口

    Make Literal String-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:输出字符串。

    输入接口介绍
    Value可以在方框处填写需要输出的字符串,也可以连接调用字符串变量
    输出接口介绍
    Return Value输出字符串

    Print String-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:在屏幕中打印出字符串,新字符串从左上角生成,旧字符串将会往下排列。

    输入接口介绍
    In String可连接传值接口,类型为字符串,输出该字符串的内容
    Print to Screen是否显示到屏幕
    Print to Log是否记录到日志
    Text Color文本的颜色
    Duration文本显示的时间

    ToString(boolean)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将布尔型的数据转换成字符串型数据(true/false)输出

    ToString(float)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将浮点型的数据转换成字符串型数据输出

    ToString(integer)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将整型的数据转换成字符串型数据输出

    ②Text

    Make Literal Text-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:创建一个文本,或是连接其他的文本值

    输入接口介绍
    Value连接需要传输的文本值,不连接值可直接创建文本

    Print Text-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将文本打印到屏幕

    输入接口介绍
    In Text连接需要打印的文本,不连接时可填写文本
    Print to Screen是否显示到屏幕
    Print to Log是否输出到日志
    Text Color文本的颜色
    Duration文本显示的时间

    ToText(float)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:将浮点型数值转换为文本并输出

    输入接口介绍
    Value连接需要转换的浮点型数值
    Rounding Mode转换的模式
    Always Sign默认为OFF
    Use Grouping默认为ON
    Minimum Integral Digits浮点型数据的整数区最小位数
    Maximum Integral Digits浮点型数据的整数区最大位数
    Minimum Fractional Digits浮点型数据的小数区最小位数
    Maximum Fractional Digits浮点型数据的小数区最大位数
    Rounding Mode介绍
    Half to Even四舍五入到最近的整数,如果两边距离相同时四舍五入到偶数的值
    Half from Zero四舍五入到最近的整数,如果两边距离相同时四舍五入到远离0的整数值
    Half to Zero四舍五入到最近的整数,如果两边距离相同时四舍五入到靠近0的整数值
    From Zero直接舍入到远离0的整数值
    To Zero直接舍入到靠近0的整数值
    To Negative Infinity直接舍入到较小的整数值
    To Positive Infinity直接舍入到较大的整数值

    ②流程控制

    分支-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于if()语句,条件为真时执行True,条件为假执行False

    输入接口介绍
    Condition连接需要进行判断的条件。当没有勾选时,条件为真执行False,条件为假执行True

    ①Viewport

    Remove All Widgets-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:删除所有的控件

    ①Widget

    ②Panel

    Add Child-节点

    该节点不能直接搜索创建,需要通过某些节点的输出接口创建

    在这里插入图片描述
    在这里插入图片描述
    作用:将控件添加到某个容器组件中

    输入接口介绍
    目标需要添加的目标容器
    Content需要添加的子控件
    输出接口介绍
    Return Value输出目标组件的对象

    Has Any Children-节点

    该节点不能直接搜索创建,需要通过某些节点的输出接口创建

    在这里插入图片描述
    在这里插入图片描述
    作用:判断目标面板是否含有子组件

    输入接口介绍
    目标连接需要判断的面板
    输出接口介绍
    Return Value若目标面板存在子组件输出True,不存在则输出False,类型为布尔

    Has Child-节点

    该节点不能直接搜索创建,需要通过某些节点的输出接口创建

    在这里插入图片描述
    在这里插入图片描述
    作用:判断目标面板中是否存在某个组件

    输入接口介绍
    目标连接需要判断的面板,默认为自身
    Content选择或连接需要判断的组件
    输出接口介绍
    Return Value若存在则输出True,不存在输出False,类型为布尔

    Remove from Parent-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:删除某个控件

    ①变量

    ②Character Movement: Walking

    设置 Max Walk Speed-节点

    该节点可通过某些节点的输出引用来创建,不能单独搜索创建

    在这里插入图片描述
    在这里插入图片描述
    作用:设置玩家的移动速度

    输入接口介绍
    Max Walk Speed需要变更的速度大小
    目标连接需要变更移动速度的目标

    ②Mouse Interface

    设置 Show Mouse Cursor-节点

    该节点不能通直接搜索创建,需要通过其他节点创建

    在这里插入图片描述
    在这里插入图片描述
    作用:显示或隐藏鼠标指针

    输入接口介绍
    Show Mouse Cursor是否显示鼠标指针,默认为False,类型为布尔
    目标需要设置的玩家,默认为自身
    输出接口介绍
    (无名称)输出当前该角色的鼠标指针状态,True表示显示指针,False表示隐藏指针,类型为布尔

    ①参数

    VectorParameter-节点

    该节点的标题可自定义
    在这里插入图片描述
    在这里插入图片描述
    作用:点击该节点可设置相应颜色,通过接口输出相应的颜色。

    ①工具

    ②文本

    格式化文本-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:通过调用参数来创建字符串,类似于编程的printf(“x值:%d ,y值:%d”,x,y),当创建完毕后将会自动添加新的输入接口。

    输入接口介绍
    Format文本的内容

    ②流程控制

    For Loop-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于编程中的for()循环语句,每经过一次循环Index+1

    输入接口介绍
    First Index开始的索引(下标)
    Last Index结束的索引(下标),当Index和Last Index值相同时,将会结束循环
    输出接口介绍
    Loop Body每次循环都会触发执行与其相连的节点
    Index当前循环的索引(下标)
    Completed结束循环时才会触发执行与其相连的节点

    For Loop with Break-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于编程中的for()循环语句加上break语句,每经过一次循环Index+1,

    输入接口介绍
    First Index
    Last Index
    Break当该接口被触发时,将会停止循环执行Completed连接的节点
    输出接口介绍
    Loop Body每次循环都会执行与其连接的节点
    Index当前循环的索引(下标)
    Completed当循环结束时将会执行与其连接的节点

    ③Switch

    Flip Flop-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于死循环,一旦执行了就不会停止。第一次执行A,第二次执行B,第三次执行A…,在两个接口中交替执行

    输出接口介绍
    Is A输出当前执行的是否为A接口,是则输出True,否则输出False

    开启字符串-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于switch()语句,对条件进行判断,适用于有1~n种结果的情况,可以通过添加引脚来添加新的输出接口。

    输入接口介绍
    Selection连接需要进行判断的条件,类型为字符串

    While Loop-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似于编程中的while()语句,当符合条件时将会一直循环

    输入接口介绍
    Condition连接判断条件,当结果为True时将会执行LoopBody连接的节点,否则执行Completed连接的节点
    输出接口介绍
    Loop Body当判断结果为True时,将会执行与其连接的节点
    Completed当判断结果为False时,将会执行与其连接的节点

    序列-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:按从上到下的顺序执行多个输出接口,输出接口全部执行完毕后将会停止。

    输出接口介绍
    添加引脚添加新的需要执行的接口

    ②数组

    For Each Loop-节点

    在这里插入图片描述
    在这里插入图片描述

    作用:对数组中的元素进行处理,按索引(下标)进行取用

    输入接口介绍
    Array连接需要处理的数组
    输出接口介绍
    Loop Body每次循环将会执行与其连接的节点
    Array Element当前取出的元素值
    Array Index当前取出的元素值相应的索引(下标)
    Completed当循环结束时将会执行与其连接的节点,即遍历数组结束就会执行

    For Each Loop with Break-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:类似编程for()语句中带有break语句,循环可中断,对数组元素进行操作。

    输入接口介绍
    Exec触发该节点的接口
    Array接入需要操作的数组
    Break当这个接口触发时,将会让循环停止并从Completed执行
    输出接口介绍
    Loop Body每一次循环都会执行与其连接的节点
    Array Element输出相应数组元素值
    Array Index输出相应数组元素值的索引(下标)
    Completed当循环结束时将会执行与其连接的节点

    Get(复制)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:复制出数组的某个元素,不会对原数组造成影响。

    Get(引用)-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:取出数组的某个元素,该元素值变更后数组相应元素的值也会变更。

    创建数组-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:创建一个临时的数组

    输出接口介绍
    Array输出一个数组
    添加引脚添加新的数组索引(下标)

    ①评级

    Play Sound at Location-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:在某个世界轴某个位置播放音乐资源。

    输入接口介绍(默认使用前两个接口)
    Sound播放的音乐资源
    Location播放器的坐标,可与GetActorLocation节点相连来获取物体的坐标
    Rotation播放器的旋转
    Volume Multiplier音量大小,类型为浮点型
    Pitch Multiplier音高,类型为浮点型
    Start Time音效开始时间(例:如果音乐总共3秒且该选项为2时,只播放从2-3秒间的音乐内容*)
    Attenuation Settings衰减设置包
    Concurrency Settings并发性设置包
    Owning Actor参与者对象

    ①添加事件

    ②AI

    事件Receive Tick AI-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:当AI行为树中调用该Task任务蓝图时,事件将会被触发

    输出接口介绍
    Owner Controller输出其控制器AIcontroller
    Controlled Pawn输出控制的AI类

    ②User Interface

    事件Construct-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:当控件被调用时执行

    事件BeginPlay-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:当游戏开始时将会触发该节点,仅触发一次

    事件Init-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:

    事件On Possess-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:使用了控制器蓝图后,该节点将会触发

    输入接口介绍
    Possessed Pawn输出自身的对象

    事件Receive Draw HUD-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:用于绘制画布,显示到玩家界面中。经过一帧触发一次,类似于死循环。

    输出接口介绍
    Size X输出游戏界面的X轴长度,类型为整型
    Size Y输出游戏界面的Y轴长度,类型为整型

    事件Tcik-节点

    在这里插入图片描述
    在这里插入图片描述
    作用:每经过一个帧就执行一次

    输出接口介绍
    Delta Seconds输出每两次执行的时间间隔

    ①用户界面

    创建控件-节点

    默认生成时为NONE
    在这里插入图片描述
    当选择了控件之后
    在这里插入图片描述

    作用:创建一个控件

    输入接口介绍
    Class连接需要创建的控件
    Owning Payer拥有该新控件的玩家,默认玩家0(即自身)
    输出接口介绍
    Return Value输出一个控件对象

    ①游戏

    (在官方API文档中类型为Game)

    从类生成Actor-节点

    刚生成的节点是NONE类型,当选择了一个类之后将会自动添加新的接口,而且标题名称也会变更

    在这里插入图片描述
    在这里插入图片描述
    添加了一个蓝图类FirstPersonProjectile之后:
    在这里插入图片描述
    在这里插入图片描述

    作用:生成一个指定的物体

    输入接口介绍
    Class连接蓝图类,可生成相应的物体
    Spawn Transform生成物体的转换,转换由坐标、旋转、缩放组成。可与Make Transform节点相连获取物体的转换。
    Collision Handing Override在这里插入图片描述
    Owner对象Actor的引用,可不填,用于复制或可视性
    Instigator对象Pawn的引用,负责处理物体产生的伤害和其他事件的Pawn
    输出接口介绍
    Return Value输出创建的蓝图类名称
    Collision Handing Override介绍
    Default默认生成
    Always Spawn,Ignore Collisions无视碰撞在所需位置生成
    Try To Adjust Location,But Always Spawn寻找附近的非碰撞位置生成,若未找到时将在所需位置生成
    Try To Adjust Location,Don’t Spawn If Still Colliding寻找附近非碰撞位置生成,找不到将不会生成
    Do Not Spawn不生成

    ①添加数学表达式-节点

    未添加表达式时
    在这里插入图片描述
    选中该节点,清除其Expression中的表达式,并创建所需要的表达式。
    此处使用了a+b的表达式,你可以通过使用字母和运算符来构造表达式。
    在这里插入图片描述
    变更了表达式之后,蓝图中的数学表达式节点也会变化,变化是根据表达式来的。

    在这里插入图片描述
    细节面板中的输入端会进行变更,Expression可能有稍微的变化。
    在这里插入图片描述
    注:如果你有变量的名称与表达式中的字母相同时,输入端将不会出现有该字母的接口,而是直接使用变量值。
    在这里插入图片描述

    展开全文
  • PQ节点-PV节点-平衡节点

    千次阅读 2020-12-22 19:25:31
    PQ节点-PV节点-平衡节点 #PQ节点 节点的有功功率P和无功功率Q是给定的,节点电压和相位(V,δ)是待求量。通常变电所都是这一类型的节点。由于没有发电设备,故其发电功率为零。在一些情况下,系统中某些发电厂送出...

    PQ节点-PV节点-平衡节点
    #PQ节点

    节点的有功功率P和无功功率Q是给定的,节点电压和相位(V,δ)是待求量。通常变电所都是这一类型的节点。由于没有发电设备,故其发电功率为零。在一些情况下,系统中某些发电厂送出的功率在一定时间内为固定时,该发电厂也作为PQ节点,因此,电力系统中绝大多数节点属于这一类型。
    #PV节点
    节点的有功功率P和电压幅值V是给定的,节点的无功功率Q和电压相位δ是待求量,这类节点必须有足够的可调无功容量,用以维持给定的电压幅值,因而又称之为“电压控制节点”,一般是选择有一定无功储备的发电厂和安装有可调无功电源设备的变电所作为PV节点。在电力系统中,这一类节点的数目很少。
    #平衡节点
    平衡节点的电压幅值和相位是给定的,而其注入有功功率和无功功率是待求量。平衡节点的A相电压相位是系统的相位基准,最后计算结果中的所有相位值都是以平衡节点的A相电压相位作为参考的,所以平衡节点在系统中只能有一个,且必须有一个,它对系统起到功率平衡的作用,可以向系统提供缺损的功率,也可以吸收系统中多余的功率。从理论上讲,平衡节点代表与系统相连的无穷大系统,实际应用中,一般选取系统中的主调频发电厂为平衡节点比较合理,最后计算结果中的平衡节点功率就是此发电厂必须向系统提供的功率。如果系统是与另一更大的电力系统S相连,则也可以选取这个连接点作为平衡节点,最后计算结果中的平衡节点功率就是系统S通过平衡节点向系统提供的功率。另外如果系统是一独立系统且只有一个电源点,则必须选此电源点为平衡节点。

    展开全文
  • 二叉查找树 - 删除节点 详解(Java实现)

    万次阅读 多人点赞 2018-05-17 12:18:31
    当某个节点存在右节点时,后继结点就是右节点中的最小值,由于左侧节点总比右侧节点和父节点小,所以 后继 节点一定没有左节点。从这一个特点就能看出来,后继结点有可能存在右节点,也有可能没有任何节点。后继结点...

    在浏览 二叉查找树(三)之 Java的实现 时,发现所有操作都很容易理解,只有删除看的很糊涂。原文作者在方法上也没有任何注释,因此理解起来很不容易。因此本文是在这篇的基础上,对删除操作进行详细的讲解,所以如果你对二叉查找树还不了解,先看前面这篇博客,如果你能直接看懂那篇博客中的删除方法,也不必再看本文。

    虽然我自己也完全从头实现了一遍二叉查找树,但是为了和前面这篇博客衔接的更好,这里就直接拿这篇博客的代码来说明,并且会对删除操作进行简单的调整。

    完整的代码在本文最后,在测试类中还提供了一个简单的输出树结构的工具类。

    删除节点

    删除节点存在 3 种情况,几乎所有类似博客都提到了这点。这 3 种情况分别如下:

    1. 没有左右子节点,可以直接删除
    2. 存在左节点或者右节点,删除后需要对子节点移动
    3. 同时存在左右子节点,不能简单的删除,但是可以通过和后继节点交换后转换为前两种情况

    实际上在 3 种情况中,还有一个特例就是删除根节点,后续代码会有处理。

    下面,我们使用图详细来说说怎么删除。

    初始状态如下图所示,我们可以按照 50, 30, 80, 20, 35, 34, 32, 40, 70, 75, 100 的顺序插入到树中,就会产生下图所示的树。
    这里写图片描述

    下面按照这 3 种情况分别来讲。

    1. 没有左右子节点时

    在我们图中,符合这个条件的有 20,32,40,75,100,随便找个 20 来演示删除该节点:
    这里写图片描述
    这种情况是最简单的,我们只需要删除该节点和父节点的关系即可。删除的时候需要先判断自己和父节点的关系是左侧还是右侧,判断方式很简单,如下:

    //这里忽略了父节点不存在的情况,最后会巧妙的处理这种情况
    if(node.parent.left == node){
        node.parent.left = null;
    } else {
        node.parent.right = null;
    }   

    如果父节点的左节点是自己,就清左侧,否则就是右侧。删除后如下图所示:

    这里写图片描述

    2. 存在左节点或者右节点时

    满足这个情况的节点有 34, 70 两个节点,这里以 70 为例,如下图所示:
    这里写图片描述
    删除 70 的时候,需要断两个关系,然后建立父节点和子节点的关系,代码如下:

    //先找到子节点,不需要管他是左是右
    BSTNode<T> child = null;
    if(node.left != null){
        child = node.left;
    } else {
        child = node.right;
    }
    //这里忽略了父节点不存在的情况,最后会巧妙的处理这种情况
    //将父节点和子节点建立关系
    if(node.parent.left == node){
        node.parent.left = child;
    } else {
        node.parent.right = child;
    }
    child.parent = node.parent;

    经过上述操作后,节点状态如下图所示:
    这里写图片描述

    3. 同时存在左右子节点

    满足同时存在左右节点的节点有 50,30,80,35 这 4 个节点,30 看起来更复杂,我们以 30 为例。

    当二叉查找树以中序遍历时,遍历的结果是一个从小到大排列的顺序,如下图所示:
    这里写图片描述
    当我们删除 30 节点的时候,整个中序遍历的结果中,从 32 开始都往前移动了一位。32 是 30 的后继节点,就是比 30 大的节点中最小的节点。当某个节点存在右节点时,后继结点就是右节点中的最小值,由于左侧节点总比右侧节点和父节点小,所以后继节点一定没有左节点。从这一个特点就能看出来,后继结点有可能存在右节点,也有可能没有任何节点。后继结点还有一个特点,就是他比 30 的左节点大,比 30 所有的右节点都小,因此删除 30 的时候,可以直接将后继结点 32 的值(key)转移到 30 节点上,然后删除后继结点 32。由于后继结点最多只有一个子节点,因此删除后继节点时,就变成了 3 种情况中的前两种。图示如下:
    这里写图片描述
    转移节点值的代码很容易:

    //获取当前节点的后继结点
    Node<T> successor = successor(node);
    //转移值
    node.key = successor.key;
    //后续变成删除 successor,就变成了前两种情况
    //在图示例子中,就是第一种没有子节点的情况
    node = successor;

    看到这里应该都不难,没什么问题,接下来开始将 3 种情况合并到一起处理,先按照本文的逻辑来写。

    整合 3 种情况的删除

    代码如下,详细说明看注释

    private BSTNode<T> delete(BSTNode<T> node) {
        //第 3 种情况,如果同时存在左右子节点
        if (node.left != null && node.right != null){
            //获取后继结点
            BSTNode<T> successor = successor(node);
            //转移后继结点值到当前节点
            node.key = successor.key;
            //把要删除的当前节点设置为后继结点
            node = successor;
        }
        //经过前一步处理,下面只有前两种情况,只能是一个节点或者没有节点
        //不管是否有子节点,都获取子节点
        BSTNode<T> child;
        if (node.left != null)
            child = node.left;
        else
            child = node.right;
        //如果 child != null,就说明是有一个节点的情况    
        if (child != null)
            //将子节点和父节点关联上
            child.parent = node.parent;
        //如果当前节点没有父节点(后继情况到这儿时一定有父节点)
        //说明要删除的就是根节点
        if (node.parent == null)
            //根节点设置为子节点
            //按照前面逻辑,根只有一个或者没有节点,所以直接赋值 child 即可
            mRoot = child;
        else if (node == node.parent.left)//存在父节点,并且当前节点是左节点时
            //将父节点的左节点设置为 child
            node.parent.left = child;
        else//右节点时
            //将父节点的右节点设置为 child
            node.parent.right = child;
        //返回被删除的节点
        return node;
    }
    //删除指定的值
    public void delete(T key) {
        //获取要删除的节点
        BSTNode<T> node = search(mRoot, key);
        //如果存在就删除
        if (node != null)
           delete(node);
    }

    在上面这段代码中,和原文相比不一样,这里对后继结点的处理更好理解。

    通过前面的铺垫和这里的代码注释,删除这个操作应该能真正领会了,下面针对 二叉查找树(三)之 Java的实现 中的删除,增加注释,代码如下:

    /*
     * 删除结点(z),并返回被删除的结点
     *
     * 参数说明:
     *     bst 二叉树
     *     z 删除的结点
     */
    private BSTNode<T> remove(BSTree<T> bst, BSTNode<T> z) {
        //这里没起个好名字,让人看着默默奇妙,实际上 x 就是子节点 child
        BSTNode<T> x=null;
        //这里的 y 节点就是要删除的节点 delete
        BSTNode<T> y=null;
        //这个写法理解比较绕,不如反转后容易理解
        //只有一个节点或者没有节点时
        if ((z.left == null) || (z.right == null) )
            //z 就是要删除的节点
            y = z;
        else
            //当有两个子节点时,删除后继结点
            y = successor(z);
        //获取子节点,不管是左是右
        if (y.left != null)
            x = y.left;
        else
            x = y.right;
        //如果存在子节点,就关联被删节点的父节点
        if (x != null)
            x.parent = y.parent;
        //如果父节点是空,说明要删的是根节点
        if (y.parent == null)
            //设置根为 child(此时根只有一个或没有节点)
            bst.mRoot = x;
        else if (y == y.parent.left)//要删的是左节点
            y.parent.left = x;//左节点关联子节点
        else//要删的是右节点
            y.parent.right = x;//右节点关联子节点
        //如果要删的节点和一开始传入的不一样,就是后继的情况
        if (y != z)
            z.key = y.key;//后继的值传给本来要删除的节点
        //返回被删除的节点
        return y;
    }
    
    /*
     * 删除结点(z),并返回被删除的结点
     *
     * 参数说明:
     *     tree 二叉树的根结点
     *     z 删除的结点
     */
    public void remove(T key) {
        BSTNode<T> z, node;
    
        if ((z = search(mRoot, key)) != null)
            if ( (node = remove(this, z)) != null)
                node = null;
    }

    理解前面代码后,再看上面这段代码也不难理解。所有代码中都没有处理 node 节点的上下级关系,因为通过其他节点已经无法引用到该 node 节点了,所以 node 能被 GC 正常回收。

    完整代码

    下面包含了完整的二叉查找树代码,90% 来自于前面的那篇博客,增加了删除节点注释和上面增加的 delete 方法,后面还有一个测试和输出树节点的代码,最后有测试输出的结果。

    树代码

    /**
     * Java 语言: 二叉查找树
     *
     * @author skywang
     * @date 2013/11/07
     */
    
    public class BSTree<T extends Comparable<T>> {
    
        BSTNode<T> mRoot;    // 根结点
    
        public class BSTNode<T extends Comparable<T>> {
            T key;                // 关键字(键值)
            BSTNode<T> left;    // 左孩子
            BSTNode<T> right;    // 右孩子
            BSTNode<T> parent;    // 父结点
    
            public BSTNode(T key, BSTNode<T> parent, BSTNode<T> left, BSTNode<T> right) {
                this.key = key;
                this.parent = parent;
                this.left = left;
                this.right = right;
            }
    
            public T getKey() {
                return key;
            }
    
            public String toString() {
                return "key:"+key;
            }
        }
    
        public BSTree() {
            mRoot=null;
        }
    
        /*
         * 前序遍历"二叉树"
         */
        private void preOrder(BSTNode<T> tree) {
            if(tree != null) {
                System.out.print(tree.key+" ");
                preOrder(tree.left);
                preOrder(tree.right);
            }
        }
    
        public void preOrder() {
            preOrder(mRoot);
        }
    
        /*
         * 中序遍历"二叉树"
         */
        private void inOrder(BSTNode<T> tree) {
            if(tree != null) {
                inOrder(tree.left);
                System.out.print(tree.key+" ");
                inOrder(tree.right);
            }
        }
    
        public void inOrder() {
            inOrder(mRoot);
        }
    
    
        /*
         * 后序遍历"二叉树"
         */
        private void postOrder(BSTNode<T> tree) {
            if(tree != null)
            {
                postOrder(tree.left);
                postOrder(tree.right);
                System.out.print(tree.key+" ");
            }
        }
    
        public void postOrder() {
            postOrder(mRoot);
        }
    
    
        /*
         * (递归实现)查找"二叉树x"中键值为key的节点
         */
        private BSTNode<T> search(BSTNode<T> x, T key) {
            if (x==null)
                return x;
    
            int cmp = key.compareTo(x.key);
            if (cmp < 0)
                return search(x.left, key);
            else if (cmp > 0)
                return search(x.right, key);
            else
                return x;
        }
    
        public BSTNode<T> search(T key) {
            return search(mRoot, key);
        }
    
        /*
         * (非递归实现)查找"二叉树x"中键值为key的节点
         */
        private BSTNode<T> iterativeSearch(BSTNode<T> x, T key) {
            while (x!=null) {
                int cmp = key.compareTo(x.key);
    
                if (cmp < 0)
                    x = x.left;
                else if (cmp > 0)
                    x = x.right;
                else
                    return x;
            }
    
            return x;
        }
    
        public BSTNode<T> iterativeSearch(T key) {
            return iterativeSearch(mRoot, key);
        }
    
        /*
         * 查找最小结点:返回tree为根结点的二叉树的最小结点。
         */
        private BSTNode<T> minimum(BSTNode<T> tree) {
            if (tree == null)
                return null;
    
            while(tree.left != null)
                tree = tree.left;
            return tree;
        }
    
        public T minimum() {
            BSTNode<T> p = minimum(mRoot);
            if (p != null)
                return p.key;
    
            return null;
        }
    
        /*
         * 查找最大结点:返回tree为根结点的二叉树的最大结点。
         */
        private BSTNode<T> maximum(BSTNode<T> tree) {
            if (tree == null)
                return null;
    
            while(tree.right != null)
                tree = tree.right;
            return tree;
        }
    
        public T maximum() {
            BSTNode<T> p = maximum(mRoot);
            if (p != null)
                return p.key;
    
            return null;
        }
    
        /*
         * 找结点(x)的后继结点。即,查找"二叉树中数据值大于该结点"的"最小结点"。
         */
        public BSTNode<T> successor(BSTNode<T> x) {
            // 如果x存在右孩子,则"x的后继结点"为 "以其右孩子为根的子树的最小结点"。
            if (x.right != null)
                return minimum(x.right);
    
            // 如果x没有右孩子。则x有以下两种可能:
            // (01) x是"一个左孩子",则"x的后继结点"为 "它的父结点"。
            // (02) x是"一个右孩子",则查找"x的最低的父结点,并且该父结点要具有左孩子",找到的这个"最低的父结点"就是"x的后继结点"。
            BSTNode<T> y = x.parent;
            while ((y!=null) && (x==y.right)) {
                x = y;
                y = y.parent;
            }
    
            return y;
        }
    
        /*
         * 找结点(x)的前驱结点。即,查找"二叉树中数据值小于该结点"的"最大结点"。
         */
        public BSTNode<T> predecessor(BSTNode<T> x) {
            // 如果x存在左孩子,则"x的前驱结点"为 "以其左孩子为根的子树的最大结点"。
            if (x.left != null)
                return maximum(x.left);
    
            // 如果x没有左孩子。则x有以下两种可能:
            // (01) x是"一个右孩子",则"x的前驱结点"为 "它的父结点"。
            // (01) x是"一个左孩子",则查找"x的最低的父结点,并且该父结点要具有右孩子",找到的这个"最低的父结点"就是"x的前驱结点"。
            BSTNode<T> y = x.parent;
            while ((y!=null) && (x==y.left)) {
                x = y;
                y = y.parent;
            }
    
            return y;
        }
    
        /*
         * 将结点插入到二叉树中
         *
         * 参数说明:
         *     tree 二叉树的
         *     z 插入的结点
         */
        private void insert(BSTree<T> bst, BSTNode<T> z) {
            int cmp;
            BSTNode<T> y = null;
            BSTNode<T> x = bst.mRoot;
    
            // 查找z的插入位置
            while (x != null) {
                y = x;
                cmp = z.key.compareTo(x.key);
                if (cmp < 0)
                    x = x.left;
                else
                    x = x.right;
            }
    
            z.parent = y;
            if (y==null)
                bst.mRoot = z;
            else {
                cmp = z.key.compareTo(y.key);
                if (cmp < 0)
                    y.left = z;
                else
                    y.right = z;
            }
        }
    
        /*
         * 新建结点(key),并将其插入到二叉树中
         *
         * 参数说明:
         *     tree 二叉树的根结点
         *     key 插入结点的键值
         */
        public void insert(T key) {
            BSTNode<T> z=new BSTNode<T>(key,null,null,null);
    
            // 如果新建结点失败,则返回。
            if (z != null)
                insert(this, z);
        }
    
        private BSTNode<T> delete(BSTNode<T> node) {
            //第 3 种情况,如果同时存在左右子节点
            if (node.left != null && node.right != null){
                //获取后继结点
                BSTNode<T> successor = successor(node);
                //转移后继结点值到当前节点
                node.key = successor.key;
                //把要删除的当前节点设置为后继结点
                node = successor;
            }
            //经过前一步处理,下面只有前两种情况,只能是一个节点或者没有节点
            //不管是否有子节点,都获取子节点
            BSTNode<T> child;
            if (node.left != null)
                child = node.left;
            else
                child = node.right;
            //如果 child != null,就说明是有一个节点的情况
            if (child != null)
                //将子节点和父节点关联上
                child.parent = node.parent;
            //如果当前节点没有父节点(后继情况到这儿时一定有父节点)
            //说明要删除的就是根节点
            if (node.parent == null)
                //根节点设置为子节点
                //按照前面逻辑,根只有一个或者没有节点,所以直接赋值 child 即可
                mRoot = child;
            else if (node == node.parent.left)//存在父节点,并且当前节点是左节点时
                //将父节点的左节点设置为 child
                node.parent.left = child;
            else//右节点时
                //将父节点的右节点设置为 child
                node.parent.right = child;
            //返回被删除的节点
            return node;
        }
        //删除指定的值
        public void delete(T key) {
            //获取要删除的节点
            BSTNode<T> node = search(mRoot, key);
            //如果存在就删除
            if (node != null)
                delete(node);
        }
    
        /*
         * 删除结点(z),并返回被删除的结点
         *
         * 参数说明:
         *     bst 二叉树
         *     z 删除的结点
         */
        private BSTNode<T> remove(BSTree<T> bst, BSTNode<T> z) {
            //这里没起个好名字,让人看着默默奇妙,实际上 x 就是子节点 child
            BSTNode<T> x=null;
            //这里的 y 节点就是要删除的节点 delete
            BSTNode<T> y=null;
            //这个写法理解比较绕,不如反转后容易理解
            //只有一个节点或者没有节点时
            if ((z.left == null) || (z.right == null) )
                //z 就是要删除的节点
                y = z;
            else
                //当有两个子节点时,删除后继结点
                y = successor(z);
            //获取子节点,不管是左是右
            if (y.left != null)
                x = y.left;
            else
                x = y.right;
            //如果存在子节点,就关联被删节点的父节点
            if (x != null)
                x.parent = y.parent;
            //如果父节点是空,说明要删的是根节点
            if (y.parent == null)
                //设置根为 child(此时根只有一个或没有节点)
                bst.mRoot = x;
            else if (y == y.parent.left)//要删的是左节点
                y.parent.left = x;//左节点关联子节点
            else//要删的是右节点
                y.parent.right = x;//右节点关联子节点
            //如果要删的节点和一开始传入的不一样,就是后继的情况
            if (y != z)
                z.key = y.key;//后继的值传给本来要删除的节点
            //返回被删除的节点
            return y;
        }
    
        /*
         * 删除结点(z),并返回被删除的结点
         *
         * 参数说明:
         *     tree 二叉树的根结点
         *     z 删除的结点
         */
        public void remove(T key) {
            BSTNode<T> z, node;
    
            if ((z = search(mRoot, key)) != null)
                if ( (node = remove(this, z)) != null)
                    node = null;
        }
    
        /*
         * 销毁二叉树
         */
        private void destroy(BSTNode<T> tree) {
            if (tree==null)
                return ;
    
            if (tree.left != null)
                destroy(tree.left);
            if (tree.right != null)
                destroy(tree.right);
    
            tree=null;
        }
    
        public void clear() {
            destroy(mRoot);
            mRoot = null;
        }
    
        /*
         * 打印"二叉查找树"
         *
         * key        -- 节点的键值
         * direction  --  0,表示该节点是根节点;
         *               -1,表示该节点是它的父结点的左孩子;
         *                1,表示该节点是它的父结点的右孩子。
         */
        private void print(BSTNode<T> tree, T key, int direction) {
    
            if(tree != null) {
    
                if(direction==0)    // tree是根节点
                    System.out.printf("%2d is root\n", tree.key);
                else                // tree是分支节点
                    System.out.printf("%2d is %2d's %6s child\n", tree.key, key, direction==1?"right" : "left");
    
                print(tree.left, tree.key, -1);
                print(tree.right,tree.key,  1);
            }
        }
    
        public void print() {
            if (mRoot != null)
                print(mRoot, mRoot.key, 0);
        }
    }

    测试代码

    public class BSTreeTest {
    
        public static BSTree<Integer> newTree() {
            int[] array = new int[]{50, 30, 80, 20, 35, 34, 32, 40, 70, 75, 100};
            BSTree<Integer> tree = new BSTree<>();
            for (int i = 0; i < array.length; i++) {
                tree.insert(array[i]);
            }
            return tree;
        }
    
        public static void main(String[] args) {
            BSTree<Integer> tree = newTree();
            System.out.println("----------初始--------");
            print(tree);
            tree.delete(20);
            System.out.println("----------删除 20--------");
            print(tree);
            tree = newTree();
            tree.delete(70);
            System.out.println("----------删除 70--------");
            print(tree);
            tree = newTree();
            tree.delete(30);
            System.out.println("----------删除 30--------");
            print(tree);
        }
    
    
        //------------下面代码是用于输出树的工具代码------------------------
    
        public static final String  PREFIX_BRANCH = "├";//树枝
        public static final String  PREFIX_TRUNK  = "│ ";//树干
        public static final String  PREFIX_LEAF   = "└";//叶子
        public static final String  PREFIX_EMP    = "  ";//空
        public static final String  PREFIX_LEFT   = "─L─";//左
        public static final String  PREFIX_RIGTH  = "─R─";//右
    
        private static boolean hasChild(BSTree.BSTNode node){
            return node.left != null || node.right != null;
        }
    
        public static void print(BSTree tree){
            if(tree != null && tree.mRoot != null){
                System.out.println(tree.mRoot.key);
                print(tree.mRoot, "");
            }
        }
    
        public static void print(BSTree.BSTNode node, String prefix){
            if(prefix == null){
                prefix = "";
            } else {
                prefix = prefix.replace(PREFIX_BRANCH, PREFIX_TRUNK);
                prefix = prefix.replace(PREFIX_LEAF, PREFIX_EMP);
            }
            if(hasChild(node)){
                if(node.right != null){
                    System.out.println(prefix + PREFIX_BRANCH + PREFIX_RIGTH + node.right.key);
                    if(hasChild(node.right)){
                        print(node.right, prefix + PREFIX_BRANCH);
                    }
                } else {
                    System.out.println(prefix + PREFIX_BRANCH + PREFIX_RIGTH);
                }
    
                if(node.left != null){
                    System.out.println(prefix + PREFIX_LEAF + PREFIX_LEFT + node.left.key);
                    if(hasChild(node.left)){
                        print(node.left, prefix + PREFIX_LEAF);
                    }
                } else {
                    System.out.println(prefix + PREFIX_LEAF + PREFIX_LEFT);
                }
            }
        }
    }

    测试结果

    注意:每次删除都在在初始树的状态下删除的,不是在同一个树连续执行的。

    ----------初始--------
    50
    ├─R─80
     ├─R─100
     └─L─70
       ├─R─75
       └─L─
    └─L─30
      ├─R─35
       ├─R─40
       └─L─34
         ├─R─
         └─L─32
      └─L─20
    ----------删除 20--------
    50
    ├─R─80
     ├─R─100
     └─L─70
       ├─R─75
       └─L─
    └─L─30
      ├─R─35
       ├─R─40
       └─L─34
         ├─R─
         └─L─32
      └─L─
    ----------删除 70--------
    50
    ├─R─80
     ├─R─100
     └─L─75
    └─L─30
      ├─R─35
       ├─R─40
       └─L─34
         ├─R─
         └─L─32
      └─L─20
    ----------删除 30--------
    50
    ├─R─80
     ├─R─100
     └─L─70
       ├─R─75
       └─L─
    └─L─32
      ├─R─35
       ├─R─40
       └─L─34
      └─L─20

    推荐阅读

    后来在看 AVL 树的时候,发现了两个特别好的网站,一个全图方式讲解,很容易理解。还有一个是动态可视化在线操作,可以方便的看到算法执行的过程,在此留个记录:

    展开全文
  • 今天在做一个项目拿兄弟节点的事,刚开始拿不到,后来网上查了一下,于是 便找到方法了,下面把我的问题写出来,话不多说直接上问题, 遇到的问题是我要通过点击删除按钮删除这一行数据,后端给的接口要传的参数...

    今天在做一个项目拿兄弟节点的事,刚开始拿不到,后来网上查了一下,于是 便找到方法了,下面把我的问题写出来,话不多说直接上问题,

    在这里插入图片描述
    遇到的问题是我要通过点击删除按钮删除这一行数据,后端给的接口要传的参数就是设备编号(imei),重点是这个列表本身也是动态的数据,用框架渲染出来的,然后就想到了用dom节点来删除,还算比较简单, 我要获取的就是imei,然后通过ajxa调用接口删除,完美实现,下面是源码:

    <script type="text/javascript">
    	$(function(){
    
    
    function deleteUL(obj){
        // obj.parentNode.parentNode.remove();
    var $imei= $(obj.parentNode.parentNode.children[1]).text() 
    //console.log( $(obj.parentNode.parentNode.children[1]).text() )//这里获取到的就是该行的imei了
    
     $.ajax({
                        url:"**********",
                        type:"post",
                        async:true,
                        //cache:true,
                        data:{
                            //id:menuId
                            "DeviceIMEI" : $imei
                        },
                        success:function(data){
    	                    //console.log(data)
    	                    //console.log($imei)
                           window.location.reload(true);      重新加载
                        }
    }
    		
    var deleteBtns = document.getElementsByClassName('deleteBtn');
    for(var i=0; i<deleteBtns.length; i++){
            //console.log(22);
            deleteBtns[i].onclick = function(){
               // console.log(this);
                deleteUL(this);
            };
        }
    })
      </script>
     
    

    下面就来总结一下关于获取节点的详情:
    一、js获取子节点的方式
    1.通过获取dom方式直接获取子节点
    其中test的父标签id的值,div为标签的名字。getElementsByTagName是一个方法。返回的是一个数组。在访问的时候要按数组的形式访问。

    var a = document.getElementById("test").getElementsByTagName("div");
    

    2.通过childNodes获取子节点
    使用childNodes获取子节点的时候,childNodes返回的是子节点的集合,是一个数组的格式。他会把换行和空格也当成是节点信息。

    var b =document.getElementById("test").childNodes;
    

    为了不显示不必须的换行的空格,我们如果要使用childNodes就必须进行必要的过滤。通过正则表达式式取掉不必要的信息。下面是过滤掉

    //去掉换行的空格
    for(var i=0; i<b.length;i++){
        if(b[i].nodeName == "#text" && !/\s/.test(b.nodeValue)){
            document.getElementById("test").removeChild(b[i]);
        }
    }
    //打印测试
    for(var i=0;i<b.length;i++){
        console.log(i+"---------")
        console.log(b[i]);
    }
    //补充 document.getElementById("test").childElementCount;  可以直接获取长度 同length
    

    4.通过children来获取子节点
    利用children来获取子元素是最方便的,他也会返回出一个数组。对其获取子元素的访问只需按数组的访问形式即可。

    var getFirstChild = document.getElementById("test").children[0];
    

    5.获取第一个子节点
    firstChild来获取第一个子元素,但是在有些情况下我们打印的时候会显示undefined,这是什么情况呢??其实firstChild和childNodes是一样的,在浏览器解析的时候会把他当换行和空格一起解析,其实你获取的是第一个子节点,只是这个子节点是一个换行或者是一个空格而已。那么不要忘记和childNodes一样处理呀。

    var getFirstChild = document.getElementById("test").firstChild;
    

    6.firstElementChild获取第一个子节点
    使用firstElementChild来获取第一个子元素的时候,这就没有firstChild的那种情况了。会获取到父元素第一个子元素的节点 这样就能直接显示出来文本信息了。他并不会匹配换行和空格信息。

    var getFirstChild = document.getElementById("test").firstElementChild;
    

    7.获取最后一个子节点
    lastChild获取最后一个子节点的方式其实和firstChild是类似的。同样的lastElementChild和firstElementChild也是一样的。不再赘余。

     var getLastChildA = document.getElementById("test").lastChild;
     var getLastChildB = document.getElementById("test").lastElementChild;
    

    二、js获取父节点的方式
    1.parentNode获取父节点
    获取的是当前元素的直接父元素。parentNode是w3c的标准。

    var p  = document.getElementById("test").parentNode;
    

    2.parentElement获取父节点
    parentElement和parentNode一样,只是parentElement是ie的标准。

    var p1 = document.getElementById("test").parentElement;
    

    3.offsetParent获取所有父节点
    一看offset我们就知道是偏移量 其实这个是于位置有关的上下级 ,直接能够获取到所有父亲节点, 这个对应的值是body下的所有节点信息。

    var p2 = document.getElementById("test").offsetParent;
    

    三、js获取兄弟节点的方式
    1.通过获取父亲节点再获取子节点来获取兄弟节点

    var brother1 = document.getElementById("test").parentNode.children[1];
    

    2.获取上一个兄弟节点
    在获取前一个兄弟节点的时候可以使用previousSibling和previousElementSibling。他们的区别是previousSibling会匹配字符,包括换行和空格,而不是节点。previousElementSibling则直接匹配节点。

    var brother2 = document.getElementById("test").previousElementSibling;
    var brother3 = document.getElementById("test").previousSibling;
    

    3.获取下一个兄弟节点
    同previousSibling和previousElementSibling,nextSibling和nextElementSibling也是类似的。

    var brother4 = document.getElementById("test").nextElementSibling;
    var brother5 = document.getElementById("test").nextSibling;
    
    展开全文
  • 1.什么是隐藏节点和暴露节点问题 (1)隐藏节点(隐终端) 隐藏终端是指在接收接点的覆盖范围内而在发送节点的覆盖范围外的节点。隐藏终端由于听不到发送节点的发送而可能向相同的接收节点发送分组,导致分组在...
  • 树的节点、度数、高度、深度、遍历

    万次阅读 多人点赞 2019-09-27 21:35:34
    1.节点的度与树的度 节点的度:结点拥有的子树数目称为结点的度,叶子结点 就是度为0的结点 树的度:树内各结点的度的最大值 分支节点:度不为0的节点 -------------------------------------------------- ...
  • 节点、子节点、叶子节点是什么?

    万次阅读 多人点赞 2020-11-25 00:12:09
    下面给个例子图解释(根节点、子节点、叶子节点)。 上图数字 1、3、7是叶子节点;(因为他们下面没有分叉出子节点,所以称为:叶子节点)【度为0】 数字2、8是子节点; (除了根节点、叶子节点之外的,都称为:...
  • Elasticsearch节点类型

    千次阅读 2019-06-17 20:54:52
    Elasticsearch2.x节点类型 节点类型 中文名称 配置 作用 备注 master节点节点 node.master=truenode.data=false
  • <span @click="getClickInfo(event)"> </span> getClickInfo: function (e) { let clickDom = e.currentTarget; // currentTarget 获取绑定点击事件的节点 ...
  • 1.节点关系图 假设html代码如实例中,那么各个元素节点的关系如下: d1 d2 d3 的parentNode是parentDiv parentDiv的firstNode是 d1 parentDiv的lastNode是d3 d2的previousSibling是d1 d2的nextSibling是d3 parentDiv...
  • Qt之QTreeWidget添加节点获取节点

    千次阅读 2020-02-29 20:35:29
    Qt之QTreeWidget添加节点获取节点概述:代码示例:.h.cpp效果图:over:文末一句话: 概述: QTreeWidget 类根据预设的模型提供树形显示控件。 QTreeWidget 使用类似于 QListWidget 类的方式提供一种典型的基于 item...
  • DOM树节点解析

    千次阅读 2017-06-16 21:50:59
    目录(?)[+] ...DOM是解析XML文件的官方标准,它与平台和语言无关。DOM解析将整个XML文件载入并组装成一棵DOM节点树,然后通过...由于DOM解析中把所有节点都载入到内存中,因而它比较耗资源,而且它需要把整棵节点
  • 1、实战遇到的问题问题描述:如何在一个四个节点的集群中,将主节点中的数据分散到其他节点中去,最后主节点没有数据?问题细节:线上环境有4个节点,单节点为48核的物理机,252G的内存。数据每...
  • MySQL查询某个子节点的顶级节点(根节点)或者所有父节点 假设表t_menu为: id(varchar) parent_id(varchar) name(varchar) 111 null aaa 222 111 bbb 333 222 ccc 查询id为...
  • 图网络算法——信息传递和节点分类 在开始介绍下面的算法问题之前,我们首先从提出一个问题,给定一个某些节点具有分类标签的网络结构,我们应该如何去预测网络中其他节点的标签呢? 这种节点分类的方式称为半监督...
  • Pi Network节点教程

    万次阅读 多人点赞 2021-01-08 00:58:57
    文章目录1、简介2、Pi节点安装2.1、操作系统2.2、路由器设置2.3、Docker安装2.4、Pi Node安装 1、简介     2020年3月31日(太平洋时间)Node软件的测试版上线此,版本号0.015。写下这篇文章时,版本号已更新至...
  • 因为区块链的冗余备份,要求所有节点都需保存全量的数据文件,在这个节点间,假设有用户用自己创建一个区块链节点来进行DApp的开发,可又不想参与共识,那对于这个用户而言,同步大量的数据是非常消耗时间的,而且...
  • ROS总结——ROS节点

    千次阅读 2017-03-07 23:40:20
    理解ROS节点本博客是对http://wiki.ros.org/上ROS教程的学习总结...Nodes:节点,一个节点即为一个可执行文件,它可以通过ROS与其它节点进行通信。 Messages:消息,消息是一种ROS数据类型,用于订阅或发布到一个话题。 T
  • 求二叉树根节点到指定节点的路径

    千次阅读 2020-11-05 17:25:47
    算法 求二叉树根节点到指定节点的路径 @author:Jingdai @date:2020.11.05 题目描述 给你一个棵二叉树,再给你一个指定的节点,求根节点到指定节点的路径。 如图,比如让你求到 4 节点的路径,则应该返回的路径为 ...
  • Zookeeper节点个数设置

    万次阅读 2020-04-15 16:38:45
    zookeeper有个特点就是选举,选举出Leader才能正常使用, 集群中的zookeeper需要超过半数,整个集群对外才可用。 这里所谓的整个集群对外才可用,是指整个集群还能选出一个Leader来, ...3.其他节点可以稍后再...
  • 先介绍一下节点类型都有哪些:一、节点类型节点类型 属性nodeType返回值 元素节点1属性节点2文本节点3注释节点(comment)8document9DocumentFragment11所以一般我们获取节点类型用 nodeType二、遍历节点树这种...
  • 节点类型

    千次阅读 2018-09-27 15:40:17
      前面提到默认情况下节点既可以做候选主节点也可以做数据节点,但是数据节点的负载较重,所以需要考虑将二者分离开,设置专用的数据节点,避免因数据节点负载重导致主节点不响应。 node . master = false ...
  • 区块链节点与主节点分别是什么?

    万次阅读 2018-12-18 11:48:23
    虽然币市低迷,但是区块链技术的发展却并未受到影响,本文将和大家分享一些区块链的基础知识,即节点和主节点分别是什么,我们如何参与及他们在区块链网络中执行的任务是什么?希望帮助大家更好的认识区块链技术。 ...
  • 07. Zookeeper 节点类型 & 节点信息

    千次阅读 2019-08-27 16:22:09
    Zookeeper 节点类型 &amp; 节点信息
  • 浅析~DOM结构中的元素节点、属性节点、文本节点

    万次阅读 多人点赞 2018-08-28 12:10:06
    综上:想要获得属性节点或者文本节点,第一步首先要绑定元素节点,然后再从元素节点向下找其子节点 //其实对于元素节点、属性节点、文本节点的设置操作,完全可以根据jQuery给的DOM操作函数来写,而不必这么麻烦...
  • 例如,每个节点都需要能够与其他节点通信,这使得可能的通信路径数量会按照节点数量的平方增长——所有节点都必须由控制平面管理。 Kubernetes controller manager 中的节点控制器定期遍历集群中的所有节点以运行...
  • 复制集(replica Set)或者副本集是MongoDB的核心高可用特性之一,它基于主节点的oplog日志持续传送到辅助节点,并重放得以实现主从节点一致。再结合心跳机制,当感知到主节点不可访问或宕机的情形下,辅助节点通过...
  • js tree 根据子节点找到所有父节点

    千次阅读 2020-06-20 09:59:53
    function findParentNode(ids){ //ids 是子节点数组 var parentNodes = [];//所有父节点 var forfun = function (id,nodes) { for(var i=0;i<nodes.length;i++){ var currentNode = nodes[i]; if...
  • Echarts实现点击节点显示 隐藏子节点

    千次阅读 2018-11-07 19:33:44
     项目中一个根节点,根节点有七八个子节点,子节点有较多的孙子节点。不美观,因此需要将孙子节点隐藏,当点击子节点时再去显示此子节点对应的孙子节点,再次点击则隐藏孙子节点。 问题解决  Echarts的links的...
  • ztree之获取当前节点的所有子节点

    千次阅读 2019-07-26 19:51:12
    在使用zTree插件实现树形图中,如果需要获取当前点击的父节点的子节点数的需求,可以使用treeNode.children获取子节点数据集合,使用length方法获取集合长度。 将当前节点的treeNode传入即可调用。 在我这有两种方式...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,165,102
精华内容 1,266,040
关键字:

节点