DFS总结

class Solution {
public:
    int kthLargest(TreeNode* root, int k) {
        int result = 0;
        dfs(root, result, k);
        return result;
    }

private:
    void dfs(TreeNode *root, int &result, int &k) {
        if (!root) return;
        dfs(root->right, result, k);
        if (!--k) result = root->val;//保留遍历到的第k个节点的值。
        dfs(root->left, result, k);
    }
};
//解题思路总结：
//1.中序遍历的结果为从小到大，所以本题逆着中序遍历进行（右中左）
//2.递归的退出条件为该节点为null
//3.本题的递归是从root节点一右到底，然后再从底部经历根节点（每部分右节点遍历完后），左节点回到顶部，在一左到底，然后再从底部经历根节点（每部分右节点遍历完后），左节点回到顶部。== 右中左的遍历。
//4.其实不仅是本道题目，递归的逻辑恰好一定程度上符合树的遍历逻辑。

class Solution {
public:
    bool hasPathSum(TreeNode* root, int targetSum) {
        if(root == nullptr){
            return false;
        }

        queue<TreeNode*> que_node;
        queue<int> que_val;
        que_node.push(root);
        que_val.push(root->val);

        while(que_node.empty() != true ){
            TreeNode* orb = que_node.front();
            int temp = que_val.front();
            que_node.pop();
            que_val.pop();
            if(orb->left == nullptr && orb->right == nullptr){
                if(temp == targetSum){
                    return true;
                }
            }
            if(orb->left != nullptr){
                que_node.push(orb->left);
                que_val.push(orb->left->val + temp);
            }
            if(orb->right != nullptr){
                que_node.push(orb->right);
                que_val.push(orb->right->val + temp);
            }
            
        }

        return false;
    }
};

总结：
创建两个队列，一个存入节点，一个存入到该节点的大小数值。两个队列同步变化。