1315 祖父节点值为偶数的节点和

题目描述：
给你一棵二叉树，请你返回满足以下条件的所有节点的值之和：
该节点的祖父节点的值为偶数。（一个节点的祖父节点是指该节点的父节点的父节点。）
如果不存在祖父节点值为偶数的节点，那么返回 0 。

示例：

输入：root = [6,7,8,2,7,1,3,9,null,1,4,null,null,null,5]
输出：18
解释：图中红色节点的祖父节点的值为偶数，蓝色节点为这些红色节点的祖父节点。

提示：
树中节点的数目在 1 到 10^4 之间。
每个节点的值在 1 到 100 之间。

方法1：
主要思路：解题链接汇总
（1）先序遍历，找到结点值为偶数的结点，然后找是否存在孙子结点，若存在，则统计；

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    void pre_order(TreeNode* root,int&res){
        if(root==NULL){
            return;
        }
        if(root->val%2==0){//当前结点的值是偶数，故判断其孙子结点是否存在，若存在，则统计
            if(root->left){
                if(root->left->left){
                    res+=root->left->left->val;
                }
                if(root->left->right){
                    res+=root->left->right->val;
                }
            }
            if(root->right){
                if(root->right->left){
                    res+=root->right->left->val;
                }
                if(root->right->right){
                    res+=root->right->right->val;
                }
            }
        }
        pre_order(root->left,res);
        pre_order(root->right,res);
    }
    int sumEvenGrandparent(TreeNode* root) {
        int res=0;
        pre_order(root,res);
        return res;
    }
};

方法2：
使用go实现

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
 func pre_order(root *TreeNode,res *int){
     if root==nil {
         return
     }
     if (root.Val%2) == 0 {
         if root.Left != nil {
             if root.Left.Left != nil {
                 *res += root.Left.Left.Val
             }
             if root.Left.Right != nil {
                 *res += root.Left.Right.Val
             }
         }
         if root.Right != nil {
             if root.Right.Left != nil {
                 *res += root.Right.Left.Val
             }
             if root.Right.Right != nil {
                 *res += root.Right.Right.Val
             }
         }
         
     }
    pre_order(root.Left,res)
    pre_order(root.Right,res)
 }
func sumEvenGrandparent(root *TreeNode) int {
    res := 0
    
    pre_order(root,&res)
    return res
}