算法训练 day15 | 102.二叉树的层序遍历 226.翻转二叉树 101.对称二叉树

102.二叉树的层序遍历

题目链接:二叉树的层序遍历

视频讲解:讲透二叉树的层序遍历

        层序遍历，就是一层一层的遍历二叉树，此时需要就用队列来完成。队列是先进先出的适合一层一层遍历。

首先把头结点放入队列中，用一个size记录队列的大小，同时也表示了每一层元素的个数。遍历某一层时，先把这一层的节点从队列中弹出并把这些节点对应的值放入一个数组中，弹出节点的个数取决于size的大小，再把下一层的节点放到队列中。如此下去，直到队列为空。

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        deque<TreeNode *> dq;
        vector<vector<int>> ret;
        if (root != nullptr)
        {
            dq.push_back(root);
        }
        while (!dq.empty())
        {
            int size = dq.size();
            vector<int> v;
            while (size--)
            {
                TreeNode* node = dq.front();
                dq.pop_front();
                v.push_back(node->val);
                if (node->left) dq.push_back(node->left);
                if (node->right) dq.push_back(node->right);
            }
            ret.push_back(v);
        }
        return ret;
    }
};

226.翻转二叉树

题目链接:翻转二叉树

视频讲解:翻转二叉树

        本题通过递归和迭代遍历都可以解决。想要翻转整棵树，只需将每个节点的左右孩子翻转即可。

递归法（三步）

1、确定递归函数的参数和返回值：参数就是要传入节点的指针，返回值就是root;

2、确定终止条件：当前节点为空时就返回了；

3、确定单层递归逻辑：对于前序遍历，是先交换左右孩子节点，然后对左子树进行翻转，再对右子树进行翻转。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if (root == NULL) return root;
        swap(root->left, root->right);  // 中
        invertTree(root->left);         // 左
        invertTree(root->right);        // 右
        return root;
    }
};

迭代法

深度优先、广度优先都可以实现（以前序遍历为例），遍历时只需将左右孩子节点交换即可。

深度优先

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
       if (!root) return root;
       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;
    }
};

广度优先

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        while (!que.empty()) {
            int size = que.size();
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                swap(node->left, node->right); // 节点处理
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
        }
        return root;
    }
};

101.对称二叉树

题目链接:对称二叉树

视频讲解:同时操作两个二叉树

        对称二叉树的实际含义其实就是把该二叉树翻转后是否与原来的相等。那么就需比较根节点的左右子树是不是可以互相翻转，也就是要比较两棵树，这两棵树它们的外侧节点和内侧节点要对应相等。那么采取什么遍历方式呢？我们通过遍历是要比较内侧和外侧节点，也就是左右中节点比较，所以采用后序遍历的方式。

/**
 * 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 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 out = compare(left->left, right->right); // 比较外侧
        bool in = compare(left->right, right->left); // 比较内侧
        bool ret = out && in; // 比较中间
        return ret;
    }

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