226. 翻转二叉树

递归：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     TreeNode* invertTree(TreeNode* root) {
15         if(root == nullptr) return root;
16         root->left = invertTree(root->left);
17         root->right = invertTree(root->right);
18         swap(root->left,root->right);
19         return root;
20     }
21 };

 

迭代：

/**
 * 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:
    TreeNode* invertTree(TreeNode* root) {
        if(root == nullptr) return root;
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){
            TreeNode* node = queue.front();
            queue.pop();
            swap(node->left,node->right);
            if(node->left != nullptr)   queue.push(node->left);
            if(node->right != nullptr)  queue.push(node->right);
        }
        return root;
    }
};

101. 对称二叉树

递归：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     bool isSymmetric(TreeNode* root) {
15         if(root == nullptr) return true;
16         return compare(root->left,root->right);
17     }
18     bool compare(TreeNode* left, TreeNode* right){
19         if(left == nullptr && right != nullptr) return false;
20         else if(left != nullptr && right == nullptr)    return false;
21         else if(left == nullptr && right == nullptr)    return true;
22         else if(left->val != right->val)    return false;
23 
24         bool in = compare(left->right, right->left);
25         bool out = compare(left->left, right->right);
26 
27         return in && out;
28     }
29 };

迭代：

 1 /**
 2  * Definition for a binary tree node.
 3  * struct TreeNode {
 4  *     int val;
 5  *     TreeNode *left;
 6  *     TreeNode *right;
 7  *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 8  *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 9  *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
10  * };
11  */
12 class Solution {
13 public:
14     bool isSymmetric(TreeNode* root) {
15         if(root == nullptr) return true;
16         stack<TreeNode*> stack;
17         stack.push(root->left);
18         stack.push(root->right);
19         while(!stack.empty()){
20             TreeNode* left = stack.top();
21             stack.pop();
22             TreeNode* right = stack.top();
23             stack.pop();
24             // 都是空，继续.
25             if(!left && !right) continue;
26             if((!left || !right || (left->val != right->val)))
27                 return false;
28             stack.push(left->left);
29             stack.push(right->right);
30             stack.push(left->right);
31             stack.push(right->left);
32         }
33         return true;
34     }
35 };