精华内容
下载资源
问答
  • 如何计算给定二叉树中节点数?

    千次阅读 2019-09-02 09:19:38
    叶子节点的特征是无左孩子也无右孩子,还要注意与只有一个节点的情况区分。 一、程序计算 int leaf(bitree t) { if(!t) return 0; //空,无叶子 else if(!t->lch && !t->rch) return 1; ...

    叶子节点的特征是无左孩子也无右孩子,还要注意与树只有一个节点的情况区分。

    一、程序计算

    int leaf(bitree t)
    {
      if(!t)       
       return 0;      //空树,无叶子 
      else if(!t->lch && !t->rch)
               return 1;
            else 
               return (leaf(t->lch) + leaf(t->rch));
    }

    二、手动计算公式

    利用“树中所有结点的度数之和再加1等于结点数”

    n_{0}+n_{1}+n_{2}+...+n_{m}=1n_{1}+2n_{2}+...+mn_{m}+1

    则叶子节点数,即n_{0} 为:

    n_{0}=(1n_{1}+2n_{2}+3n_{3}+...+mn_{m}+1)-(n_{1}+n_{2}+n_{3}+...+n_{m})

    展开全文
  • 再讲完全二叉树节点数计算之前,我们先来看什么是完全二叉树 ...我们现在来看如何计算完全二叉树的节点个数呢? 如果是一个普通的二叉树,显然只要向下遍历一遍就行,时间复杂度为 O(N) int countNodes(TreeNode* ...

    再讲完全二叉树节点数计算之前,我们先来看什么是完全二叉树

    完全二叉树就是,树的高度差最多为1,且最后一层的节点都是紧凑靠左排列的。

    在这里插入图片描述
    满二叉树就是一种特殊的完全二叉树**,每层都是满的,除叶子结点外,每一层都有两个子节点**:

    在这里插入图片描述

    我们现在来看如何计算完全二叉树的节点个数呢?

    如果是一个普通的二叉树,显然只要向下遍历一遍就行,时间复杂度为 O(N)

    int countNodes(TreeNode* root)
    {
    	if(root == nullptr) 
    		return 0 ;
    	return 1 + countNodes(root->left) + countNodes(root->right);
    }
    

    那么如果是一个满二叉树,节点总数与高度呈指数关系,时间复杂度为O(logN)

    int countNodes(TreeNode* root)
    {
    	int h = 0;
    	while(root != nullptr)
    	{
    		root = root->left;
    		h++;
    	}
    	return pow(2,h) - 1;
    }
    

    完全二叉树比普通二叉树普通,但是又没有满二叉树那么特殊所以它分情况看用哪一种算法。

    int coutNodes(TreeNode *root)
    {
    	TreeNode* l = root;
    	TreeNode* r = root;
    	int hleft = 0;
    	int hright = 0;
    	while(l != nullptr)
    	{
    		l = l->left;
    		hleft++;
    	}
    	while(r != nullptr)
    	{
    		r = r->right;
    		hright++;
    	}
    	//如果左右子树的高度相同,则是一颗满二叉树
    	if(hleft == hright)
    		return pow(2,hleft) - 1;
    	
    	else //按照普通二叉树的逻辑进行计算
    		return 1 + countNodes(root->left) + countNodes(root->right);
    }
    
    展开全文
  • 树的度:一棵树中,最大的节点的度称为树的度; 叶子节点或终端节点:度为0的节点称为叶节点; 双亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点; 孩子节点或子节点:一个节点含有的子树的...

    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档


    前言

    1.树的一些定义

    节点的度:一个节点含有的子树的个数称为该节点的度;
    树的度:一棵树中,最大的节点的度称为树的度;
    叶子节点或终端节点:度为0的节点称为叶节点;
    双亲节点或父节点:若一个节点含有子节点,则这个节点称为其子节点的父节点;
    孩子节点或子节点:一个节点含有的子树的根节点称为该节点的子节点;
    根结点:一棵树中,没有双亲结点的结点;
    节点的层次:从根开始定义起,根为第1层,根的子节点为第2层,以此类推;
    树的高度或深度:树中节点的最大层次;

    非终端节点或分支节点:度不为0的节点;
    兄弟节点:具有相同父节点的节点互称为兄弟节点;
    堂兄弟节点:双亲在同一层的节点互为堂兄弟;
    节点的祖先:从根到该节点所经分支上的所有节点;
    子孙:以某节点为根的子树中任一节点都称为该节点的子孙。
    森林:由m(m>=0)棵互不相交的树的集合称为森林

    2.二叉树的一些性质

    二叉树的特点

    1. 每个结点最多有两棵子树,即二叉树不存在度大于 2 的结点。
    2. 二叉树的子树有左右之分,其子树的次序不能颠倒,因此二叉树是有序树。

    两种特殊的二叉树

    满二叉树: 一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是2^k-1 ,则它就是满二叉树。
    完全二叉树: 完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树

    二叉树的性质

    1. 若规定根节点的层数为1,则一棵非空二叉树的第i层上最多有2^{i-1}(i>0)个结点
    2. 若规定只有根节点的二叉树的深度为1,则深度为K的二叉树的最大结点数是2^k-1(k>=0)
    3. 对任何一棵二叉树, 如果其叶结点个数为 n0, 度为2的非叶结点个数为 n2,则有n0=n2+1
    4. 具有n个结点的完全二叉树的深度k为log2(n+1)log_2(n+1)上取整
    5. 对于具有n个结点的完全二叉树,如果按照从上至下从左至右的顺序对所有节点从0开始编号,则对
      于序号为i的结点有:
      若i>0,双亲序号:(i-1)/2;i=0,i为根节点编号,无双亲节点
      若2i+1<n,左孩子序号:2i+1,否则无左孩子
      若2i+2<n,右孩子序号:2i+2,否则无右孩子
    
    class TreeNode {
        String val;
        TreeNode left;
        TreeNode right;
    
        public TreeNode(String val) {
            this.val = val;
        }
    
        @Override
        public String toString() {
            return "val='" + val ;
        }
    }
    
    
    public static TreeNode great(){
            TreeNode A = new TreeNode("A");
            TreeNode B = new TreeNode("B");
            TreeNode C = new TreeNode("C");
            TreeNode D = new TreeNode("D");
            TreeNode E = new TreeNode("E");
            TreeNode F = new TreeNode("F");
    
            A.left = B;
            A.right = C;
            B.left = D;
            C.left = E;
            E.right = F;
    
            return A;
        }
    

    3.前序,中序,后序遍历

    1. NLR:前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点—>根的左子树—>根的右子树。
    2. LNR:中序遍历(Inorder Traversal)——根的左子树—>根节点—>根的右子树。
    3. LRN:后序遍历(Postorder Traversal)——根的左子树—>根的右子树—>根节点
    //    先序遍历
        public static void preOrderTraversal(TreeNode root){
            if(root == null){
                return ;
            }
            System.out.print(root.val);
            preOrderTraversal(root.left);
            preOrderTraversal(root.right);
        }
    //    中序遍历
        public static void inOrderTraversal(TreeNode root){
            if(root == null){
                return;
            }
            inOrderTraversal(root.left);
            System.out.print(root.val);
            inOrderTraversal(root.right);
        }
    
    //    后序遍历
        public static void postOrderTraversal(TreeNode root){
            if(root == null){
                return;
            }
            postOrderTraversal(root.left);
            postOrderTraversal(root.right);
            System.out.print(root.val);
        }
    
    

    对上面所创造的二叉树三种遍历的结果如图:
    在这里插入图片描述

    展开全文
  • 众所周知,在计算机领域是一种重要非线性数据结构,直观看,它还是数据元素按分支关系组织起来结构呢,那下面小编跟大家带来聊聊一种名叫二叉树数据结构,一起来看看二叉树层次又是如何计算的呢?...

    众所周知,树在计算机领域是一种重要的非线性数据结构,直观的看,它还是数据元素按分支关系组织起来的结构呢,那下面小编跟大家带来聊聊一种名叫二叉树的数据结构,一起来看看二叉树层次又是如何计算的呢?

    那么何为二叉树呢?是这样的,树是有很多种,

    其中每个节点最多只能有两个子节点的叫二叉树,二叉树的子节点又分为左节点和右节点,如果呢,二叉树的所有叶子节点全部都在最后一层, 并且结点总数=2^n-1,

    n为层数, 则我们称之为满二叉数,如果该二叉树的所有叶子节点(没有子节点的节点)都在最后一层或者倒数第二层, 而且最后一层的叶子节点在左边连续,

    倒数第二层的叶子节点在右边连续, 我们就称之为完全二叉树。

    计算二叉树层次示例如下:import java.util.LinkedList;

    import java.util.List;

    public class BinaryTreeDeep

    {

    public static void main(String[] args)

    {

    Tree tree1 = new Tree("1");

    Tree tree2 = new Tree("2");

    Tree tree3 = new Tree("3");

    Tree tree4 = new Tree("4");

    Tree tree5 = new Tree("5");

    Tree tree7 = new Tree("7");

    Tree tree8 = new Tree("8");

    Tree tree9 = new Tree("9");

    Tree tree10 = new Tree("10");

    tree1.setLeft(tree2);

    tree1.setRight(tree3);

    tree2.setLeft(tree4);

    tree3.setRight(tree5);

    tree5.setLeft(tree7);

    tree7.setLeft(tree8);

    tree8.setRight(tree9);

    tree4.setRight(tree10);

    /*

    1

    2    3

    4         5

    10         7

    8

    9

    */

    int deep = getDeep(tree1);

    System.out.println("深度(递归)是" + deep);

    int deep1 = getDeep1(tree1);

    System.out.println("深度(非递归)是" + deep1);

    System.out.println("层次遍历是:");

    levelTraversal(tree1);

    }

    private static int getDeep(Tree root)

    {

    if (null == root)

    {

    return 0;

    }

    if (null == root.getLeft() && null == root.getRight())

    {

    return 1; //如果只有他自己就是1

    }

    int left = 0;

    int right = 0;

    if (null != root.getLeft())

    {

    left = getDeep(root.getLeft());

    }

    if (null != root.getRight())

    {

    right = getDeep(root.getRight());

    }

    int deep = Math.max(left, right) + 1;

    return deep;

    }

    private static int getDeep1(Tree root)

    {

    if (null == root)

    {

    return 0;

    }

    List  nodes = new LinkedList  ();

    ((LinkedList  ) nodes)

    .offer(root);

    int current = 0;

    int deep = 0;

    int levelNodeSize = 0;

    while (nodes.size() > 0)

    {

    levelNodeSize = nodes.size(); //当前层节点的个数

    current = 0;

    while (current 

    {

    Tree tmp = ((LinkedList  ) nodes)

    .poll();

    if (null != tmp.getLeft())

    {

    ((LinkedList  ) nodes)

    .offer(tmp.getLeft());

    }

    if (null != tmp.getRight())

    {

    ((LinkedList  ) nodes)

    .offer(tmp.getRight());

    }

    current++;

    }

    deep++;

    }

    return deep;

    }

    private static void levelTraversal(Tree root)

    {

    List  nodes = new LinkedList  ();

    ((LinkedList  ) nodes)

    .offer(root);

    while (!nodes.isEmpty())

    {

    Tree tmp = ((LinkedList  ) nodes)

    .poll();

    System.out.print(tmp.getRoot() + " ");

    if (null != tmp.getLeft())

    {

    ((LinkedList  ) nodes)

    .offer(tmp.getLeft());

    }

    if (null != tmp.getRight())

    {

    ((LinkedList  ) nodes)

    .offer(tmp.getRight());

    }

    }

    System.out.println("");

    }

    }

    class Tree

    {

    private String root;

    private Tree left;

    private Tree right;

    public Tree(String root)

    {

    this.root = root;

    }

    public String getRoot()

    {

    return root;

    }

    public void setRoot(String root)

    {

    this.root = root;

    }

    public Tree getLeft()

    {

    return left;

    }

    public void setLeft(Tree left)

    {

    this.left = left;

    }

    public Tree getRight()

    {

    return right;

    }

    public void setRight(Tree right)

    {

    this.right = right;

    }

    }

    那么以上就是有关二叉树的所有内容了,如果还想了解更多java一些知识问答那么记得关注本站消息哦,更多精彩内容等你来了解。

    展开全文
  • MYSQLB+Tree索引高度如何计算

    千次阅读 2020-04-24 08:35:37
    先给出一个千万级记录表的索引的高度大概在3-5 举例前先做一下举例时...由于索引树每个节点的大小固定,所以索引KEY越小,B值就越大,那么每个BTREE节点上可以保存更多的索引KEY,也就是B值越大,索引树的高度就越...
  • 小编上课时使用英文教材,所以对中文计算机词汇不是那么了解,所以,这里先表示抱歉。但是,我还是尽量使用中文计算机词汇来表达,这样有助于你们能看...OK,现在就展示如何用C++递归来实现这个问题。//Function prot
  • 二叉树的操作以及完全二叉树的节点计算 (labuladong老师的题目总结) 第一个问题在BST中寻找一个 首先我们普通的寻找就是每个节点都去遍历然后对比目标值,但是这样的复杂度是比较高的,而且没有使用到BST的特点...
  • //在二叉树中如何获得树的深度//方法1:递归算法--先计算出左右子树的深度,之后比较两者之间的大小关系,取大的那个数值,然后将此数值加一后返回//该返回值,即树的深度//方法2:利用队列,每遍历树的一层,就将...
  • 小编先翻译什么是BST (Binary Search Tree),对于中文计算机词汇是二叉搜索,关于这个知识点,小编就不在这里进行解释了,大家还是自行百度吧!或者看看有关数据结构书就知道了。那什么情况节点才是属于叶子节点...
  • 如何计算折半查找平均查找长度?

    万次阅读 2019-04-12 20:52:32
    则,根据二叉树性质,它有最大节点数, 则 (2是底数)。那么二叉树第j层节点数为:2^(j-1),当最后一层也就是j=h 假定每个元素查找概率相等,则,pi=1/n (pi为第i个节点查找概率) 那么平均查找长度为 1/n*(1*...
  • now方案是他所有儿子内部如何分配方案相乘得到 这个可以递归计算 不过对于那么多儿子之间 他们分配走标号可能是不同 比如now将把2,3,4,5分配给他子树,那有可能是2,3;4,5 也有可能是2,4; 3,5这样...
  • 无向连通图生成

    千次阅读 2013-06-24 21:41:22
    对于一个无向连通图来说,它可能有很多生成,那么如何求得它生成呢? 首先给出一个非常一般的计算方法 -- 矩阵行列式法 对于任何一个顶点数为n无向连通图,我们列出一个矩阵。 矩阵规则是: ...
  • 可以这样理解,我们可以去查找根节点的左子树的深度和其右子树的深度,然后比较这两个谁大。如果 左子树的深度大于右子树,那么我们可以把左子树的深度加1就是整个树的深度,相反如果右子树的深度大于左子树的深度...
  • 对于子树问题,我们可以使用树的 DFSDFSDFS 序来解决这个问题,因为树的DFS序可以十分有利的求解子树相关问题。思考这道题如何用 DFSDFSDFS 来解决。 对于平面直角坐标系来说,以节点编号为横纵坐标,我们可以通过...
  • 与二叉树的应用:平衡二叉树平衡二叉树的定义:如何计算高度为h的最小平衡二叉树的节点数N~h~?如何判断一颗为平衡二叉树?平衡二叉树的插入:方法一、LL平衡旋转(右单旋转)方法二、RR平衡旋转(左单旋转)...
  • 树的重心 点分治

    2015-07-15 22:09:00
    树的重心的定义是:最大的子树最小的节点。 为什么要找树的重心呢 因为找到树的重心把他变成根以后,最大的子树的大小不超过n/2,否则如果超过n/2将该子树的根作为重心将会更优。 这样可以保证递归的层不超过...
  • 是数据结构中很重要一部分,一下是建立二叉树,遍历二叉树以及在遍历过程中求每层节点数的样例。 建立二叉树有很多种方法,这里采用类方式来建立。 类私有数据成员包括该节点值,它左儿子以及右儿子。...
  • 可以看出因为是有向无环图所以就可以看成树的形式,然后就是考虑如何计算路径,对于路径,可以考虑解决子结构,把一个子结构解决了,也就解决了整个树。 我们可以计算每一个子根节点下的路径,然后把所有的子...
  • 二叉查找

    2017-10-22 14:27:41
    二叉查找树树在数据结构里面是一种非常自然的数据结构,很多自然和人类社会的现象抽象出来都很自然地形成一棵树....树结构的定义要得出树的定义,我们需要对树进行抽象,可以发现树由节点和连线构成
  • 严格m叉(正则m叉

    千次阅读 2019-11-13 09:40:59
    严格m叉:只有度为0的节点和度为m的节点如何构造正则m叉:首先寻找N0节点的个数与Nm节点的个数之间的关系。 (1)从节点个看:N = N0 + Nm (2)从分支看:N - 1 = mNm 联立两个方程得:(m-1)*Nm = N0-1 ...
  • 一、 数据结构:首先其它的刷完,再反...现在回归正题,如何求一棵完全二叉树的节点呢? // 输入一棵完全二叉树,返回节点总数 int countNodes(TreeNode root); 如果是一个普通二叉树,显然只要向下面这样遍.
  • 决策树的结果类似如下图: 图中方形方框代表叶节点,带圆边的方框代表决策节点,决策节点与叶节点的不同之处就是决策节点还需要通过判断该节点的状态来进一步分类。 那么如何通过训练数据来得到这样的决策树呢? ...
  • 每一层的节点是上一层节点个的2倍; 一般的,第一层是1个节点,第二层是2个节点,第三层是4个节点,以此类推 // 2. 最后一层节点的个数在 1 ~ 2^(L-1), 其中 L 表示最大层 // 综上可知&#...
  • 机器学习之决策

    2018-07-17 16:33:23
    2)效率高,决策树只需要一次构建,反复使用,每一次预测的最大计算次数不超过决策树的深度。 如何切分特征(选择节点) 我们的目标应该是根节点就像一个老大似的能更好的切分数据(分类的效果更好),...
  • 提升GBDT详解

    2018-09-05 15:18:59
    最多叶子节点数 D. loss满足约束条件 2. 如何评估特征权重大小? 答:a. 通过计算每个特征在训练集下信息增益,最后计算每个特征信息增益与所有特征信息增益之和比例为权重值。 b. 借鉴投票机制。用相同...
  • 编译原理中对于表达式管理,前面已经有如何将中缀...因此遇到操作就形成一个叶子节点,并压栈,遇到操作符,则从栈中取两个节点,形成一颗新的树,并进行压栈。最后从栈中取出为最终表达式。 代码如下:

空空如也

空空如也

1 2 3 4 5 ... 12
收藏数 221
精华内容 88
关键字:

如何计算树的节点数