421-二叉树（226. 翻转二叉树、101. 对称二叉树、104.二叉树的最大深度、222.完全二叉树的节点个数）

226. 翻转二叉树

1、递归法

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr)    return root;

        swap(root->left, root->right);

        invertTree(root->left);
        invertTree(root->right);
        return root;
    }
};

2、迭代法

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == nullptr) return nullptr;
        stack<TreeNode*> st;
        st.push(root);

        while (!st.empty())
        {
            TreeNode* node = st.top();
            st.pop();

            swap(node->left, node->right);

            if (node->right) st.push(node->right);
            if (node->left) st.push(node->left);
        }
        return root;
    }
};

101. 对称二叉树

1、递归法

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right)
    {
        if (left == nullptr && right != nullptr) return false;
        else if (left != nullptr && right == nullptr)    return false;
        else if (left == nullptr && right == nullptr) return true;
        else if (left->val != right->val)    return false;
        else return compare(left->left, right->right) && compare(left->right, right->left);
    }

public:
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

2、迭代法

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if (root == NULL) return true;
        queue<TreeNode*> que;
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列
        
        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode* leftNode = que.front(); que.pop();
            TreeNode* rightNode = que.front(); que.pop();
            if (!leftNode && !rightNode) {  // 左节点为空、右节点为空，此时说明是对称的
                continue;
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if ((!leftNode || !rightNode || (leftNode->val != rightNode->val))) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};

104.二叉树的最大深度

1、递归法

class Solution {
public:
    int get_depth(TreeNode* node)
    {
        if (node == nullptr)    return 0;
        int left_depth = get_depth(node->left);
        int right_depth = get_depth(node->right);
        int depth = 1 + std::max(left_depth, right_depth);
        return depth;
    }

public:
    int maxDepth(TreeNode* root) {
        return get_depth(root);
    }
};

2、迭代法

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        if (root)    que.push(root);
        int res = 0;

        while (!que.empty())
        {
            int size = que.size();
            res++;

            for (int i = 0; i < size; i++)
            {
                TreeNode* node = que.front();
                que.pop();

                if (node->left)  que.push(node->left);
                if (node->right)  que.push(node->right);
            }
        }
        return res;
    }
};

222.完全二叉树的节点个数

1、递归法

class Solution {
public:
    int get_nodes(TreeNode* node)
    {
        if (node == nullptr) return 0;
        int left_nodes = get_nodes(node->left);
        int right_nodes = get_nodes(node->right);
        int nodes = 1 + left_nodes + right_nodes;
        return nodes;
    }

public:
    int countNodes(TreeNode* root) {
        return get_nodes(root);
    }
};

2、迭代法

class Solution {
public:
    int countNodes(TreeNode* root) {
        queue<TreeNode*> que;
        if(root)    que.push(root);

        int res = 0;

        while(!que.empty())
        {
            int size = que.size();
            for(int i = 0; i < size; i++)
            {
                res++;
                TreeNode* node = que.front();
                que.pop();

                if(node->left)  que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return res;
    }
};