树问题总结

最新推荐文章于 2020-07-13 14:03:00 发布
最新推荐文章于 2020-07-13 14:03:00 发布
阅读量304 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44233369/article/details/99458936
版权

二叉树的结构

class Node<V>{
    V value;
    Node left;
    Node right;
}

1.二叉树的遍历分别是前序、中序、后续、层序遍历。

2.宽度优先遍历（层次遍历）

3.求二叉树的宽度

4.判断搜索二叉树

5.判断平衡二叉树

6.判断完全二叉树

7.判断满二叉树

8. 给定两个节点，找到它们的最低公共祖先节

9. 在二叉树中找到一个节点的后继节点。（j8）

10.寻找一个节点的前驱节点

11.二叉树的序列化和反序列化

12.折纸问题

13.二叉树的镜像

14.判断一个数是不是完全二叉树

15.知道二叉树的先序和中序的遍历结果创建一个树（j7）

判断B是不是A的子结构（j26）

https://blog.csdn.net/snow_5288/article/details/71170904
https://blog.csdn.net/weixin_39411321/article/details/90732295

二叉树的遍历

分别是前序、中序、后续、层序遍历。

//递归实现的前序遍历
    static void preOrderRecur(Node* head){
        if(head == NULL)
            return;
        cout << head->data << " ";
        preOrderRecur(head->left);
        preOrderRecur(head->right);
    }
    //递归实现的中序遍历
    static void inOrderRecur(Node* head){
        if(head == NULL)
            return;
        inOrderRecur(head->left);
        cout << head->data << " ";
        inOrderRecur(head->right);
    }
    //递归实现的后序遍历
    static void posOrderRecur(Node*head){
        if(head == NULL)
            return;
        posOrderRecur(head->left);
        posOrderRecur(head->right);
        cout << head->data << " ";
    }
    //非递归实现的前序遍历
    static void preOrderUnRecur(Node* head){
        if(head == NULL)
            return;
        stack<Node*> s;
        s.push(head);
        while(!s.empty()){
            head = s.top();
            cout << head->data << " ";
            s.pop();
            if(head->right != NULL)
                s.push(head->right);
            if(head->left != NULL)
                s.push(head->left);
        }
    }
    //非递归实现的中序遍历
    static void inOrderUnRecur(Node* head){
        if(head == NULL)
            return;
        stack<Node*> s;
        while(!s.empty()|| head != NULL){
          if(head != NULL){
            s.push(head);
            head = head->left;
          }else{
            head = s.top();
            cout << head->data << " ";
            s.pop();
            head = head->right;
          }
        }
    }
    //非递归实现的后序遍历
    static void posOrderUnRecur_1(Node* head){
    if(head == NULL){
            return;
        }
        stack<Node*> s1;
        stack<Node*> s2;
        s1.push(head);
        while(!s1.empty()){
            head = s1.top();
            s1.pop();
            s2.push(head);
            if(head->left != NULL){
                s1.push(head->left);
            }
            if(head->right != NULL){
                s1.push(head->right);
            }
        }
        while(!s2.empty()){
            cout << s2.top()->data << " ";
            s2.pop();
        }
    }

宽度优先遍历（层次遍历）

    static void breadthFirstTravel(Node* head){
        if(head == NULL){
            return;
        }
        queue<Node*> q;
        q.push(head);
        while(!q.empty()){
            head = q.front();
            cout << head->data << " ";
            q.pop();
            if(head->left != NULL){
                q.push(head->left);
            }
            if(head->right != NULL){
                q.push(head->right);
            }
        }
 
    }

求二叉树的宽度

 //求一颗二叉树的宽度
   static int treeMaxWidth(Node* head){
       if(head == NULL)
           return 0;
       queue<Node*> q;
       map<Node*,int> levelMap;
       q.push(head);
       levelMap[head] = 1;
       int maxWidth = 0;
       int curWidth = 0;
       int curLevel = 0;
       while(!q.empty()){
           head = q.front();
           q.pop();
           if(head->left != NULL){
               q.push(head->left);
               levelMap[head->left] = levelMap.find(head)->second + 1;
               //cout << levelMap.find(head)->second + 1 << " ";
           }
           if(head->right != NULL){
               q.push(head->right);
               levelMap[head->right] = levelMap.find(head)->second + 1;
           }
           if(levelMap.find(head)->second > curLevel){
               curWidth = 0;
               curLevel = levelMap.find(head)->second;
           }else{
               curWidth++;
           }
          // cout << curLevel << ": " << curWidth << endl;
           maxWidth = maxWidth >= curWidth ? maxWidth:curWidth;
       }
       return maxWidth + 1;
   }

二叉树的相关概念及其判断

搜索二叉树

每个节点的值一定大于左子树的最大值（或左子树为空），小于右子树的最小值（或右子树为空）。

	//判断当前二叉树是不是BST树
    bool isBSTtree()
    {
    	BSTNode *pre = nullptr;
    	return isBSTree(_root, pre);
    }
    
	bool isBSTree(BSTNode *node,BSTNode *&pre)	
	{
		if (node == nullptr)
		{
			return true;
		}

		if (!isBSTree(node->_left, pre))
		{
			return false;
		}

		if (pre != nullptr)
		{
			if (node->_data < pre->_data)
			{
				return false;
			}
		}
		pre = node;
		return isBSTree(node->_right, pre);
	}

平衡二叉树：每个节点左子树和右子树的高度相差不超过1.

class Solution {
public:
    bool IsBalanced_Solution(TreeNode* pRoot) {

        if(pRoot==NULL)
            return true;
        int rightDepth=getDepth(pRoot->right);
        int leftDepth=getDepth(pRoot->left);
        if(rightDepth>leftDepth+1||leftDepth>rightDepth+1)
        return false;
        else return IsBalanced_Solution(pRoot->left)&&IsBalanced_Solution(pRoot->right);

    }
     int getDepth(TreeNode* pRoot)
        {
            if(pRoot==NULL)
                return 0;
        int rightDepth=getDepth(pRoot->right);
        int leftDepth=getDepth(pRoot->left);
         return 1+(leftDepth>rightDepth?leftDepth:rightDepth);

        }
};

完全二叉树与满二叉树：

//判断一颗二叉树是不是完全二叉树
    static bool isCompleteBinaryTree(Node* head){
        if(head == NULL)
            return true;
        bool leaf = false;
        queue<Node*> q;
        q.push(head);
        while(!q.empty()){
            head = q.front();
            q.pop();
            if(
               (head->left == NULL && head->right != NULL)
               ||
               (leaf && (head->left != NULL || head->right) != NULL)
               )
                return false;
            if(head->left != NULL){
                q.push(head->left);
            }
            if(head->right != NULL){
                q.push(head->right);
            }
            else{
                leaf = true;
            }
        }
        return true;
    }
 
    //判断一棵树是不是满二叉树
 
class FullBinaryReturnType{
public:
    int height;
    int nodes;
    FullBinaryReturnType(int height,int nodes){
        this->height = height;
        this->nodes = nodes;
       // cout << "init: height(" << this->height << ")  nodes（" << this->nodes << ")" << endl;
    }
};
 
    static FullBinaryReturnType fProcess(Node* head){
        if(head == NULL){
            FullBinaryReturnType res(0,0);
            return res;
        }
        FullBinaryReturnType leftData = fProcess(head->left);
        FullBinaryReturnType rightData = fProcess(head->right);
       // cout << "LH: " << leftData.height << " RH:" << rightData.height << " LN: " << leftData.nodes << " RN: " << rightData.nodes << endl;
        int height = max(leftData.height,rightData.height) + 1;
        int nodes = leftData.nodes + rightData.nodes + 1;
        //cout << head->data << " height:" << height << " nodes:"<< nodes << endl;
        FullBinaryReturnType res(height,nodes);
        return res;
    }
 
    static bool isFullBinaryTree(Node* head){
        FullBinaryReturnType res = fProcess(head);
        return ((1 << res.height) - 1 == res.nodes);
    }

扩展题目：

1. 给定两个节点，找到它们的最低公共祖先节

 static Node* findLowestCommonAncester(Node* head,Node* n1,Node* n2){
        if(head == NULL || head == n1 || head == n2)
            return head;
        Node* l = findLowestCommonAncester(head->left,n1,n2);
        Node* r = findLowestCommonAncester(head->right,n1,n2);
        if(l != NULL && right != NULL){
            return head;
        }
        return l != NULL ? l : r;
    }

2. 在二叉树中找到一个节点的后继节点(j8)中序遍历序列的下一个节点

【题目】 现在有一种新的二叉树节点类型如下:

public class Node {

public int value;

public Node left;

public Node right;

public Node parent;

public Node(int val) { value = val; }

}
在二叉树的中序遍历的序列中， node的下一个节点叫作node的后继节点。

class Solution {
public:
    TreeLinkNode* GetNext(TreeLinkNode* pNode)
    {
        if(pNode==nullptr)
            return nullptr;
        TreeLinkNode* res=nullptr;
        if(pNode->right!=nullptr){
            TreeLinkNode* right=pNode->right;;
            while(right->left!=nullptr)
                right=right->left;
          
            res=right;
        }else if(pNode->next!=nullptr){
            TreeLinkNode* father=pNode->next;
            TreeLinkNode* current=pNode;
            while(father!=nullptr&&current==father->right){
                  current=father;
                  father=father->next;
            }
            res=father;
        }
      return res;
    }
};

3.寻找一个节点的前驱节点

//在二叉树中找到一个节点的前驱节点
    static Node_3* findPreNode(Node_3* node){
        if(node == NULL)
            return NULL;
       // cout << node->data << endl;
        if(node->l != NULL){
            node = node->l;
            while(node->r != NULL && node != NULL)
                node = node->r;
            if(node->l != NULL)
                node = node->l;
            return node;
        }
        else{
            //cout << node->data << endl;
            while(node->parent != NULL && node->parent->r != node){
                node = node->parent;
                //cout << node->data << endl;
            }
 
            return node->parent;
        }
 
    }

3.二叉树的序列化和反序列化

序列化：内存里的一棵树如何转化成字符串形式。

反序列化：从字符串形式变成内存里的树。

 static string serializePreTree(Node* root){
        if(root == NULL)
            return "# ";
        stringstream ss;
        ss << root->data;
        string str = ss.str() + " ";
        str += serializePreTree(root->left);
        str += serializePreTree(root->right);
        return str;
    }
 
    static Node* recnPreOrder(queue<string>& nodeStr){
        string str = nodeStr.front();
        nodeStr.pop();
        if(str == "#"){
            return NULL;
        }
        int data;
        sscanf(str.data(),"%d",&data);
        Node* root = new Node(data);
        root->left = recnPreOrder(nodeStr);
        root->right = recnPreOrder(nodeStr);
        return root;
 
    }
 
    static void split(const std::string& s, std::queue<std::string>& v, const std::string& c)
    {
      std::string::size_type pos1, pos2;
      pos2 = s.find(c);
      pos1 = 0;
      while(std::string::npos != pos2)
      {
        v.push(s.substr(pos1, pos2-pos1));
 
        pos1 = pos2 + c.size();
        pos2 = s.find(c, pos1);
      }
      if(pos1 != s.length())
        v.push(s.substr(pos1));
    }
 
    static Node* recnByPreString(string str){
        queue<string> q;
        string c = " ";
        split(str,q,c);
        return recnPreOrder(q);
    }

这里使用前序遍历的顺序进行序列化。

4.折纸问题

请把一段纸条竖着放在桌子上，然后从纸条的下边向上方对折1次，压出折痕后 展开。 此时折痕是凹下去的，即折痕突起的方向指向纸条的背面。 如果从纸条的下边向上方连续对折2次，压出折痕后展开，此时有三条折痕，从 上到下依次是下折痕、下折痕和上折痕。 给定一个输入参数N，代表纸条都从下边向上方连续对折N次。 请从上到下打印所有折痕的方向。 例如:N=1时，打印: down N=2时，打印: down down up

分析：可以通过实际折纸来寻找规律

当 N = 1： down

当 N = 2： down down up

当 N = 3： down down up down down up up

。。。

可以看出折痕的方向具有一定规律，并且该规律与二叉树十分相似，每一个节点的左子树为 down，右子树为 up。打印结果就是二叉树的中序遍历。

 static void paperFolding (int i,int N,bool down){
        if(i > N){
            return;
        }
        paperFolding(i + 1,N,true);
        cout << (down ? "down " : "up ");
        paperFolding(i + 1,N,false);
    }

5.二叉树的镜像

在这里插入图片描述

递归
void Swap(TreeNode** a,TreeNode** b)
{
    TreeNode* tmp = *a;
    *a = *b;
    *b = tmp;
    return;
}
void TreeMirror(TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    Swap(&root->lchild,&root->rchild);
    TreeMirror(root->lchild);
    TreeMirror(root->rchild);
}

非递归
void TreeMirrorByLoop(TreeNode* root)
{
    if(root == NULL)
    {
        return;
    }
    SeqQueue queue;
    SeqQueueInit(&queue);
    SeqQueuePush(&queue,root);
    TreeNode* cur = NULL;
    while(SeqQueueFront(&queue,&cur))
    {
        //此处的访问相当于交换左右子树
        Swap(&cur->lchild,&cur->rchild);
        SeqQueuePop(&queue);
        if(cur->lchild != NULL)
        {
            SeqQueuePush(&queue,cur->lchild);
        }
        if(cur->rchild != NULL)
        {
            SeqQueuePush(&queue,cur->rchild);
        }
    }
    return;
}

6.判断一个数是不是完全二叉树

完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个节点的二叉树，当且仅当其每个节点都与深度为K的满二叉树中的编号从1至n的节点一一对应时称之为完全二叉树。

完全二叉树具有以下的特点：

1）只允许最后一层有空缺节点且空缺在右边，即叶子节点只能在层次最大的两层上出现；

2）对任一节点，如果其右子树的深度为j，则其左子树的深度必为j或j+1，即度为1

的点只有1个或0个

int IsCompleteTree(TreeNode* root)
{
    if(root == NULL)
    {
        return 0;
    }
    SeqQueue queue;
    SeqQueueInit(&queue);
    SeqQueuePush(&queue,root);
    //是否要进入第二阶段
    int is_step_tow_flag = 0;
    TreeNode* cur = NULL;
    while(SeqQueueFront(&queue,&cur))
    {
        SeqQueuePop(&queue);
        //阶段一走这个分支
        if(is_step_tow_flag == 0)
        {
            if(cur->lchild != NULL && cur->rchild != NULL)
            {
                //同时具备左右子树
                SeqQueuePush(&queue,cur->lchild);
                SeqQueuePush(&queue,cur->rchild);
            }
            else if(cur->rchild != NULL && cur->lchild == NULL)
            {
                //只有右子树，没有左子树，一定不是完全二叉树
                return 0;
            }
            else if(cur->rchild == NULL && cur->lchild != NULL)
            {
                //只有左子树没有右子树，需要进入第二阶段
                is_step_tow_flag = 1;
                SeqQueuePush(&queue,cur->lchild);
            }
            else
            {
                //没有左右子树
                is_step_tow_flag = 1;
            }
        }
        else
        {
            //阶段二分支
            if(cur->lchild == NULL && cur->rchild == NULL)
            {
              break;
            }
            else
            {
                return 0;
            }
        }//结束阶段一和阶段二的判定
    }//循环结束
    //所有节点都遍历完了，此时是完全二叉树
    return 1;
}

7.知道二叉树的先序和中序的遍历结果创建一个树(j7)

class Solution {
public:
    TreeNode* reConstructBinaryTree(vector<int> pre,vector<int> vin) {
        int lenpre=pre.size();
        int lenvin=pre.size();
        if(lenpre==0||lenvin==0)
            return NULL;
        
        TreeNode* root=new TreeNode(pre[0]);
        vector<int>leftpre,leftvin,rightpre,rightvin;
        int rootvalue=pre[0];
        int genlocal=0;
        for(int i=0;i<lenvin;i++){
            if(vin[i]==rootvalue){
                genlocal=i;
                break;
            }           
        }
        for(int j=0;j<genlocal;j++){
            leftpre.push_back(pre[j+1]);
            leftvin.push_back(vin[j]);
        }
        for(int k=genlocal+1;k<lenvin;k++){
            rightpre.push_back(pre[k]);
            rightvin.push_back(vin[k]);
        }
        root->left=reConstructBinaryTree(leftpre,leftvin);
        root->right=reConstructBinaryTree(rightpre,rightvin);
        return root;
    }
};

树的子结构(j26)

class Solution {
public:
    bool HasSubtree(TreeNode* pRoot1, TreeNode* pRoot2)
    {
        bool result=false;
        if(pRoot1!=nullptr&&pRoot2!=nullptr){
            if(pRoot1->val==pRoot2->val){
                result=match(pRoot1,pRoot2);
            }
            if(!result){
                result=HasSubtree(pRoot1->left,pRoot2);
            }
            if(!result){
                result=HasSubtree(pRoot1->right,pRoot2);
            }
        }
        return result;
    }
    bool match(TreeNode* Root1, TreeNode* Root2){
        if(Root2==nullptr)
            return true;
        if(Root1==nullptr)
            return false;
        if(Root1->val!=Root2->val)
            return false;
        return match(Root1->left,Root2->left)&&match(Root1->right,Root2->right);
    }
};
我去前面探探路a
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
树专题经典题目+方法总结
肉丸不肉
03-12 899
一、二叉树（Binary Tree） 1.1 二叉树的遍历题目（前序、后序、中序、层次） 后序遍历 = 删除树中结点 当你删除一个节点时，你将首先删除它的左节点和它的右边的节点，然后再删除节点本身。 层次遍历使用 BFS 实现，利用的就是 BFS 一层一层遍历的特性；而前序、中序、后序遍历利用了 DFS 实现。 前中后序遍历的三种方法：递归、迭代、颜色标记法 层次遍历方法：使用 BFS 进行层...
NOIP树上问题总结
weixin_30493321的博客
09-12 232
这几年考了好几次树上问题： NOIP2012 疫情控制(二分答案+倍增+贪心) NOIP2013 货车运输(最大生成树+倍增) NOIP2014 联合权值(勉强算作树形dp的傻逼题) NOIP2015 运输计划(二分答案+树上差分+最近公共祖先) NOIP2016 天天爱跑步(树上差分+树上倍增) 可以说除了联合权值外都有一定的难度，(关键是我不抄题解一道也做不出来) 去年没考树上的...
一类子树问题的总结
weixin_30336061的博客
03-28 122
以下问题均允许离线，根节点都为1。 prob1 : 一棵有根树，要求线性时间求出任意子树的权值和。 prob2 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的节点的权值和。 prob3 : 一颗有根树，要求O(nlogn)求出与u距离不超过x且在u子树中的不同颜色种类个数，颜色数不超过1E6。 prob4 : 一颗有根数，要求O(nlogn+大常数)求出与u距离不超...
树形问题和更多树
weixin_30376453的博客
06-11 290
----------------siwuxie095 树形问题 在处理计算机中遇到的很多问题时，虽然没有创建出具体的树，但是 整个是以一棵树的形状进行求解的，通常称这类问题为 树形问题 递归法 - 天然的树形性质 由于树这种结构，它的定义具有天然的递...
树问题
qq_36150399的博客
02-09 205
一、哈弗曼树树中所有叶子节点的带权路径之和为该树的带权路径长度和；给定n个节点和他们的权值，以它们为叶子节点构造一棵带权路径长度最小的二叉树，该树即为哈弗曼树。若k中只剩一个节点，该节点即为构造出的哈弗曼树的根节点，所有构造得到的中间节点的权值和即为该哈弗曼树的带权路径和。方法：利用优先队列实现堆数据结构#include&lt;queue&gt; using namespace priority_...
人教版五年级上植树问题总结
01-21
对于植树问题由浅入深的进行总结和归纳。有利于对孩子的辅导和帮助
解读赫夫曼树编码的问题
09-05
赫夫曼树编码是一种高效的前缀编码方法...总结来说，赫夫曼树编码是一种利用树结构优化数据编码的高效算法，通过构建权值最小的二叉树，实现了对数据的高效压缩。在实际应用中，它能够显著减少存储空间，提高传输效率。
大树移植常见问题汇总.docx
11-06
大树移植常见问题汇总.docx
Python基于回溯法子集树模板解决找零问题示例
09-21
通过回溯法和子集树模板，我们可以有效地解决找零问题，寻找最少硬币数量的解。这种方法的关键在于正确地定义冲突检测函数以实现有效的剪枝，以及递归地探索状态空间。在Python中，回溯法实现简洁，易于理解，适用于...
VUE重点问题总结
08-27
VUE重点问题总结 Vue.js 是一种流行的前端框架，具有强大的组件化和响应式编程能力。但是，在使用 Vue.js 时，开发者可能会遇到一些棘手的问题。下面汇总了一些 Vue.js 的重要难点，并提供了详细的解释和代码示例。...
树上处理的问题总结
weixin_30387339的博客
06-20 124
树的直径 也就是树的最长路径的长度 做法 求2次DFS，第一次DFS找到当前距离根节点最远的点(叶节点)，然后以这个点出发再做一次DFS，找到最远的点。可以证明这个距离即是树上的最长路径。 //hdu4607 //树的直径，树上最长的链的顶点的个数 #include <cstdio> #include <cstring> #include <str...
树上问题归纳
weixin_30655569的博客
06-16 317
。 转载于:https://www.cnblogs.com/a-blog-of-taojiayi-2003/p/11032148.html
一类树上问题的总结
weixin_42465242的博客
01-03 185
目录 方法一 优点 缺点 方法二 优点 缺点 例题： - CF70E Information Reform - P3267 [JLOI2016/SHOI2016]侦察守卫 ...
总结一些树的问题
qq_34471804的博客
11-20 188
#965. Univalued Binary Tree 用DFS来解决这个问题，如果根存在，就把节点的值放在数组中，然后继续遍历它的左右子节点。最后判断数组中元素是否都相等就可以了。相同就是独一无二的树。 function dfs(root,val) { if(root) { val.push(root.val); dfs(root.left,val);...
树的重心---解释和模板
bensanhuan的博客
07-13 562
树的重心 使用背景： 对一颗无根树，求重心.(当然，对一棵树，究竟是有根还是无根，完全自己说了算)， 感性定义： 作为根时，能使各子树节点数目"均衡"的节点。 明确定义： 设f(x)f(x)f(x)表示节点xxx为根时，所有子树中的最大子树节点数。f(x)f(x)f(x)最小的节点即这颗无根树的重心。 性质： 以树的重心为根时，所有子树的大小都不超过整棵树大小的一半。 树中所有点到某个点的距离和中，到重心的距离和是最小的；如果有两个重心，那么到它们的距离和一样。 把两棵树通过一条边相连得到一棵新的树，那么
2020.02.06日常总结——树上问题
ZHUYINGYE_123456的博客
02-06 304
树上dp\color{green}{树上dp}树上dp 顾名思义，即树上的dp问题。 有两种转移方式：一是从根转移到叶子，二是从叶子转移到根。在实际应用中，从叶子转移到根的方式应用的更多。 树上dp在实现起来的时候，可能需要配合贪心等其它高效的算法，甚至于线段树等高效数据结构。 代码实现起来的时候，常常用递归实现，因为树的定义就是递归定义的。同时，一定要注意不要从一个点又转移回了它的父亲，否则，...
树上问题
Yangxiansen——Nextdoor
10-03 743
树 树的存储 无根树 有根树 无根树转有根树 有根树转无根树 树上的路径长度 树的直径 树的中心 树上两点间距离 查询 kkk 级祖先 树上动态规划 有根树求 LCALCALCA 暴力 记忆化暴力 倍增 ...
洛谷【图论2-1】基础树上问题做题总结
weixin_45677913的博客
03-31 394
原题单连接：【图论2-1】基础树上问题 这两天写了一下洛谷基础树上题单，小小的做一个总结，不然又忘了，收获还是有的，还有两题没写，一题是原来再牛客看题解做过了，还有一题（P5666 树的重心）感觉有点难，后面再补，感觉自己做的题型还是太少了，慢慢来吧。 P5836 [USACO19DEC]Milk Visits S 这道题应该是最简单的一题吧，把两种牛所在的节点赋予0或者1权值，统计路径和然后与询...
树上分治：总结和理解
limn204的专栏
10-28 345
所以树上分治是什么呢？树上分治是解决一类树上路径计数的问题。 举个例子，我现在要知道树上有多少条路的距离小于等于K。 如果直接取点判断肯定是不行的，我们考虑一条路径，肯定有两种可能，一个是经过根节点，或者不在根节点。那我们就可以先找一个根节点，将一颗树转化成一个有根树。然后我们对以这点为中心，计算有多少个符合的路径。当然这一次计算会发现把子树上的也算进去了。删掉这个点，然后我们再遍历所有的子树，先...
问题树课程开发模型 ppt 22.ppt
05-05
问题树课程开发模型 ppt 22.ppt

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值