617.合併二叉樹

給定兩個二叉樹，想象當你將它們中的一個覆蓋到另一個上時，兩個二叉樹的一些節點便會重疊。

你需要將他們合併為一個新的二叉樹。合併的規則是如果兩個節點重疊，那麼將他們的值相加作為節點合併後的新值，否則不為 NULL 的節點將直接作為新二叉樹的節點。

解法1：遞迴解決，以t1為基樹，若t1為null則採用t2節點值，若t2也為空，則不需要了。按照根節點與左右節點依次遞迴。

/**
 * 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:
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        merge(t1,t2);
        return t1;
    }
    void merge(TreeNode* &t1, TreeNode* &t2)
    {
        if(t1==nullptr)
            t1 = t2;
        else
        {
            if(t2==nullptr)
                return;
            else
            {
                t1->val+=t2->val;
                merge(t1->left,t2->left);
                merge(t1->right,t2->right);
            }
        }
    }
};
 

226.翻轉二叉樹

翻轉一棵二叉樹。

示例：

輸入：

     4
   /   \
  2     7
 / \   / \
1   3 6   9

輸出：

     4
   /   \
  7     2
 / \   / \
9   6 3   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 exchange(TreeNode* root)
    {
        TreeNode* node = root;
        if(node!=NULL)
        {
            TreeNode* tmp = node->left;
            node->left = node->right;
            node->right = tmp;
        }
    }
    TreeNode* invertTree(TreeNode* root) {
        TreeNode* node = root;
        if(root==NULL) return root;
        invertTree(node->left);
        invertTree(node->right);
        exchange(node);
        return root;
    }
};
 

144.二叉樹的前序遍歷

解法1：遞迴求解（根左右）

解法2：利用棧，首先把root壓入，然後再把右子樹壓入，再把左子樹壓入。

解法一：
/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        preorder(root,res);
        return res;
    }
    void preorder(TreeNode* root,vector<int>& res)
    {
        if(root==NULL) return;
        res.push_back(root->val);
        preorder(root->left,res);
        preorder(root->right,res);
    }
};
解法二：
/**
 * 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:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> res;
        if(root==NULL) return res;
        stack<TreeNode*> stk;
        stk.push(root);
        while(!stk.empty())
        {
            auto node = stk.top();
            res.push_back(node->val);
            stk.pop();
            if(node->right!=NULL) stk.push(node->right);
            if(node->left!=NULL) stk.push(node->left);
        }
        return res;
    }
};