刷题记录（树）

0二叉树

0.1二叉树的种类

0.1满二叉树

满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。

0.2 完全二叉树

完全二叉树：除最后一层外，其余层全部铺满；且最后一层向左停靠

• 如果根节点的左子树深度等于右子树深度，则说明左子树为满二叉树
  
• 如果根节点的左子树深度大于右子树深度，则说明右子树为满二叉树
  

优先级队列其实是一个堆，堆就是一棵完全二叉树，同时保证父子节点的顺序关系

0.3 二叉搜索树

而二叉搜索树是有数值的了，二叉搜索树是一个有序树。（二叉搜索树的中序遍历一定是递增序列）

• 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
• 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
• 它的左、右子树也分别为二叉排序树
  

0.4 平衡二叉搜索树（AVL树）

性质：平衡+搜索

C++中map、set、multimap，multiset的底层实现都是平衡二叉搜索树，所以map、set的增删操作时间时间复杂度是logn，注意我这里没有说unordered_map、unordered_set，unordered_map、unordered_map底层实现是哈希表。

0.2二叉树的存储方式

链式存储：

顺序存储：

0.3二叉树的遍历方式

二叉树主要有两种遍历方式：

• 深度优先遍历（DFS）：先往深走，遇到叶子节点再往回走。
• 广度优先遍历(BFS)：一层一层的去遍历。
  深度优先遍历：
• 前序遍历（递归法，迭代法）——DLR
• 中序遍历（递归法，迭代法）——LDR
• 后序遍历（递归法，迭代法）——LRD
  广度优先遍历：
• 层次遍历（迭代法）
  
  前序：✓

    vector<int> preorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        stack<TreeNode*> st;
        st.emplace(root);
        while (!st.empty()) {
            TreeNode* cur = st.top();
            if (cur) {
                st.pop();               
                if (cur->right) st.emplace(cur->right);
                if (cur->left) st.emplace(cur->left);
                st.emplace(cur);
                st.emplace(nullptr);
                
            }
            else {
                st.pop();
                cur = st.top();
                res.emplace_back(cur->val);
                st.pop();
            }
        }
        return res;
    }

中序：✓

    vector<int> inorderTraversal(TreeNode* root) {
        if (!root) return {};
        vector<int> res;
        stack<TreeNode*> st;
        st.emplace(root);
        while (!st.empty()) {
            TreeNode* cur = st.top();
            if (cur) {
                st.pop();
                if (cur->right) st.emplace(cur->right);
                st.emplace(cur);
                st.emplace(nullptr);
                if (cur->left) st.emplace(cur->left);
            }
            else {
                st.pop();
                cur = st.top();
                st.pop();
                res.emplace_back(cur->val);
            }
        }
        return res;
    }

后序：✓

    vector<int> postorderTraversal(TreeNode* root) {
       if (!root) return {};
        vector<int> res;
        stack<TreeNode*> st;
        st.emplace(root);
        while (!st.empty()) {
            TreeNode* cur = st.top();
            if (cur) {
                st.pop();
                st.emplace(cur);
                st.emplace(nullptr);
                if (cur->right) st.emplace(cur->right);
                
                if (cur->left) st.emplace(cur->left);
            }
            else {
                st.pop();
                cur = st.top();
                st.pop();
                res.emplace_back(cur->val);
            }
        }
        return res;
    }

层序：✓

    vector<vector<int>> levelOrder(TreeNode* root) {
        if (!root) return {};
        vector<vector<int>> res;
        queue<TreeNode*> q;
        q.emplace(root);
        while (!q.empty()) {
            int n = q.size();
            vector<int> temp;
            for (int i = 0; i < n; ++i) {                
                TreeNode* cur = q.front();
                q.pop();
                temp.emplace_back(cur->val);
                if (cur->left) q.emplace(cur->left);
                if (cur->right) q.emplace(cur->right);
            }
            res.emplace_back(temp);
        }
        return res;
    }

层序（从下到上）:先用一个栈stack<vector<int>> st;来存放每一层的数组，最后用一个二维数组接受它

    vector<vector<int>> levelOrderBottom(TreeNode* root) {
        if (!root) return {};
        vector<vector<int>> res;
        stack<vector<int>> st;
        queue<TreeNode*> q;
        q.emplace(root);
        while (!q.empty()) {
            int n = q.size();
            vector<int> temp;
            for (int i = 0; i < n; ++i) {                
                TreeNode* cur = q.front();
                q.pop();
                temp.emplace_back(cur->val);
                if (cur->left) q.emplace(cur->left);
                if (cur->right) q.emplace(cur->right);
            }
            st.emplace(temp);
        }      
        while (!st.empty()) {
            res.emplace_back(st.top());
            st.pop();
        }

        return res;
    }

层序（从下到上，从右到左）: 先用一个栈来存放每一层的数组+先放cur->right

BFS总共有两个模板：

• 如果不需要确定当前遍历到了哪一层，BFS模板如下。

while queue 不空：
    cur = queue.pop()
    for 节点 in cur的所有相邻节点：
        if 该节点有效且未访问过：
            queue.push(该节点)

• 如果要确定当前遍历到了哪一层，BFS模板如下。

level = 0
while queue 不空：
    size = queue.size()
    while (size --) {
        cur = queue.pop()
        for 节点 in cur的所有相邻节点：
            if 该节点有效且未被访问过：
                queue.push(该节点)
    }
    level ++;

0.4二叉树的定义

struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

1翻转二叉树(二叉树的镜像)✓

思路：每一个节点的左右孩子翻转一下，就可以达到整体翻转的效果

    TreeNode* invertTree(TreeNode* root) {
        if (!root) return nullptr;
        queue<TreeNode* > q;
        q.emplace(root);
        while (!q.empty()) {
            TreeNode* cur  = q.front();
            swap(cur->left, cur->right);
            q.pop();
            if (cur->left) q.emplace(cur->left);
            if (cur->right) q.emplace(cur->right);
        }
        return root;
    }

2合并二叉树✓

-1 若root1不存在返回root2，若root2不存在返回root1

• 2 BFS，保持队列永远同时是两个一起入，两个一起出，令cur1->val += cur2->val;
• 3 若root1和root2左右子树都存在，并送入队列(不能在这里加，因为根节点会漏掉)
• 4 若root1的左右子树不存在且root2左右子树都存在，令root1的左右子树等于root2左右子树，
  3和4顺序不能换，因为4会赋值，会影响3.

    TreeNode* mergeTrees(TreeNode* root1, TreeNode* root2) {
        if (!root1) return root2;
        if (!root2) return root1;
        queue<TreeNode*> q;
        q.emplace(root1);
        q.emplace(root2);
        while (!q.empty()) {
            TreeNode* cur1 = q.front();
            q.pop();
            TreeNode* cur2 = q.front();
            q.pop();
            cur1->val += cur2->val;
           
            if (cur1->left and cur2->left) {
                q.emplace(cur1->left);
                q.emplace(cur2->left);
            }
            if (cur1->right and cur2->right) {
                q.emplace(cur1->right);
                q.emplace(cur2->right);
            }
            if (!cur1->left and cur2->left) cur1->left = cur2->left;
            if (!cur1->right and cur2->right) cur1->right = cur2->right;
        }
        return root1; 
    }

3对称二叉树

比较左子树的左节点和右子树的右节点，左子树的右节点和右子树的左结点，首先要看他们是否是成对存在，存在再比较值是否相同。最开始push进去的应该是root->left和root->right

4二叉树的最大深度

二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
思路一：层序遍历，每遍历一层深度++

5二叉树的最小深度

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
叶子节点是指没有子节点的节点。
思路一：层序遍历，每遍历一层深度++，若该层的某个节点没有左右子树，则return

6 二叉树的右视图

层序遍历统计每一层最后一个元素

7 每个树行找最大值

层序遍历统计每一层所有值

8二叉树的层平均值

层序遍历计算每一层所有值的和，除以每层的个数

9平横二叉树（AVL树）

性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

• 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
• 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。
  思路:先定义一个获取节点高度的函数(后序，高度=该节点的最大深度)，遍历二叉树，看每个点的左右子树高度差是否为一

10 完全二叉树的节点个数

思路1：层序遍历，统计每一层元素的个数
思路2：利用完全二叉树的性质。若左子树深度等于右子树深度，说明左子树是满二叉树，节点个数为2的left_levels次方-1，只需要统计右子树的节点个数。同理若左子树深度大于右子树，则说明右子树是满二叉树
5<<6表示5*2的6次方
完全二叉树的深度：

int countLevels(TreeNode* root) {
        int levels = 0;/=0根节点处深度为0，=1根节点处深度为1
        while (root) {
            root = root->left; levels += 1;
        }
        return levels;
    }
int left_levels = countLevels(root->left);
int right_levels = countLevels(root->right);

11 二叉树的所有路径

层序，累加每一层的路径

12 路径总和

每个节点为上层和自己的累加和，若等于targetsum就返回true

13 从中序与后序遍历序列构造二叉树

后序遍历特点：最后一个必定是根节点。
中序遍历特点：根结点左边就是左子树结点，右边就是右子树结点
思路一（？）：
迭代法是一种非常巧妙的实现方法。迭代法的实现基于以下两点发现。

• 如果将中序遍历反序，则得到反向的中序遍历，即每次遍历右孩子，再遍历根节点，最后遍历左孩子。
• 如果将后序遍历反序，则得到反向的前序遍历，即每次遍历根节点，再遍历右孩子，最后遍历左孩子。

eg：

    3
   / \
  9  20
 / \   \
15 10   7
       / \
      5   8
           \
            4
inorder = [15, 9, 10, 3, 20, 5, 7, 8, 4]
postorder = [15, 10, 9, 5, 4, 8, 7, 20, 3]   

    TreeNode* buildTree(vector<int>& inorder, vector<int>& postorder) {
        int pos = inorder.size() - 1;
        return dfs(inorder, postorder, pos, 0, inorder.size() - 1);

    }
    TreeNode* dfs(vector<int>& inorder, vector<int>& postorder, int& pos, int l, int r) {
        if (pos < 0) return 0;
        TreeNode* root = new TreeNode(postorder[pos]);
        int i;
        for (i = l; i < r; ++i) {
            if (inorder[i] == postorder[pos]) break;
        }
        if (i + 1 <= r) root->right = dfs(inorder, postorder, --pos, i + 1, r);
        if (i -1 >= l) root->left = dfs(inorder, postorder, --pos, l, i - 1);
        return root;
    }

思路二：同前序与中序，只是后序最后才是根节点，所以需要pos–,且需要先递归完右子树再递归左子树。

14 从前序与中序遍历序列构造二叉树

思路：用pos记录当前的根节点，然后在中序划分左右子树，先递归完左子树后右子树

 TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
        int pos = 0;
        return bt(preorder, inorder, pos, 0, preorder.size()-1);
    }
    TreeNode* bt(vector<int>& preorder, vector<int>& inorder, int& pos, int left, int right) {
        if (pos >= preorder.size()) return 0;
        TreeNode* root = new TreeNode(preorder[pos]);
        int i;
        for (i = left; i <= right; ++i) {
            if (inorder[i] == preorder[pos]) break;
        }
        if (i - 1 >= left) root->left = bt(preorder, inorder, ++pos, left, i-1);
        if (i + 1 <= right) root->right = bt(preorder,inorder, ++pos, i+1, right);
        return root;
    }

15 按之字形顺序打印二叉树(从上到下打印二叉树 III)

思路一：层序+reverse
思路二：deque

• 前取后放：从左向右打印，所以从前边取，后边放入（先入左，后入右）
• 后取前放： 从右向左，从后边取，前边放入（先入右，后入左）

16 二叉树的最近公共祖先

祖先： 若节点 p 在节点 root的左（右）子树中，或 p = root，则称 root是 p的祖先。

最近公共祖先： 设节点 root为节点 p, q的某公共祖先，若其左子节点 root->left 和右子节点 root->right 都不是 p,q 的公共祖先，则称 root是“最近的公共祖先” 。

根据以上定义，若 root 是 p, q 的 最近公共祖先 ，则只可能为以下情况之一：

• p 和 q在 root的子树中，且分列 root 的 异侧（即分别在左、右子树中）；
• p = root，且 q在 root的左或右子树中；
• q = root ，且 p 在 root的左或右子树中；
• （1） 如果当前结点 root等于 NULL，则直接返回 NULL
• （2） 如果 root 等于 p 或者 q，那这棵树一定返回 p 或者 q
• （3） 然后递归左右子树，因为是递归，使用函数后可认为左右子树已经算出结果，用 left和 right 表示
• （4） 此时若left为空，那最终结果只要看 right；若 right为空，那最终结果只要看 left
• （5） 如果 left和 right都非空，因为只给了 p和 q 两个结点，都非空，说明一边一个，因此 root是他们的最近公共祖先
• （6） 如果 left 和 right 都为空，则返回空（其实已经包含在前面的情况中了）

17 求根节点到叶节点数字之和

思路一：BFS+两个队列（一个treenode* 一个 int）
思路二：DFS

18 二叉树中和为某一值的路径

思路一：DFS。

• 套用自上而下的模板，注意定义dfs函数的时候，需要将vector<int> path传进去，因为每次都需要将root->val放进去，但 只有在满足条件时，才将他添加进二维vector里
  思路二：BFS 类似于路径总和找到满足条件的叶子节点，但需要unordered_map<左子树或右子树，双亲节点>记录路径
• 找路径node = m[node]
• 记录路径m[cur->left] = cur

19 验证二叉搜索树

BST 的定义，root 需要做的不只是和左右子节点比较，而是要整个左子树和右子树所有节点比较
思路一：二叉搜索树的性质，中序遍历一定是个递增序列，中序遍历存入数组，看数组是否递增。
思路二：中序遍历时验证，用一个pre表示前一个出栈节点（cur=nullptr时，若pre存在且pre的值>=cur的值 return false ,再令pre=cur）。
思路三：递归(cur->left 应该大于)

void BST(TreeNode root, int target) {
    if (root->val == target)
        // 找到目标，做点什么
    if (root->val < target) 
        BST(root->right, target);
    if (root->val > target)
        BST(root->left, target);
}

20 验证完全二叉树

完全二叉树：若二叉树的深度为 h，除第 h 层外，其它各层的结点数都达到最大个数，第 h 层所有的叶子结点都连续集中在最左边。

思路一：对其进行层次遍历，

• 若某节点左孩子空右孩子不空，则不是完全二叉树
• 若不是叶子节点，且左孩子或有孩子不存在，则不是完全二叉树。

思路二（✓）：定义一个标志符（是否达到空节点）若达到空节点以后，还出现非空节点，则说明不是完全二叉树。

21 二叉搜索树中第K小的元素

思路一 ：中序放数组，v[k-1]
思路二：中序遍历时记录次数，等于k的时候return。

22 二叉树剪枝

23 相同的树

讲解树算法的框架思路很好的一篇文章
思路一 ：递归

• 都为空的话，显然相同
• 一个为空，一个非空，显然不同
• 两个都非空，但 val 不一样也不行
• root1 和 root2 该比的都比完了，递归去比他们的左右子树

思路二：BFS
层序+queue

24 删除二叉搜索树中的节点 ?

框架

TreeNode deleteNode(TreeNode root, int key) {
    if (root.val == key) {
        // 找到啦，进行删除
    } else if (root.val > key) {
        root.left = deleteNode(root.left, key);
    } else if (root.val < key) {
        root.right = deleteNode(root.right, key);
    }
    return root;
}

找到目标节点，因为删除节点的同时不能破坏 BST 的性质。有三种情况

• 情况 1：A 恰好是末端节点，两个子节点都为空，直接删。
  
• 情况 2：A 只有一个非空子节点，那么它要让这个孩子接替自己的位置

if (!root->left) return root->right;
if (!root->right) return root->left;

• A 有两个子节点，将A的左子树，移到A的右子树的最左节点的左子树上
  
  思路一：找到A的右子树的最左节点，令最左节点的左子树为A的左子树，并令A为A的右子树。

	TreeNode* node = findLeft(root->right);
	node->left = root->left;
	root = root->right

思路二：（修改内部值，一般不用）

f (root.left != null && root.right != null) {
    // 找到右子树的最小节点
    TreeNode minNode = getMin(root.right);
    // 把 root 改成 minNode
    root.val = minNode.val;
    // 转而去删除 minNode
    root.right = deleteNode(root.right, minNode.val);
}

25 二叉搜索树中的搜索

26 二叉搜索树中的插入操作

27 另一棵树的子树

思路：参考相同子树，定义一个函数。 若 节点为空则false,否则进入递归。

28 二叉搜索树的最近公共祖先

参考二叉树的最近公共祖先，加上利用BST的性质
思路：

1. 基础情况：

 if (!root) return nullptr;
        if (root == p or root == q) return root;

2. 利用BST性质，若p,q均大于节点的值，则进入root->left ,若p,q均小于节点的值，则递归进去root->right,否则要不然一大一小，要不然有一个等于的，就返回root

if (root->val > p->val and root->val > q->val) return lowestCommonAncestor(root->left, p, q);
else if (root->val < p->val and root->val < q->val) return lowestCommonAncestor(root->right, p, q);
else {
            return root;

29 二叉搜索树的最小绝对差

设置一个最小值，不断更新

30 二叉搜索树中的众数

设置出现次数和最大出现次数，以及pre，

• 若pre为空，即第一次出现，令次数为1，若pre=cur，则次数++，若pre!=cur，令次数为1
• 若出现次数=最大出现次数 ，则添加进vector
• 若次数>最大出现次数， 则令最大出现次数=出现次数，并清空vector后在添加。

31 将有序数组转换为二叉搜索树

参考构造二叉树，每次以中间的点（left + (right - left) / 2）作为根节点，

32 最大二叉树

利用left和right来切割数组

33 把二叉搜索树转换为累加树

就是反中序遍历BST，用一个值记录累加和。

34 修剪二叉搜索树 ?

if (root == null) return null;
// 如果当前结点小于下界，直接将修剪后的右子树替换当前节点并返回
if (root.val < low) return trimBST(root.right, low, high);
// 如果当前结点大于上界，直接将修剪后的左子树替换当前节点并返回
if (root.val > high) return trimBST(root.left, low, high);
// 如果当前结点不越界，继续往两边扩散寻找第一个越界的结点
root.left = trimBST(root.left, low, high);
root.right = trimBST(root.right, low, high);
return root;

35 二叉树最大宽度

思路一：修改节点内部值作为坐标，

• 每一层设置 temp，它的值比该层第一个元素的值小1，防止坐标值过大,再用每个节点的值去减temp
• 每层的最大宽度就等于q.back()->val - q.front()->val + 1;
  -若该节点左子树存在，左子树的值 = 2 *cur->val ,右子树的值 = 2 *cur->val + 1

36 恢复二叉搜索树

思路：中序遍历找出 pre->val >cur->val 有问题的点。用两个指针记录下来，最后交换节点

• 第一种情况[1,3,2,4] 有问题的两个点连在一起（pre->val >cur->val 只出现一次）令p1 = pre,p2=cur
• 第二种情况[3,2,1,4] 有问题的两个点没有连在一起（pre->val >cur->val 出现两次）出现第一次的时候也是令p1 = pre,p2=cur ，第二次时令p2 = cur;

综上：只要出现 pre->val >cur->val ，若p1为空，则p1 = pre,p2=cur ，若p1不为空，则p2 = cur;

37 序列化二叉树

[注] ：string对象是恒定不变的，当每次用“+”, eg:res = res + tostring(cur->val)进行字符串拼接时，都会重新申请内存复制进去，所以多次字符串拼接操作时就吃内存，，可以用 += 直接加。
[注]：单引号用于字符，例如',' 双引号用于字符串，例如"null"
[注]：string是一个容器,char* 是一个指针，指向一个字符串的首地址。strcpy返回的事char*
[注]：char，是一个指向字符串的指针，是变量，值可以改变， char[]：是一个char数组（字符数组）是常量，值不能改变。
eg:char * a=”string1”;char b[]=”string2”;
a=b； //OK; a=”string3” //OK; b=a; //报错！左边操作数只读
[注]：char* 转string ,eg: char* str; 转成string类型： string data = string(str);
eg：

string res = "1,2,3,4,5";
char* ret = new char[res.length() + 1];
strcpy(ret, res.c_str());

序列化：层序，记得删除最后的，
反序列化：(将string里的数据放进vector + 创建二叉树(bfs))

• 先将 string里的数据放到数组里，
• 创建节点的时候可以用atoi(str.c_str()）转成int ，利用完全二叉树的性质，序列里第i个节点（0开始），他的左右子树在序列里的位置是 2 * i+1(左),2 * i+2(右)

38 路径总和 III (不一定从根节点开始)

• 定义一个全局变量作为答案，先统计以根节点开始符号条件的路径，然后再递归root->left,root->right.
• sum-=root->val, 若sum=0时，说明找到了一条，此题此时不需要return，因为有正数有负数，后面还有可能会有，例如[1,2,3,-6,6]，tagrat=6
• 找符合条件的路径的时候可以套用模板

int res = 0;
int pathSum(TreeNode* root, int targetSum) {
    if (!root) return 0;
    dfs(root, targetSum);
    pathSum(root->left, targetSum);
    pathSum(root->right, targetSum);
    return res;
}
void dfs(TreeNode* root, int sum) {
    if (!root) return;
    sum -= root->val;
    if (sum == 0) res++;
    dfs(root->left, sum);
    dfs(root->right, sum);

    }

39 二叉树中的最大路径和

节点值可能为负数，因此要初始设定为INT_MIN
一个子树内部的最大路径和 = 左子树提供的最大路径和 + 根节点值 + 右子树提供的最大路径和
当前子树中捞取的最大收益。分三种情况：

• 路径停在当前子树的根节点，在当前子树的最大收益：root.val
• 走入左子树，在当前子树的最大收益：root.val + dfs(root.left)
• 走入右子树，在当前子树的最大收益：root.val + dfs(root.right)
  
  但是返回时只能返回2或3，不能走入左子树又掉头走右子树，不能两头收益
  如果某个子树 dfs 结果为负，走入它，收益不增反减，该子树就没用，需杜绝走入，像对待 null 一样让它返回 0
  

int maxSum = INT_MIN;
int maxPathSum(TreeNode* root) {
    dfs(root);
    return maxSum;

}
int dfs(TreeNode* root) {
    if (!root) return 0;
    int left = max(0, dfs(root->left));
    int right = max(0, dfs(root->right));
    maxSum = max(maxSum, left + right + root->val);
    return max(left+ root->val, right + root->val);
    }

二叉树总结

1.1路径问题：

1、自顶向下：
顾名思义，就是从某一个节点(不一定是根节点)，从上向下寻找路径，到某一个节点(不一定是叶节点)结束

一般路径：
vector<vector<int>>res;
void dfs(TreeNode*root,vector<int>path)
{
    if(!root) return;  //根节点为空直接返回
    path.push_back(root->val);  //作出选择
    if(!root->left && !root->right) //如果到叶节点  
    {
        res.push_back(path);
        return;
    }
    dfs(root->left,path);  //继续递归
    dfs(root->right,path);
}

# **给定和的路径：**
void dfs(TreeNode*root, int sum, vector<int> path)
{
    if (!root)
        return;
    sum -= root->val;
    path.push_back(root->val);
    if (!root->left && !root->right && sum == 0)
    {
        res.push_back(path);
        return;
    }
    dfs(root->left, sum, path);
    dfs(root->right, sum, path);
}

2、非自顶向下：从任意节点到任意节点的路径
设计一个辅助函数maxpath，调用自身求出以一个节点为根节点的左侧最长路径left和右侧最长路径right，那么经过该节点的最长路径就是left+right。接着只需要从根节点开始dfs,不断比较更新全局变量即可。

int res=0;
int maxPath(TreeNode *root) //以root为路径起始点的最长路径
{
    if (!root)
        return 0;
    int left=maxPath(root->left);
    int right=maxPath(root->right);
    res = max(res, left + right + root->val); //更新全局变量  
    return max(left, right);   //返回左右路径较长者
}

这类题型DFS注意点：

• 1、left,right代表的含义要根据题目所求设置，比如最长路径、最大路径和等等
• 2、全局变量res的初值设置是0还是INT_MIN要看题目节点是否存在负值,如果存在就用INT_MIN，否则就是0
• 3、注意两点之间路径为1，因此一个点是不能构成路径的