LeetCode1315. 二叉树祖父节点值为偶数

问题

https://leetcode-cn.com/problems/sum-of-nodes-with-even-valued-grandparent/

解决

法1、bfs搜索 把每一层放到队列中进行搜索（ps 因为自己一直喜欢clean code,就把计算孙子节点的值抽离出了getGrandSonVal(TreeNode grandp) 没想到在后面的dfs中也用到了 所以重构是个持续的过程，存在于软件开发的任何一个阶段）

   /**
    bfs搜索 把每一层放到队列中进行搜索
    */
    private int bfs(TreeNode root){
        int ret = 0;
        //一层一层的遍历
        //linkedlist 还是个队列 可以啊
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if((node.val&1)==0){
                ret += getGrandSonVal(node);
            }
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
        return ret;
    }

	 /**
     * @param grandp
     * @return  求孙子的值
     */
    private int getGrandSonVal(TreeNode grandp) {
        int temp = 0;
        if(grandp!=null){
            //左儿子不为空
            if(grandp.left!=null){
                //左孙子
                if(grandp.left.left!=null){
                    temp+=grandp.left.left.val;
                }
                //右孙子
                if(grandp.left.right!=null){
                    temp+=grandp.left.right.val;
                }
            }
            //右儿子不为空
            if(grandp.right!=null){
                //左孙子不为空
                if(grandp.right.left!=null){
                    temp+=grandp.right.left.val;
                }
                //右孙子不为空
                if(grandp.right.right!=null){
                    temp+=grandp.right.right.val;
                }
            }
            return temp;
        }
        return 0;
    }

法2、 思想很直观 就是每遇到一个偶数节点都去计算它孙子的值

 private void dfsWay2(TreeNode root){
        //如果该节点是偶数，那么把他的孙子加起来
        if(root!=null){
            if((root.val&1)==0) {
                ans += getGrandSonVal(root);
            }
            dfsWay2(root.left);
            dfsWay2(root.right);
        }
    }
    /**
     *
     * @param grandp
     * @return  求孙子的值
     */
    private int getGrandSonVal(TreeNode grandp) {
        int temp = 0;
        if(grandp!=null){
            //左儿子不为空
            if(grandp.left!=null){
                //左孙子
                if(grandp.left.left!=null){
                    temp+=grandp.left.left.val;
                }
                //右孙子
                if(grandp.left.right!=null){
                    temp+=grandp.left.right.val;
                }
            }
            //右儿子不为空
            if(grandp.right!=null){
                //左孙子不为空
                if(grandp.right.left!=null){
                    temp+=grandp.right.left.val;
                }
                //右孙子不为空
                if(grandp.right.right!=null){
                    temp+=grandp.right.right.val;
                }
            }
            return temp;
        }
        return 0;
    }

法3、把三代关系都抽离出来 便于传值

 /**
     *
     * @param grandp  祖父
     * @param father 父
     * @param child 子
     * 深度遍历
     */
    private void dfsWay1(TreeNode grandp, TreeNode father, TreeNode child){
        if(child == null){
            return ;
        }
        if(grandp!=null&&(grandp.val&1)==0){
            ans +=child.val;
        }
        //dfs左子树
        dfsWay1(father,child,child.left);
        //dfs右子树
        dfsWay1(father,child,child.right);
    }

可运行代码（ 以下代码包含上面的三种方法 可直接粘贴在编辑器中运行测试，还包含测试用例）

public class Solution {
    public static void main(String[] args) {
        TreeNode  node1 = new TreeNode(6);
        TreeNode  node2 = new TreeNode(7);
        TreeNode  node3 = new TreeNode(8);
        TreeNode  node4 = new TreeNode(2);
        TreeNode  node5 = new TreeNode(7);
        TreeNode  node6 = new TreeNode(1);
        TreeNode  node7 = new TreeNode(3);
        TreeNode  node8 = new TreeNode(9);
        TreeNode  node9 = new TreeNode(1);
        TreeNode  node10 = new TreeNode(4);
        TreeNode  node11 = new TreeNode(5);
        node1.left = node2;
        node2.left = node4;
        node4.left = node8;
        node2.right =node5;
        node5.left = node9;
        node5.right =node10;

        node1.right = node3;
        node3.left = node6;
        node3.right = node7;
        node7.left = node11;

        Solution s = new Solution();
        System.out.println(s.sumEvenGrandparent(node1));
    }

    int ans = 0;
    public int sumEvenGrandparent(TreeNode root) {
        return bfs(root);
        //return ans;
    }
    private int bfs(TreeNode root){
        int ret = 0;
        //一层一层的遍历
        //linkedlist 还是个队列 可以啊
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(root);
        while(!queue.isEmpty()){
            TreeNode node = queue.poll();
            if((node.val&1)==0){
                ret += getGrandSonVal(node);
            }
            if(node.left!=null){
                queue.add(node.left);
            }
            if(node.right!=null){
                queue.add(node.right);
            }
        }
        return ret;
    }
    private void dfsWay2(TreeNode root){
        //如果该节点是偶数，那么把他的孙子加起来
        if(root!=null){
            if((root.val&1)==0) {
                ans += getGrandSonVal(root);
            }
            dfsWay2(root.left);
            dfsWay2(root.right);
        }
    }
    /**
     *
     * @param grandp
     * @return  求孙子的值
     */
    private int getGrandSonVal(TreeNode grandp) {
        int temp = 0;
        if(grandp!=null){
            //左儿子不为空
            if(grandp.left!=null){
                //左孙子
                if(grandp.left.left!=null){
                    temp+=grandp.left.left.val;
                }
                //右孙子
                if(grandp.left.right!=null){
                    temp+=grandp.left.right.val;
                }
            }
            //右儿子不为空
            if(grandp.right!=null){
                //左孙子不为空
                if(grandp.right.left!=null){
                    temp+=grandp.right.left.val;
                }
                //右孙子不为空
                if(grandp.right.right!=null){
                    temp+=grandp.right.right.val;
                }
            }
            return temp;
        }
        return 0;
    }


    /**
     *
     * @param grandp  祖父
     * @param father 父
     * @param child 子
     * 深度遍历
     */
    private void dfsWay1(TreeNode grandp, TreeNode father, TreeNode child){
        if(child == null){
            return ;
        }
        if(grandp!=null&&(grandp.val&1)==0){
            ans +=child.val;
        }
        //dfs左子树
        dfsWay1(father,child,child.left);
        //dfs右子树
        dfsWay1(father,child,child.right);
    }

}
class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}

总结

dfs一般使用递归实现
bfs一般使用一个队列存储然后再取出来

不管什么时候都要注意代码质量