树结构

PMP--二模--解题--161-170 A:邀请团队成员在下一次回顾中分享经验。B:请求发起人增加具有所需经验的团队成员。C:在团队内计划知识共享会议。D:请求发起人为团队提供培训课程。A。 阅读详情

树结构

树(Tree)结构是一种描述非线性层次关系的数据结构,其中重要的是树的概念。树是n个数据结点的集合,在该集合中包含一个根结点,根结点之下分布着一些互不交叉的子集合,这些子集合是根结点的子树。树结构的基本特征如下:
- 在一个树结构中,有且仅有一个结点没有直接前驱,这个结点就是树的根结点;
- 除根结点外,其余每个结点有且仅有一个直接前驱;
- 每个结点可以有任意多个直接后继。
从树的定义可以看出,树具有层次结构的性质。而从数学的角度来看,树具有递归的特性。在树中的每个结点及其后的所有结点构成一个子树,这个子树也包括根结点。

在树结构中,二叉树是最简单的一种形式。在研究树结构时,二叉树是树结构内容中的重点。二叉树的描述相对简单,处理也相对简单,而且更为重要的是任意的树都可以转换成对应的二叉树。

二叉树

二叉树是树结构的一种特殊形式,它是n个结点的集合,每个结点最多只能有两个子结点。二叉树的子树仍然是二叉树。二叉树的一个结点上对应的两个子树分别称为左子树和右子树。由于树有左右之分,因此二叉树是有序树。

二叉树可以进一步细分为两种特殊的类型,满二叉树和完全二叉树:
- 满二叉树:在二叉树中除最下一层的叶结点外,每层的结点都有两个子结点,即这是一个每一层都不缺结点的完整二叉树。
- 完全二叉树:在二叉树中除二叉树最后一层外,其他各层的结点数都达到最大个数,且最后一层叶结点按照从左到右的顺序连续存在,只缺最后一层右侧若干结点。

从上述二叉树和完全二叉树的定义可以看出,满二叉树一定是完全二叉树,而完全二叉树不一定是满二叉树,因为其没有达到完全满分支结构。

按照数据的存储方式,树结构可以分为顺序存储结构和链式存储结构两种:
1. 二叉树的顺序存储:与线性表类似,树结构的顺序存储一般采用一位结构数组来表示。这里的关键是定义合适的次序来存放树中各个层次的数据。如果采用顺序存储方式,可以将其按层来存储,即先存储根结点,然后从左至右依次存储下一层结点的数据….,直到所有的结点数据完全存储。
二叉树的链式存储结构定义代码实例:

static final int MAXLEN = 100;      // 最大结点数
char[] SeqBinaryTree = new char[MAXLEN];    // 定义保存二叉树数组

2. 二叉树的链式存储:与线性结构的链式存储类似,二叉树的链式存储结构包含结点元素及分别指向左子树和右子树的引用。
二叉树的链式存储结构定义代码实例:

class CBTType{                  // 树结点的类型结构
    String data;                // 结点保存的数据
    CBTType left;               // 指向的左子树
    CBTType right;              // 指向的右子树
}
CBTType root = null;            // 定义二叉树根结点引用

准备数据

定义二叉树结构的类CBTType。结点的具体数据保持在一个字符串data中,而引用left用来指向左子树结点,引用right用来指向右子树结点。

/*
 * 链式二叉树
 * chain binary tree
 */
class CBTType{                  // 树结点的类型结构
    String data;                // 结点保存的数据
    CBTType left;               // 指向的左子树
    CBTType right;              // 指向的右子树
}

初始化二叉树

在使用顺序表之前,首先要初始化二叉树。在此,在程序中只需将一个结点设置为二叉树的根结点。

CBTType InitTree(){             // 创建二叉树结点
    CBTType node;
    if((node = new CBTType())!=null){       // 分配内存
        System.out.println("请先输入一个根结点数据:");
        node.data=input.next();
        node.left=null;
        node.right=null;
        if(node!=null){
            return node;
        }else{
            return null;
        }
    }
    return null;
}

在上述代码中,首先申请内存,然后由用户输入一个根结点数据,并将指向左子树和右子树的引用设置为空,即可完成二叉树的初始化工作。

添加结点

添加结点即在二叉树中添加结点数据。添加结点时除了要输入结点数据外,还需要指定其父结点,以及添加的结点是作为左子树还是作为右子树。

void AddTreeNode(CBTType treeNode){         // 添加结点
    CBTType pnode,parent;
    String data;
    int menusel;
    if((pnode=new CBTType())!=null){        // 分配内存
        System.out.printf("输入需新增的二叉树结点数据:");
        pnode.data=input.next();            // 创建一个新输入的结点
        pnode.left=null;
        pnode.right=null;

        System.out.printf("输入该结点的父结点数据:");
        data=input.next();

        parent=TreeFindNode(treeNode,data);         // 查找指定数据的结点
        if(parent==null){
            System.out.println("未找到该父结点!");
            pnode=null;
            return;
        }

        System.out.println("1.添加该结点到左子树\t2.添加该结点到右子树");
        do{
            menusel = input.nextInt();
            if(menusel==1 || menusel==2){
                if(parent==null){
                    System.out.println("不存在父结点,请先设置父结点!");
                }else{
                    switch (menusel) {
                    case 1:
                        if(parent.left!=null){
                            System.out.println("左子树不为空!");
                        }else{
                            parent.left=pnode;
                        }
                        break;
                    case 2:
                        if(parent.right!=null){
                            System.out.println("右子树结点不为空!");
                        }else{
                            parent.right=pnode;
                        }
                        break;
                    default:
                        System.out.println("无效参数!");
                        break;
                    }
                }
            }
        }while(menusel!=1 && menusel!=2);
    }
}

在上述代码中,输入参数treeNode为二叉树的根结点,参数传入根结点是为了方便在代码中进行查找。程序中首先申请内存,然后由用户输入二叉树结点数据,并设置左、右子树为空。接着指定其父结点,最后设置其作为左子树还是作为右子数。

查找结点

查找结点即在二叉树中的每一个节点中,逐个比较数据,当找到目标数据时,将返回该数据所在结点的引用。查找结点的代码如下:

CBTType TreeFindNode(CBTType treeNode, String data){    // 查找结点
    CBTType node;
    if(treeNode == null){
        return null;
    }else{
        if(treeNode.data.equals(data)){
            return treeNode;
        }else if((node = TreeFindNode(treeNode.left,data))!=null){      // 分别向左右子数递归查找
            return node;
        }else if((node = TreeFindNode(treeNode.right,data))!=null){
            return node;
        }else{
            return null;
        }
    }
}

在上述代码中,输入参数treeNode为待查找的二叉树的根结点,输入参数data为待查找的结点数据。程序中首先判断根结点是否为空,然后分别向左、右子树递归查找。如果当前结点的数据与查找数据相等,则返回当前结点的引用。

获取左子树

CBTType TreeLeftNode(CBTType treeNode){     // 获取左子树
    if(treeNode==null){
        return null;
    }
    return treeNode.left;
}

获取右子树

CBTType TreeRightNode(CBTType treeNode){    // 获取右子树
    if(treeNode==null){
        return null;
    }
    return treeNode.right;
}

判断空树

int TreeIsEmpty(CBTType treeNode){          // 判断空树
    if(treeNode == null){
        return 1;
    }else{
        return 0;
    }
}

计算二叉树深度

计算二叉树深度即计算二叉树中结点的最大层数,这里往往需要采用递归算法来实现。

int TreeDepth(CBTType treeNode){            // 计算二叉树深度
    if(treeNode==null){             // 递归临界条件
        return 0;               // 对于空树 深度为0
    }
    return Math.max(TreeDepth(treeNode.left), TreeDepth(treeNode.right))+1; // 递归调用左右子树 计算深度,并回溯深度+1
}

在上述代码中,输入参数treeNode为待计算的二叉树的根节点。程序中首先判断根结点是否为空,然后分别按照递归调用来计算左子树深度和右子树深度,取左右子树深度中较大的值再加上根结点的深度1,作为整个二叉树深度。

清空二叉树

清空二叉树即将二叉树变为一个空树,这里也需要实用递归算法来实现。程序中按照递归调用来清空左子树和右子树,并且使用赋值null操作来释放当前结点所占内存,从而完成清空操作。

void ClearTree(CBTType treeNode){           // 清空二叉树
    if(treeNode!=null){
        ClearTree(treeNode.left);           //递归调用 清空左右子树,最后清空父结点
        ClearTree(treeNode.right);
        treeNode = null;
    }
}

显示结点数据

void TreeNodeData(CBTType p){               // 显示结点数据
    if(p==null){
        System.out.println("无效结点!");
    }else{
        System.out.printf("%s",p.data);
    }
}

遍历二叉树

可以通过按层遍历方式遍历树结构,也可以通过使用递归来简化遍历算法。

按层遍历算法

由于二叉树代表的是一种层次结构,因此,首先按层来遍历整个二叉树。对于二叉树的按层遍历,一般不能使用递归算法来编写代码,而是使用一个循环队列来进行处理。首先将第1层(根结点)进入队列,再将第1层的左右子树(第2层)进入队列….,循环处理,可以逐层遍历。

void LevelTree(CBTType treeNode){           // 按层遍历
    CBTType node;
    CBTType[] stack = new CBTType[MAXLEN];  // 定义一个顺序队列,保存各结点对象
    int head=0,tail=0;
    if(treeNode!=null){
        tail = (tail+1)%MAXLEN;             // 利用取余 实现循环队列
        stack[tail]=treeNode;               // 将二叉树的根结点入队列
    }
    while(head!=tail){                      // 当队列不为空时,循环入队和出队遍历 打印结点   
        head=(head+1)%MAXLEN;
        node = stack[head];                 // 队首元素出队列
        TreeNodeData(node);
        if(node.left!=null){                // 遍历下一层时 队首元素的左子树入队列
            tail=(tail+1)%MAXLEN;
            stack[tail]=node.left;
        }
        if(node.right!=null){               // 遍历下一层时 队首元素的右子树入队列
            tail=(tail+1)%MAXLEN;
            stack[tail]=node.right;
        }
    }
}

先序遍历算法

先序遍历算法即先访问根结点,再按先序遍历左子树,最后按先序遍历右子树。程序中可以按照递归的思路来遍历整个二叉树。在程序中,输入参数为需要遍历的二叉树根结点。

void DLRTree(CBTType treeNode){             // 先序遍历
    if(treeNode!=null){
        TreeNodeData(treeNode);             // 先打印结点数据,再遍历左右子树
        DLRTree(treeNode.left);
        DLRTree(treeNode.right);
    }
}

中序遍历算法

中序遍历算法即先按中序遍历左子树,再访问根结点,最后按中序遍历右子树。程序中可以按照递归的思路来遍历整个二叉树。在程序中,输入参数为需要遍历的二叉树根结点。

void LDRTree(CBTType treeNode){             // 中序遍历
    if(treeNode!=null){
        LDRTree(treeNode.left);             // 先遍历左子树 打印结点数据 再遍历右子树
        TreeNodeData(treeNode);
        LDRTree(treeNode.right);
    }
}

后续遍历算法

后序遍历算法即先按后序遍历左子树,再按后序遍历右子树,最后访问根结点。程序中可以按照递归的思路来遍历整个二叉树。在程序中,输入参数为需要遍历的二叉树根结点。

void LRDTree(CBTType treeNode){             // 后续遍历
    if(treeNode!=null){
        LRDTree(treeNode.left);             // 先遍历左右子树,再打印结点
        LRDTree(treeNode.right);
        TreeNodeData(treeNode);
    }
}

数结构操作实例

package dataStructure.tree;

import java.util.Scanner;

/*
 * 链式二叉树
 * chain binary tree
 */
class CBTType{                  // 树结点的类型结构
    String data;                // 结点保存的数据
    CBTType left;               // 指向的左子树
    CBTType right;              // 指向的右子树
}

class ChainBinaryTree{
    static final int MAXLEN = 20;
    static Scanner input = new Scanner(System.in);
    CBTType InitTree(){             // 创建二叉树结点
        CBTType node;
        if((node = new CBTType())!=null){       // 分配内存
            System.out.println("请先输入一个根结点数据:");
            node.data=input.next();
            node.left=null;
            node.right=null;
            if(node!=null){
                return node;
            }else{
                return null;
            }
        }
        return null;
    }

    void AddTreeNode(CBTType treeNode){         // 添加结点
        CBTType pnode,parent;
        String data;
        int menusel;
        if((pnode=new CBTType())!=null){        // 分配内存
            System.out.printf("输入需新增的二叉树结点数据:");
            pnode.data=input.next();            // 创建一个新输入的结点
            pnode.left=null;
            pnode.right=null;

            System.out.printf("输入该结点的父结点数据:");
            data=input.next();

            parent=TreeFindNode(treeNode,data);         // 查找指定数据的结点
            if(parent==null){
                System.out.println("未找到该父结点!");
                pnode=null;
                return;
            }

            System.out.println("1.添加该结点到左子树\t2.添加该结点到右子树");
            do{
                menusel = input.nextInt();
                if(menusel==1 || menusel==2){
                    if(parent==null){
                        System.out.println("不存在父结点,请先设置父结点!");
                    }else{
                        switch (menusel) {
                        case 1:
                            if(parent.left!=null){
                                System.out.println("左子树不为空!");
                            }else{
                                parent.left=pnode;
                            }
                            break;
                        case 2:
                            if(parent.right!=null){
                                System.out.println("右子树结点不为空!");
                            }else{
                                parent.right=pnode;
                            }
                            break;
                        default:
                            System.out.println("无效参数!");
                            break;
                        }
                    }
                }
            }while(menusel!=1 && menusel!=2);
        }
    }

    CBTType TreeFindNode(CBTType treeNode, String data){    // 查找结点
        CBTType node;
        if(treeNode == null){
            return null;
        }else{
            if(treeNode.data.equals(data)){
                return treeNode;
            }else if((node = TreeFindNode(treeNode.left,data))!=null){      // 分别向左右子数递归查找
                return node;
            }else if((node = TreeFindNode(treeNode.right,data))!=null){
                return node;
            }else{
                return null;
            }
        }
    }

    CBTType TreeLeftNode(CBTType treeNode){     // 获取左子树
        if(treeNode==null){
            return null;
        }
        return treeNode.left;
    }

    CBTType TreeRightNode(CBTType treeNode){    // 获取右子树
        if(treeNode==null){
            return null;
        }
        return treeNode.right;
    }

    int TreeIsEmpty(CBTType treeNode){          // 判断空树
        if(treeNode == null){
            return 1;
        }else{
            return 0;
        }
    }

    int TreeDepth(CBTType treeNode){        // 计算二叉树深度
        if(treeNode==null){         // 递归临界条件
            return 0;           // 对于空树 深度为0
        }
        return Math.max(TreeDepth(treeNode.left), TreeDepth(treeNode.right))+1; // 递归调用左右子树 计算深度,并回溯深度+1
    }

    void ClearTree(CBTType treeNode){           // 清空二叉树
        if(treeNode!=null){
            ClearTree(treeNode.left);           //递归调用 清空左右子树,最后清空父结点
            ClearTree(treeNode.right);
            treeNode = null;
        }
    }

    void TreeNodeData(CBTType p){               // 显示结点数据
        if(p==null){
            System.out.println("无效结点!");
        }else{
            System.out.printf("%s",p.data);
        }
    }

    void LevelTree(CBTType treeNode){           // 按层遍历
        CBTType node;
        CBTType[] stack = new CBTType[MAXLEN];  // 定义一个顺序队列,保存各结点对象
        int head=0,tail=0;
        if(treeNode!=null){
            tail = (tail+1)%MAXLEN;             // 利用取余 实现循环队列
            stack[tail]=treeNode;               // 将二叉树的根结点入队列
        }
        while(head!=tail){                      // 当队列不为空时,循环入队和出队遍历 打印结点   
            head=(head+1)%MAXLEN;
            node = stack[head];                 // 队首元素出队列
            TreeNodeData(node);
            if(node.left!=null){                // 遍历下一层时 队首元素的左子树入队列
                tail=(tail+1)%MAXLEN;
                stack[tail]=node.left;
            }
            if(node.right!=null){               // 遍历下一层时 队首元素的右子树入队列
                tail=(tail+1)%MAXLEN;
                stack[tail]=node.right;
            }
        }
    }

    void DLRTree(CBTType treeNode){             // 先序遍历
        if(treeNode!=null){
            TreeNodeData(treeNode);             // 先打印结点数据,再遍历左右子树
            DLRTree(treeNode.left);
            DLRTree(treeNode.right);
        }
    }       

    void LDRTree(CBTType treeNode){             // 中序遍历
        if(treeNode!=null){
            LDRTree(treeNode.left);             // 先遍历左子树 打印结点数据 再遍历右子树
            TreeNodeData(treeNode);
            LDRTree(treeNode.right);
        }
    }

    void LRDTree(CBTType treeNode){             // 后续遍历
        if(treeNode!=null){
            LRDTree(treeNode.left);             // 先遍历左右子树,再打印结点
            LRDTree(treeNode.right);
            TreeNodeData(treeNode);
        }
    }

}

/**
 * 测试用例
 * @author elon@elon33.com
 *
 */
public class BinaryTree {
    static Scanner input = new Scanner(System.in);
    public static void main(String[] args){
        CBTType root = null;                    // root 为指向二叉树根节点的引用
        int menusel=0;
        ChainBinaryTree cbt = new ChainBinaryTree();
        root = cbt.InitTree();
        do{
            System.out.println("请选择菜单选择添加二叉树的结点:");
            System.out.printf("0.退出\t");
            System.out.println("1.添加二叉树的子结点");
            menusel = input.nextInt();
            switch (menusel) {
            case 1:
                cbt.AddTreeNode(root);
                break;
            case 0:
                break;
            default:
                break;
            }
        }while(menusel!=0);

        // 遍历
        do{
            System.out.println("请选择菜单遍历二叉树,输入0表示退出:");
            System.out.printf("1.先序遍历DLR\t");
            System.out.printf("2.中序遍历LDR\t");
            System.out.printf("3.后序遍历LRD\t");
            System.out.println("4.按层遍历");
            menusel=input.nextInt();
            switch (menusel) {
            case 0:
                break;
            case 1:
                System.out.printf("\n先序遍历DLR的结果:");
                cbt.DLRTree(root);
                System.out.println();
                break;
            case 2:
                System.out.printf("\n中序遍历LDR的结果:");
                cbt.LDRTree(root);
                System.out.println();
                break;
            case 3:
                System.out.printf("\n后序遍历LRD的结果:");
                cbt.LRDTree(root);
                System.out.println();
                break;
            case 4:
                System.out.printf("\n按层遍历的结果:");
                cbt.LevelTree(root);
                System.out.println();
                break;
            default:
                break;
            }
        }while(menusel!=0);
        System.out.println("\n 二叉树深度为:" + cbt.TreeDepth(root));     // 二叉树深度
        cbt.ClearTree(root);
        root = null;
    }
}



硬件工程师入门基础知识(一)基础元器件认识(二) 我们的电路输入一般是只有两种状态,0V 或者是其它的高电平(1.8V,3.3V,5V 等),截止状态一般不用怎么考虑,因为如果让三极管的 Vbe=0,自然就截止了,重要的是饱和状态如何保证。也就是说只要 Rb 阅读详情

相关推荐

浮点数运算的陷阱与启示:FP16加法器/乘法器开发中的常见误区

本文深入探讨FP16加法器和乘法器开发中的常见误区,包括FP16格式解析、阶码对齐陷阱、尾数运算风险及规格化处理。通过Verilog实战代码展示防御性编程技巧,帮助开发者避免边界条件处理和异常状态管理中的错误,提升硬件设计的可靠性和效率。

dell8的博客 252

第三方控件DEV中的TreeList如何显示树形结构

private void reflishcategory()               //刷新treelist使用 {             TreeListNode node = null; //获取ProductCategory对象的集合的方法。大家根据实际情况只要知道categorys是ProductCategory对象的集合,而ProductCategory中又包含了Produ

yunanzhe987的专栏 4591

LinuxCNC开发实战:从安装到EtherCAT配置全解析

本文详细解析LinuxCNC开发实战,从系统安装到EtherCAT总线配置全流程。涵盖实时内核优化、伺服驱动器PDO映射、HAL配置及自定义运动学开发,帮助开发者快速搭建工业级数控系统,提升运动控制精度与稳定性。

rgv234567的博客 355

第二十四题 求取树的深度

//求取树的深度 #include using namespace std; struct treenode { treenode *m_left; treenode *m_right; int value; }; //定义一个平衡二叉树 void maketree(int value,treenode *&ptr) { if (ptr==nullptr) { treenode

oqqNAME的专栏 717

Vivado实战:如何用BUFGMUX_CTRL实现FPGA双时钟热切换(附时序约束模板)

本文详细介绍了如何使用Xilinx FPGA中的BUFGMUX_CTRL原语实现双时钟热切换的工业级解决方案。通过分析BUFGMUX_CTRL的核心机制、PCB布局约束和电源噪声抑制方法,提供Vivado实现全流程和时序约束模板,帮助工程师在工业自动化、车载电子等场景中提升系统可靠性。

weixin_29186249的博客 585

OpenWRT系统启动流程全解析:从procd到ubus的完整链路(附源码分析)

本文深入解析了OpenWRT系统从内核移交控制权到用户空间服务就绪的完整启动链路。核心聚焦于进程管理器procd与通信总线ubus的协同工作机制,通过源码分析揭示了状态机转换、服务注册与事件分发的内在逻辑,为系统定制、启动优化与故障调试提供了清晰指南。

weixin_28335283的博客 534

数据结构 一 树

树 树是由一个集合以及在该集合上定义的一种关系构成的。 集合中的元素称为树的结点,所定义的关系称为父子关系。 父子关系在树的结点之间建立了一个层次结构。 树的结点包含一个元素及若干指向其子树的若干分支。 在这种层次结构中有一个结点具有特殊的地位,这个结点称为该树的根结点,简称树根。 树是n(n>=0)个结点的有限集 空树(n=0),空树中不包含任何系结点 非空树(n>0),此时有且仅有一个特定的称为根的结点 当n>1时,其余结点可分为m(m>0)个互不相交的有限集,

sunny潘先生的博客 515

树莓派 SPI操作

扩展板配备一款0.96inch,128864分辨率的oled显示屏,通过SPI控制,先上显示效果图。由于程序过长,在这里我就不把代码全部贴出来了,只是简单讲解一下spi的操作函数。管脚如下如所有,左边方框的管脚分别为MOSI MISO SCLK,左边CE0,CE1为两个片选管脚,分别对应上图中的spidev0.0,spidev0.1两个设备。下载spidev库,复制到树莓派,并行运行如下命令解压安装。spi设备,此处设备为/dev/spi-decv0.0。在/dev路径下面,我们可以发现两个spi设备。

weixin_46529898的博客 917

Dev TreeList树控件使用

Winform 快速初始化Dev TreeList树控件的数据 使用Id,ParentId数据结构即可初始化TreeList,如下图: 图中TreeList控件命名tlCategory。 产品类别数据表定义: 建议Id,ParentId数据取名用01:CPU,0101:AMD-CPU,010101:AMD-XXCPU表示,虽然意义不是特别明显,顺势而为吧,群众认为是对的也不会太离谱

ht_gaogao的专栏 6340

ROS通信机制深度解析:为什么话题订阅模型比服务调用更适合你的机器人项目?

本文深入解析ROS通信机制,重点探讨话题订阅模型相较于服务调用在机器人项目中的优势。通过性能对比和架构分析,揭示话题模型在异步通信、系统解耦和实时数据处理方面的卓越表现,特别适合传感器数据流和高频控制场景。文章还提供了实际案例和高级应用技巧,帮助开发者优化机器人系统设计。

weixin_29172963的博客 102

Lasso的原理及其与其他特征选择方法的比较进行阐述,然后讨论Lasso优点、缺点以及应用场景,最后给出了代码实例

在机器学习领域中,特征选择(feature selection)是指在模型训练前对数据集进行分析,选择其中有助于预测目标变量或影响模型性能的特征,去除不相关或冗余的特征,提升模型的泛化能力。而Lasso回归是一种很流行的用于特征选择的方法之一。Lasso回归(又称LASSO,least absolute shrinkage and selection operator)是一种线性模型中的特征选择方法。

AI天才研究院 3052

JS树结构操作:查找、遍历、筛选、树结构和列表结构相互转换

转自:沐码小站https://wintc.top/article/20经常有同学问树结构的相关操作,也写了很多次,在这里总结一下 JS 树形结构一些操作的实现思路,并给出了简洁易懂的代码...

前端达人 3492

【深度学习|Transformer模型学习】什么是前馈神经网络(Feed-Forward Neural Network)?将前馈神经网络中的全连接层变成1*1卷积层会有什么样的效果?

【深度学习|Transformer模型学习】什么是前馈神经网络(Feed-Forward Neural Network)?将前馈神经网络中的全连接层变成1*1卷积层会有什么样的效果?

985小水博的摸鱼日常 1377

java - poi递归导出树结构Excel,导入树结构Excel,树结构递归查询,新增,修改,删除

文章目录一、表结构设计,导入导出模板。二、递归查询树结构1.思路如下2.代码示例二、新增树结构思路如下三.树结构修改。思路如下四、递归删除树结构1.思路如下2.代码示例五、树结构递归导出Excel1.思路如下2.代码示例六、导入树结构Excel1.思路如下2.代码示例吹牛逼结束,感谢观看 一、表结构设计,导入导出模板。 注: 博主树结构为8级结构,因业务关系,故分为两张表。此表分为4级结构如下: 楼栋 — 单元 — 楼层 — 房间 Excel表格项目名字段从第一张表获取,忽略即可。 表仅截取几个树结

kai641596729的博客 5509

汉书HE8,好用的汇编代码编写工具

汉书HE8,好用的汇编代码编写工具早期编写汇编代码所用功能强大

精雕软件(JDpaint) 5.5 绿色版

精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版精雕软件(JDpaint) 5.5 绿色版

树结构概述

文章目录什么是树结构?简介为什么要使用树结构?树的基本概念根节点双亲节点路径节点的度节点的权叶子节点子树层树的高度森林 什么是树结构? 树是一种重要的非线性数据结构,直观地看,它是数据元素(在树中称为结点)按分支关系组织起来的结构,很象自然界中的树那样 简介 树结构在客观世界中广泛存在,如人类社会的族谱和各种社会组织机构都可用树形象表示。树在计算机领域中也得到广泛应用,如在编译源程序如下时,可用树...

Woo_home的博客 5782

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

Java树结构的创建和使用详解

首先,我们需要定义一个树节点类,用于表示树结构中的节点。// 构造方法、getter和setter方法Copy在上面的示例中,TreeNode类包含了一个数据域data、一个子节点列表children和一个父节点引用parent。// 构造方法、getter和setter方法Copy本文详细介绍了在Java中创建和使用树结构的方法,包括树节点类的定义、树结构的创建以及树结构在具体业务中的应用。树结构作为一种重要的数据结构,在实际开发中有着广泛的应用场景,能够有效地组织和管理数据。

2301_82147294的博客 6711

Camera2Demo

在Camera2 的基础上进行封装,使得Camera2一堆初始化逻辑与Activity分离,降低耦合度,完成预览拍照并保存的操作

树结构使用实例---实现数组和树结构的转换

树是一种非散列数据结构,和非散列表一样,它对于存储需要快速查找的数据非常有用。 树是一种分层数据的抽象模型。现实生活中最常见的树的例子是家谱,或是公司的组织架构 本文将讲述一个实例,构造一棵树来实现数组和tree的相互转换,这在前端树结构中是经常遇到的。 需求场景: 将数组转化树结构,并将树结构转化为数组 数组 const list= [ { id: 1001, parentId: 0, name: 'AA' }, { id: 1002, parentId: 1001, ...

前端361 3730

js数组和树结构数据相互转换

数组转树结构采取递归和非递归两种方式,树结构转扁平化数组采取深度优先遍历(递归和非递归两种方式)和广度优先遍历实现。 let arr =[ {id:2,name:'部门B',parentId:0}, {id:3,name:'部门C',parentId:1}, {id:1,name:'部门A',parentId:2}, {id:4,name:'部门D',parentI...

susuzhe 1万+

JS树结构操作:查找、遍历、筛选、树结构和列表结构相互转换

JS树结构操作:查找、遍历、筛选、树结构和列表结构相互转换 经常有同学问树结构的相关操作,在这里总结一下JS树形结构一些操作的实现思路,并给出了简洁易懂的代码实现。 本文内容结构大概如下: 遍历树结构 1. 树结构介绍 JS中树结构一般是类似于这样的结构: let tree = [ { id: '1', title: '节点1', children: [ { id: '1-1', title: '节点1-1' },

weixin_42069147的博客 5564

js树结构操作

let tree = [ { id: '1', title: '节点1', children: [ { id: '1-1', title: '节点1-1' } ] }, { id: '2', title: '节点2', children: [

nick_zhang的博客 2802

树结构实现多级列表的显示

一、概述 多级列表的显示是编程时比较常见的功能,包括显示屏多菜单的显示和文件列表的显示。本次对该问题进行整理归纳,使用树结构进行完美解决。 使用STM32作为处理平台驱动oled显示。 二、解决思路 我以本次实现的多菜单显示作为示例进行说明。菜单显示分为列表显示和按键控制。多级菜单显示常见方法有三种: 使用数组对各级菜单显示内容进行存储,然后编写按键控制对各界面进行切换; 使用链表的方式进行显示,每个节点分别定义指针指向显示的内容、按键操作方法和上下级节点; 树结构的方式进行显示,只需初...

zhang421412170的博客 1548

es6遍历树结构并判断_JavaScript树结构操作:查找、遍历、筛选、树结构和列表结构相互转换...

经常有同学问树结构的相关操作,也写了很多次,在这里总结一下JS树形结构一些操作的实现思路,并给出了简洁易懂的代码实现。本文内容结构大概如下:一、遍历树结构1. 树结构介绍JS中树结构一般是类似于这样的结构:let tree = [ { id: '1', title: '节点1', children: [ { id: '1-1', ...

weixin_33196646的博客 1731

redis存储树结构数据

本文主要讲解两方面内容:1.redis如何存储树结构数据。2.java操作redis时选取哪种序列化器。 redis如何存储树结构数据 先抛出结论,树结构数据在redis中的存储顺序如下: ...

thanksm1的博客 1万+

一文了解树结构召回演变

本文梳理了2018-2021年间4种重要的树结构召回模型:阿里的TDM系列(TDM1.0、JTM2.0、OTM3.0)和字节的DR模型,这些模型在推荐系统中都取得了显著效果提升。文章提供了各模型的论文解读、技术详解视频和开源代码实现(包括XDL、PaddleRec、TensorFlow等框架),帮助读者了解树结构召回技术的发展脉络。

乐于创作,乐于分享,志于创作高价值博文 1105

树结构的一些概念

树结构 树结构着重表达个体之间的层次关系。 树结构的应用领域: 1、社会关系:企业组织结构 2、信息技术:文件目录、分类学、物种发展史 3、逻辑学:决策树、思维导图 等 树结构的可视化方法 1、结点链接法:清晰展示树的结构和对象之间的层次关系 2、空间镶嵌填充法:有效利用空间来展示树的结构,比较适合显示包含和从属的关系 3、混合法:既结构清晰,又有效利用空间 结点链接法 结点和链接关系的布局方...

计算机小白努力学习 1906

java递归实现树结构封装

1.新建树结构表 2.生成树实体对象 3.递归实现树结构封装 package com.jd.org.service.impl; import com.alibaba.fastjson.JSONArray; import com.alibaba.fastjson.JSONObject; import com.jd.org.entity.TreeNode; import com.jd.org.mapper.TreeNodeMapper; import com.jd.org.service.Tr

萌新比克o的博客 766
上一篇: 队列结构
下一篇: Java中8种基本数据类型及其默认值
gamedev˚
博客等级 码龄12年 280粉丝 293原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值