【数据结构与算法 | 灵神题单 | 自顶向下DFS篇】力扣199， 1315， 1457

1. 力扣199：二叉树的右视图

1.1 题目：

给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。

示例 1:

输入: [1,2,3,null,5,null,4]
输出: [1,3,4]

示例 2:

输入: [1,null,3]
输出: [1,3]

示例 3:

输入: []
输出: []

提示:

• 二叉树的节点个数的范围是 [0,100]
• -100 <= Node.val <= 100 

1.2 思路：

使用基于队列的bfs，将每一层的最后一个节点的值加入到列表中即可。

1.3 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<Integer> rightSideView(TreeNode root) {
        List<Integer> list = new ArrayList<>();
        Deque<TreeNode> queue= new LinkedList<>();
        if(root == null){
            return list;
        }
        // 将根节点加入队列进入while循环
        queue.offer(root);
        int n = 1;
        //n表示一行有几个节点
        while(!queue.isEmpty()){
            // 用x记录下一层的节点数
            int x = 0;
            while(n-- > 0){
                TreeNode poll = queue.poll();
                if(poll.left != null){
                    x++;
                    queue.offer(poll.left);
                }
                if(poll.right != null){
                    x++;
                    queue.offer(poll.right);
                }
                // 将一层节点的最后一个节点的值加入到列表中
                if(n == 0){
                    list.add(poll.val);
                }
            }
            // x表示下一层有几个节点，然后更新n便于下一轮while循环
            n = x;
        }
        return list;
    }
}

2. 力扣1315：祖父节点值为偶数的节点和

2.1 题目：

给你一棵二叉树，请你返回满足以下条件的所有节点的值之和：

• 该节点的祖父节点的值为偶数。（一个节点的祖父节点是指该节点的父节点的父节点。）

如果不存在祖父节点值为偶数的节点，那么返回 0 。

示例：

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

提示：

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

2.2 思路：

dfs狠狠递归即可。

2.3 题解：

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int sum;
    public int sumEvenGrandparent(TreeNode root) {
        if(root == null){
            return 0;
        }
        // 直接从根节点的左右孩子开始递归，因为根节点啊肯定是被当做0处理的
        dfs(null, root, root.left);
        dfs(null, root, root.right);

        return sum;
    }
    private void dfs(TreeNode granpar, TreeNode parent, TreeNode node) {
        // 节点为null，直接返回就好了
        if(node == null){
            return;
        }
        // 如果祖父节点不为空，而且祖父的值是偶数，满足条件
        // 将其值加入到全局变量sum中
        if(granpar != null && granpar.val % 2 == 0){
            sum += node.val;
        }
        // 无脑递归就可以了
        dfs(parent, node, node.left);
        dfs(parent, node, node.right);
    }
}

3. 力扣1457：二叉树中的伪回文路径

3.1 题目：

给你一棵二叉树，每个节点的值为 1 到 9 。我们称二叉树中的一条路径是 「伪回文」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。

请你返回从根到叶子节点的所有路径中 伪回文 路径的数目。

示例 1：

输入：root = [2,3,1,3,1,null,1]
输出：2 
解释：上图为给定的二叉树。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1] 。
     在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1] 。

示例 2：

输入：root = [2,1,1,1,3,null,null,null,null,null,1]
输出：1 
解释：上图为给定二叉树。总共有 3 条从根到叶子的路径：绿色路径 [2,1,1] ，路径 [2,1,3,1] 和路径 [2,1] 。
     这些路径中只有绿色路径是伪回文路径，因为 [2,1,1] 存在回文排列 [1,2,1] 。

示例 3：

输入：root = [9]
输出：1

提示：

• 给定二叉树的节点数目在范围 [1, 105] 内
• 1 <= Node.val <= 9

3.2 思路：

开始我是用将该节点更新为该节点的值加上其父节点的值，然后在用数组记录数字中每个数字出现了几次。跑了出问题了，我觉得是树如果非常长的话，数字就会超过Int的范围。

不如选择使用全局变量的数组，类似于栈的作用，如果遍历到该节点，就将该节点加入到数组中，如果其左右子树都处理完了，就将该节点的值从数组中删除。

如果遍历到叶子节点，就需要判断数组，如果其元素的奇数大于1，就不可能构成回文。

3.3 题解：

class Solution {
    int target;
    // 用栈来维护从根节点到遍历到的节点的排列
    int[] stack = new int[10];
    public int pseudoPalindromicPaths (TreeNode root) {
        if(root.left == null && root.right == null){
            return 1;
        }
        dfs(root);
        return target;
    }
    private void dfs(TreeNode node) {
        if(node == null){
            return;
        }
        // 将该节点加入到栈中
        stack[node.val]++;
        // 如果此时node节点是叶子节点
        if(node.left == null && node.right == null){
            int count = 0;
            // 遍历数组元素，如果数组元素中的奇数大于1个，俺么肯定就构成不了回文
            for(int i : stack){
                if(i % 2 == 1){
                    count++;
                }
            }
            target = count > 1 ? target : target +1;
        }
        dfs(node.left);
        dfs(node.right);
        // 处理完左右子树，递完了，要归（回去）了
        // 就将这个节点在数组中抹掉
        stack[node.val]--;
    }
}