day15 二叉树02 二叉树的层序遍历&翻转二叉树&对称二叉树

大纲

● 二叉树的层序遍历
● 226.翻转二叉树
● 101.对称二叉树

二叉树的层序遍历

二叉树的层序遍历可以解决很多相似的二叉树问题，比如二叉树最大深度/最小深度。
思路是利用队列实现，每层元素个数可以确定为队列大小，遍历每层元素过程中不断把下层的元素填充到队列末尾，直到队列为空

// 使用队列的逻辑 需要注意判断是否为空的情况
vector<vector<int>> levelOrder(TreeNode* root) {
    queue<TreeNode*> _queue;
    if (root) _queue.push(root);
    vector<vector<int>> ret;
    while (!_queue.empty()) {
        int size = _queue.size();
        vector<int> tmp;
        for (int i = 0; i < size; ++i) {
            TreeNode* node = _queue.front();
            _queue.pop();

            tmp.push_back(node->val);
            if (node->left != nullptr) _queue.push(node->left);
            if (node->right != nullptr) _queue.push(node->right);
        }
        ret.push_back(tmp);
    }
    return ret;
}

翻转二叉树

题目链接：226.翻转二叉树
分析过程：
从根节点往下层序遍历，交换每个节点的左右孩子节点。

// 交换左右节点
// 先交换同一层的，再交换下一层的节点
TreeNode* swapTreeNode(TreeNode* root) {
    queue<TreeNode*> _queue;
    if (root) _queue.push(root);

    while (!_queue.empty()) {
        int size = _queue.size();

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

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

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

对称二叉树

题目链接：101.对称二叉树
分析过程：
二叉树是否对称判断，需要注意比较的不是左右孩子节点，而是比较左右子树是否对称。
迭代法：

// 
bool isEquipment(TreeNode* root)
{
    queue<TreeNode*> _queue;
    if (root) _queue.push(root);
    else return false;

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

            if (node->left && node->right) {
                if (node->left->val != node->right->val)
                    return false;
                _queue.push(node->left);
                _queue.push(node->right);
            } else if (!node->left && !node->right) {

            } else {
                return false;
            }
        }
    }
    return true;
}

递归法：

bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == NULL && right != NULL) return false;
        else if (left != NULL && right == NULL) return false;
        else if (left == NULL && right == NULL) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;

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

总结

递归写起来会比迭代更加容易，需要想清楚递归的3大要素：

递归参数返回值、递归结束条件、递归单层循环