精华内容
下载资源
问答
  • <p>#include<iostream>  using namespace std; const int DefaultSize = 10; using namespace std; template<class E> class MinHeap ...}</p>...
  • 有一个问题 怎么确保红黑树的根节点总是黑色的?用的是C语言,节点定义是 struct rbt_node{ char *key; char color; rbt left; rbt right;...根节点是红色的应该也不影响功能实现,但是还是想看看怎么
  • 现在知道树中内节点的指针,怎么查找到从节点的路径呢? 看到网上大体有两种方法,一种是递归的方法,另外一种是非递归的方法。   方法一:递归二叉树 出自:...

    最近在看二叉树的时候会突然想到,如果知道二叉树的结构,以及二叉树的结构。现在知道树中内节点的指针,怎么查找到从根到节点的路径呢?

    看到网上大体有两种方法,一种是递归的方法,另外一种是非递归的方法。

     

    方法一:递归二叉树 出自:http://blog.csdn.net/hhygcy/article/details/4660362

    bool nodePath (bstNode* pRoot, int value, std::vector<bstNode*>& path)  
    {  
        if (pRoot==NULL) return false;  
        if (pRoot->data!=value)  
        {  
            if (nodePath(pRoot->pLeft,value,path))  
            {  
                path.push_back(pRoot);  
                return true;  
            }  
            else  
            {  
                if (nodePath(pRoot->pRight,value,path))  
                {  
                    path.push_back(pRoot);  
                    return true;  
                }  
                else  
                    return false;  
            }  
        }  
        else  
        {  
            path.push_back(pRoot);  
            return true;  
        }  
    }  
    

    其中上面的path是用来记录从节点到根走过的节点路径的。如果想求根到节点的路径,只需要将vector中的元素进行转置就可以了。上面的程序也可以通过使用一个栈保存路径,下面介绍的非递归的方式将使用这种方法。

    void reverse(vector<bstNode*> &v){
    	int length = v.size();
    	bstNode *temp;
    	for (int i = 0; i < length / 2; ++i){
    		temp = v[i];
    		v[i] = v[length-i-1];
    		v[length-i-1] = temp;
    	}
    }

     

    ps:可以将此方法用更简洁的方式写出。出自:http://bbs.ffsky.com/showtopic-1693038.aspx

    bool find(BT *p,char c)
    
    {
    
        return p&&(p->data==c||find(p->lchild,c)||find(p->rchild,c))?true:false;
    
    }
    
    


     

    方法二:模拟程序的递归,使用非递归的方法求取路径

    void Find_Node(BiTNode *r , const TElemType& ch)   
    {   
        stack_bit s;   
        BiTNode *p , *q;   
        s.push(r);   
        while (!s.empty())   
        {   
            p = s.top();   
            if (p->lchild == 0 && p->rchild == 0)   
            {   
                if (p->data == ch)   
                {   
                    PrintStack(s);   
                    break;   
                }   
                else   
                {   
                    s.pop();   
                    while ((q = s.top()) && (q->data != ch) &&    
                           (q->lchild != p) && (q->rchild != p))   
                    {   
                        s.pop();   
                    }   
                    if (q->data == ch)   
                    {   
                        PrintStack(s);   
                        break;   
                    }   
                    else if (q->lchild == p && q->rchild != 0)   
                    {   
                        s.push(q->rchild);   
                    }    
                    else   
                    {   
                        while ((q->rchild == 0 || q->rchild == p) && (q->data != ch))   
                        {   
                            p = q;   
                            s.pop();   
                            q = s.top();   
                        }   
                        if (q->data == ch)   
                        {   
                            PrintStack(s);   
                            break;   
                        }   
                        else if (q->rchild != 0)   
                        {   
                            s.push(q->rchild);   
                        }   
                    }   
                }   
            }   
            else   
            {   
                if (p->lchild != 0)   
                {   
                    s.push(p->lchild);   
                }   
                else if (p->rchild != 0)   
                {   
                    s.push(p->rchild);   
                }   
            }   
        }   
    }  
       
    void PrintStack(stack_bit &sa)   
    {   
        BiTNode *p;   
        stack_bit sb;   
        while (!sa.empty())   
        {   
            p = sa.top();   
            sb.push(p);   
            sa.pop();   
        }   
        while (!sb.empty())   
        {   
            p = sb.top();   
            cout<<(p->data);   
            sa.push(p);   
            sb.pop();   
        }   
        cout<<endl;   
    }   
    void Print_Path()   
    {   
        char ch;   
        cout<<"Please type in the value of the node:";   
        cin>>ch;   
        Find_Node(root , ch);   
    }   
       

     

     

    扩展:

    输出所有根到叶节点的路径。

    void printpath(node *root, vector<int> path){
    	if (root){
    		path.push_back(root->key);
    		if (root->left == NULL && root->right == NULL){
    			for (int i = 0; i < path.size(); ++i){
    				cout << path[i] << " ";
    			}
    			cout << endl;
    			return ;
    		}
    		else {
    			printpath(root->left, path);
    			printpath(root->right, path);
    		}
    	}
    }
    
    
    展开全文
  • 数据是后台接口动态获取的,对取出来的数据进行了树的初始化,初始化结束后默认展开根节点数据,然后问题就来了,不管怎么根节点数据就是展不开,然后就开始了我的漫长调查过程… 下面是我...

    今天解决了一个非常尴尬的问题,纠结了整整半个月,最后还是被自己没有仔细看文档给打败了。
    具体的事情是这样的,我们的需求是实现可复选的树结构,因为要适配IE8,纠结了很久之后最后决定使用z-tree,适配性又高速度又快。数据是后台接口动态获取的,利用取出来的数据进行树的初始化,初始化结束后默认展开根节点,再然后问题就来了,不管怎么弄根节点数据就是展不开,然后就开始了我的漫长调查过程…
    下面是我的节点展开代码

    FormioUtils.getDataFromUrl(
        Formio.getBaseUrl() + initPath,
        {},
        'post',
        ''
    ).then(function (res) {
        if(res.errorcode == "0"){
            // 初始化ztree组件
            var zTreeObj = $.fn.zTree.init($("#depTree"), setting, res.data);
               zTreeObj.expandNode(res.data[0],true, false, false);
        } else {
            FormioUtils.updateMessage({
                type: 'warning',
                text: res.msg,
                time: 2000
            }, Messager);
        }
    });
    

    整个调查问题的辛酸历程

    1. 最开始怀疑是参数配置问题,然后各种更改配置的true,false,然而没有任何作用
    2. 怀疑拼写错误,又从官网上重新copy了一遍源码,发现没有任何变化
    3. 尝试使用expandAll方法,发现可行,怀疑是expandNode方法使用的问题,
    4. 尝试在单击节点数据时使用expandNode方法测试无问题,然后我就纠结是不是树组件初始化没有结束我就展开节点,因此才不执行失效的,所以就在初始化树结构之后加了延迟,然后实测失败…
    5. 然后该问题就搁置了…
    6. 经过了半个月的主体功能开发结束之后,我回首又看这个问题,在看完官方文档上了个厕所回来之后,茅塞顿开…
    7. 下面是官方文档说明,问题点我重点圈出来了,告诫自己以后一定要认真看文档,然后去个厕所,问题可能就解决了~~
      在这里插入图片描述
    8. 问题原因分析:
      官方其实有红字标明【请通过 zTree 对象执行此方法】,所以从后台取出来的数据不能直接使用,需要先通过主key从树结构中取出当前节点数据,然后再执行expandNode方法就可以了。
      下面是修改后的代码!!!
    FormioUtils.getDataFromUrl(
        Formio.getBaseUrl() + initPath,
        {},
        'post',
        ''
    ).then(function (res) {
        if(res.errorcode == "0"){
            // 初始化ztree组件
            var zTreeObj = $.fn.zTree.init($("#depTree"), setting, res.data);
            var node = zTreeObj.getNodeByParam("id",res.data[0].id,null);
               zTreeObj.expandNode(node,true, false, false);
        } else {
            FormioUtils.updateMessage({
                type: 'warning',
                text: res.msg,
                time: 2000
            }, Messager);
        }
    });
    
    展开全文
  • 首先一个n个节点二叉树的度n-1,从下往上,因为除了根节点以为每个节点都有一个入度 设n个节点中 有x个非叶子节点和y个叶子节点,x+y =n ,从上往下,所有的非叶子节点都有两个出度,叶子节点没有-》2x = n-1 = ...

    首先公式都是for (int i = arr.length/2 -1; i >= 0; i–) 其中arr.length/2 -1代表的非叶子节点的索引,推导过程
    在这里插入图片描述

    1. 首先一个n个节点二叉树的度n-1,从下往上看,因为除了根节点以为每个节点都有一个入度
    2. 设n个节点中 有x个非叶子节点和y个叶子节点,x+y =n ,从上往下看,所有的非叶子节点都有两个出度,叶子节点没有-》2x = n-1 = x+y-1->x=y-1
    3. 从上面式子可知道 非叶子节点比叶子节点少一个,而int型在在进行除法时会自动去除小数点,所以arr.leng /2 就类似于(n-1)/2 而这是数组下标,都需要减一,所以int i = arr.length/2 -1
    展开全文
  • 决策树在预测时总是返回根节点的信息,怎么返回相应叶子节点的信息。 ``` def classifer(Tree, testVec): """ 输入:决策树,分类标签,测试数据 输出:决策结果 """ if Tree.results == None: if ...
  • 情况一:最大距离可能一个在左子树,一个在右子树中,通过根节点; 情况二:也可能出现在左/右子树中,不经过根节点。 大体就是这样,我们要如何来解决呢? 给大家看看《编程之美》中它是如何决解的...

    一说到二叉树,就有很多题目,今天在编程之美中看到了二叉树中两个节点最远的距离。所以给想借机写一篇博客。

    在开始之前,我们先想想,两个最常节点的最远距离是怎么样的?

    情况一:最大距离可能一个在左子树,一个在右子树中,通过根节点;


    情况二:也可能出现在左/右子树中,不经过根节点。


    大体就是这样,我们要如何来解决呢?


    给大家看看《编程之美》中它是如何决解的:

    <span style="font-size:24px;">// 数据结构定义
    struct NODE
    {
        NODE* pLeft;        // 左子树
        NODE* pRight;       // 右子树
        int nMaxLeft;       // 左子树中的最长距离
        int nMaxRight;      // 右子树中的最长距离
        char chValue;       // 该节点的值
    };
     
    int nMaxLen = 0;
     
    // 寻找树中最长的两段距离
    void FindMaxLen(NODE* pRoot)
    {
        // 遍历到叶子节点,返回
        if(pRoot == NULL)
        {
            return;
        }
     
        // 如果左子树为空,那么该节点的左边最长距离为0
        if(pRoot -> pLeft == NULL)
        {
            pRoot -> nMaxLeft = 0; 
        }
     
        // 如果右子树为空,那么该节点的右边最长距离为0
        if(pRoot -> pRight == NULL)
        {
            pRoot -> nMaxRight = 0;
        }
     
        // 如果左子树不为空,递归寻找左子树最长距离
        if(pRoot -> pLeft != NULL)
        {
            FindMaxLen(pRoot -> pLeft);
        }
     
        // 如果右子树不为空,递归寻找右子树最长距离
        if(pRoot -> pRight != NULL)
        {
            FindMaxLen(pRoot -> pRight);
        }
     
        // 计算左子树最长节点距离
        if(pRoot -> pLeft != NULL)
        {
            int nTempMax = 0;
            if(pRoot -> pLeft -> nMaxLeft > pRoot -> pLeft -> nMaxRight)
            {
                nTempMax = pRoot -> pLeft -> nMaxLeft;
            }
            else
            {
                nTempMax = pRoot -> pLeft -> nMaxRight;
            }
            pRoot -> nMaxLeft = nTempMax + 1;
        }
     
        // 计算右子树最长节点距离
        if(pRoot -> pRight != NULL)
        {
            int nTempMax = 0;
            if(pRoot -> pRight -> nMaxLeft > pRoot -> pRight -> nMaxRight)
            {
                nTempMax = pRoot -> pRight -> nMaxLeft;
            }
            else
            {
                nTempMax = pRoot -> pRight -> nMaxRight;
            }
            pRoot -> nMaxRight = nTempMax + 1;
        }
     
        // 更新最长距离
        if(pRoot -> nMaxLeft + pRoot -> nMaxRight > nMaxLen)
        {
            nMaxLen = pRoot -> nMaxLeft + pRoot -> nMaxRight;
        }
    }</span>

    这段代码有几个缺点:
    1.算法加入了侵入式(intrusive)的资料nMaxLeft, nMaxRight
    2.使用了全局变量 nMaxLen。每次使用要额外初始化。而且就算是不同的独立资料,也不能在多个线程使用这个函数
    3.逻辑比较复杂,也有许多 NULL 相关的条件测试。

    而,我想了想,写出了这样的代码:

    <span style="font-size:24px;">void _FindMaxDis(BSTreeNode *pNode, int &deepth, int &maxdis)    //这里的两个数,我都用的是引用,读者知道为什么? 
    {  
        if (pNode==NULL)  
        {  
            deepth=0;maxdis=0;  
            return;  
        } </span>
    <span style="font-size:24px;">    int l_deepth=0,r_deepth=0;  
        int l_maxdis=0,r_maxdis=0;  
      
        if (pNode->m_pleft)  
            FindMaxDis(pNode->m_pleft,l_deepth,l_maxdis);  
        if (pNode->m_pright)  
            FindMaxDis(pNode->m_pright,r_deepth,r_maxdis);  
      
        deepth = (l_deepth > r_deepth ? l_deepth : r_deepth) + 1;  
      
        maxdis = l_maxdis > r_maxdis ? l_maxdis : r_maxdis ;  
      
        maxdis = (l_deepth+r_deepth) > maxdis ? (l_deepth+r_deepth) : maxdis;  
      
    }</span>
    <span style="font-size:24px;">  
    int FindMaxDis(BSTreeNode *pNode)  
    {  
        int deepth, maxdis;  
        _FindMaxDis(pNode,deepth,maxdis);  
      
        return maxdis;  
    }  </span>
    其实做做这个题,大体思路都是一致的。但是,我们要考虑很多。在这个方面,推荐读者去看看《代码大全》

    我来说一说这个代码的好处吧。

    提高了可读性,另一个优点是减少了 O(节点数目) 大小的侵入式资料,而改为使用 O(树的最大深度) 大小的栈空间。


    本博文只是对二叉树中两个节点最远的距离的解法,做了粗略的概述,如有更好的解法或者不同的看法,请留言。

    展开全文
  • 当一个HTML元素上产生一个事件时,该事件会在DOM树中元素节点与根节点之间按特定的顺序传播,路径所经过的节点都会收到该事件,这个传播过程就是DOM事件流。 JS冒泡事件:当一个元素上的事件被触发的时候,比如说...
  • 那么由上面两条性质,可以知道:前序序列判父子关系,中序序列判左右子树,我们可以将前序序列和中序序列各分成三部分来:第一部分,根节点元素;第二部分,根节点左子树;第三部分,根节点右子树。于是递归就可以...
  • I-2019 换dp

    2019-11-14 23:18:19
    题解:首先你要知道怎么求固定,用树形dp写出,可以仿照这类题的解法,设dp[i][j]代表节点i权值为j%2019的点的个数,然后换dp。这个换dp跟我之前写的不完全一样,建议代码学习一下。 #include<bits/stdc++...
  • 前序:根节点->左子树->右子树 中序:左子树->根节点->右子树 后续:左子树->右子树->根节点 这么肯定很迷茫,下面以一个例子加深理解: 现在一步步写出3种遍历结果(笔者自己的理解语言逻辑)...
  • 衍生问题:include 为什么不能作为xml资源布局的根节点?merge 为什么作为xml资源布局的根节点?先来setContentView里的 mLayoutInflater.inflate(layoutResID, mContentParent)方法@Override public void setC
  • ``` #include #include using namespace std; //#define MaxValue 10000; //初始设定的权值最大值 //#define MaxBit 4;...输入规定好个数的字符后和权值后就停止运行了,无法继续,怎么改啊,求大家帮忙啊
  • 结果可以显示树的根节点和一级节点,但是在打开二级节点的时候失败.一直在loading... 并出现错误: Object expected. 虽然是0分,还是希望各位大大帮忙下. action直接打印的String如下: [code="java"] [ {id: ...
  • 所以不管怎么说那群切掉这题的大佬是不会这篇博客的所以我要开始自嗨了。 这题,明显是树dp啊。只不过出题人想你发疯,询问二合一了而已。 对于给出了a数组要求b数组的询问,想象一下怎么求。 你先yy一棵树,...
  • 1.左子树的所有结点 都 小于 根节点 2.右子树的所有结点 都 大于 根节点 3.左右子树本身也是一颗 二叉排序树 那么很明显,这是递归的定义,根据上述定义,我们可以很轻松的画出一颗二叉排序树来。 那么我们该怎么画...
  • 如果把第一个文件夹看作是树的根节点的话,下面的子文件夹就可以看作一个子节点。不过最终我们寻找的还是文件夹中的文件,文件可以看做是叶子节点。下面我们介绍一种模式,与这种树级结构息息相关。当然,今天的主角...
  • 红黑树 都可以这么细?面试官还能怎么说.

    千次阅读 多人点赞 2021-05-21 22:19:42
    根节点是黑色的; 如果一个节点是红色的,则它的两个孩子结点是黑色的; 对于每个结点,从该结点到其所有后代叶结点的简单路径上,均包含相同数目的黑色结点; 每个叶子结点都是黑色的(此处的叶子结点指的是空结点); ...
  • 机器人发射子弹已经完成了,下面看看怎么给玩家设置障碍....从控件库拖入一个CCNodeColor节点,称为其根节点的子节点.按照喜好装饰外观,同时打开物理对象,物理类型为静态:新建Levels文件夹,在其中建立Level.c
  • 前言 我们今天接着来一道关于二叉树的算法题,关于二叉树的深度。 题目 输入一棵二叉树,求该树的深度。...这里用递归,如果当前节点没有左右节点,就返回当前节点,如果有左右节点,就返回左右节点的...
  • 我想二叉排序树结构的起源一定是来源于生活,二叉树只有一个根节点,每个节点最多有两个子节点,并且左边的子节点一定小于该节点,右边的子节点一定大于该节点。 二叉查找树的前提是数据是有序的,假如我要查找0002...
  • 二叉搜索树的定义是左孩子节点永远比根节点小,右孩子节点永远比根节点大。比如这个二叉树就是一个二叉搜索树,它的后序遍历为 15 30 20 70 60 50。后序遍历的原则是从左孩子节点到右孩子节点最后到根节点,因此最后...
  • 不同的二叉搜索树(动态规划)1. 题目描述2. 题目分析3. C语言实现4. Python实现 1. 题目描述 难度:中等 2. 题目分析 ...现在我们来看看怎么用动态规划来解决这个问题: 动态规划 动态规划的解决思路是...
  • 二叉树的概念:每一个根节点最多只有两个子节点,也就是只有左右节点两个,再把根节点的左右节点作为子根节点进行沿拓。 大致的图形如下: 对于左边,每一个根节点只存在0个或2个子节点,这..
  • 我们要把哪个当做根节点呢 我们应该把pid=1的当做根节点 第一步我们登录进来肯定是要先查询这些菜单 所以首先要加一个查询方法 即要去在增加查询订单方法,修改下面的两个文件即dao层(在SSM里面dao层就是这两个...
  • 问题二:当传递根节点 为多节点怎么处理? 问题三:传递节点是否为叶子节点的处理 。。。 等等等等 不一一列表,下面用详细代码解释: 话不多说,先结果,为了方便查看,都打印的JSON格式: 单根节点的处理 多...
  • 首先我们需要知道二叉树后序遍历序列的特点:最后一个节点为根节点,去掉根节点的话,可以把s列分为两部分,左边那部分所有节点值都比根节点小,右边那部分都比根节点大。下面看怎么解决这个题: 首先判断这棵树...

空空如也

空空如也

1 2 3 4 5 ... 18
收藏数 351
精华内容 140
关键字:

根节点怎么看