算法日记1二叉树

算是亡羊补牢开始学算法吧，从今天开始记录做过的题目

• 257. 二叉树的所有路径

给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

https://leetcode.cn/problems/binary-tree-paths/description/
该题主要是运用递归，需要注意用数组储存已经走过的数（注意回溯时pop），当找到叶子节点时打印一个string字符串，用数组result存储起来

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    void getRoad(TreeNode* node,vector<int>& path,vector<string>&result){
        path.push_back(node->val);
        if(node->left==NULL&&node->right==NULL){
            string spath;
            for(int i=0;i<path.size()-1;i++){
                spath+=to_string(path[i]);
                spath+="->";
            }
            spath+=to_string(path[path.size()-1]);
            result.push_back(spath);
            return;
        }
        if(node->left){
            getRoad(node->left,path,result);
            path.pop_back();//回溯时弹出
        }
        if(node->right){
            getRoad(node->right,path,result);
            path.pop_back();//回溯时弹出
        }
    }
    vector<string> binaryTreePaths(TreeNode* root) {
        vector<string> result;
        vector<int> path;
        getRoad(root,path,result);
        return result;
    }
};

• 100.相同的树
  给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

示例 1：

输入：p = [1,2,3], q = [1,2,3]
输出：true
示例 2：

输入：p = [1,2], q = [1,null,2]
输出：false
示例 3：

输入：p = [1,2,1], q = [1,1,2]
输出：false

https://leetcode.cn/problems/same-tree/description/

本题我主要用的迭代法，因为不是很能理解递归，通过建立队列来存储p和q的结点，然后进行比较，弹出，压入等操作

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    bool isSameTree(TreeNode* p, TreeNode* q) {
        if(p==NULL&&q==NULL)return true;
        if(p==NULL||q==NULL)return false;
        queue<TreeNode*> que;
        que.push(p);
        que.push(q);
        while(!que.empty()){
            TreeNode* leftNode=que.front();que.pop();
            TreeNode* rightNode=que.front();que.pop();
            if(!leftNode&&!rightNode){
                continue;
            }
            if(!leftNode||!rightNode||(leftNode->val!=rightNode->val)){
                return false;
            }
            que.push(leftNode->left);
            que.push(rightNode->left);
            que.push(leftNode->right);
            que.push(rightNode->right);
        }
        return true;
    }
};

• 404.左叶子之和
  计算给定二叉树的所有左叶子之和。
  https://leetcode.cn/problems/sum-of-left-leaves/
  个人认为本题易混淆在于计算左子树的判断，即

int leftSum=sumOfLeftLeaves(root->left);
        if(root->left&&!root->left->left&&!root->left->right){
            leftSum=root->left->val;
        }
        int rightSum=sumOfLeftLeaves(root->right);
        int sum=leftSum+rightSum;

如果 root->left 是左叶子节点，它会在下一步被单独处理。

如果 root->left 不是左叶子节点，递归继续向下查找。
root->left 存在（即当前节点有左子节点）。

root->left 没有左子节点（!root->left->left）。

root->left 没有右子节点（!root->left->right）。
如果 root->left 是左叶子节点，则将 leftValue 更新为 root->left->val（左叶子节点的值）。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int sumOfLeftLeaves(TreeNode* root) {
        if(root==NULL)return 0;
        if(root->left==NULL&&root->right==NULL)return 0;
        int leftSum=sumOfLeftLeaves(root->left);
        if(root->left&&!root->left->left&&!root->left->right){
            leftSum=root->left->val;
        }
        int rightSum=sumOfLeftLeaves(root->right);
        int sum=leftSum+rightSum;
        return addNumOfLeftnode(root,sum);
    }
};