二叉树：层序遍历 翻转二叉树 对称二叉树

层序遍历

• 题目：Leetcode102,107,199,637,429,515,116,117,104,111
• 思路：一层一层遍历，需要借助队列，队列先进先出，符合一层一层遍历的逻辑。
• 102.二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        vector<vector<int>> res;
        if(root) que.push(root);
        while(!que.empty()) {
            vector<int> vec;
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            res.push_back(vec);
        }
        return res;
    }
};

• 429.N叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(Node* root) {
        queue<Node*> que;
        vector<vector<int>> res;
        if(root) que.push(root);
        while(!que.empty()) {
            vector<int> vec;
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                Node* node = que.front();
                que.pop();
                //遍历当前节点的值加入vec
                vec.push_back(node->val);
                for(int i = 0; i < node->children.size(); i++) {
                    //将子节点加入队列
                    if(node->children[i]) que.push(node->children[i]);
                }
            }
            res.push_back(vec);
        }
        return res;
    }
};

• 116.填充每个节点的下一个右侧节点指针

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root) {
            que.push(root);
            //头结点next指向NULL
            root->next = NULL;
        }
        while(!que.empty()) {
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                //获取当前节点，将当前节点的左右子节点入队
                Node* curNode = que.front();
                if(curNode->left) que.push(curNode->left);
                if(curNode->right) que.push(curNode->right);
                que.pop();
                //获取右侧节点，如果不是该层最后一个节点，则next指向右侧节点，如果是最右节点则next指向NULL
                Node* nextNode = que.front();
                if(i != size - 1) {
                    curNode->next = nextNode;
                } else {
                    curNode->next = NULL;
                }
            }
        }
        return root;
    }
};

• 117.填充每个节点的下一个右侧节点指针2

class Solution {
public:
    Node* connect(Node* root) {
        queue<Node*> que;
        if(root) {
            que.push(root);
            //头结点next指向NULL
            root->next = NULL;
        }
        while(!que.empty()) {
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                //获取当前节点，将当前节点的左右子节点入队
                Node* curNode = que.front();
                if(curNode->left) que.push(curNode->left);
                if(curNode->right) que.push(curNode->right);
                que.pop();
                //获取右侧节点，如果不是该层最后一个节点，则next指向右侧节点，如果是最右节点则next指向NULL
                Node* nextNode = que.front();
                if(i != size - 1) {
                    curNode->next = nextNode;
                } else {
                    curNode->next = NULL;
                }
            }
        }
        return root;
    }
};

• 104.二叉树的最大深度

class Solution {
public:
    int maxDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root) que.push(root);
        while(!que.empty()) {
            depth++;
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
        }
        return depth;
    }
};

• 111.二叉树的最小深度

class Solution {
public:
    int minDepth(TreeNode* root) {
        queue<TreeNode*> que;
        int depth = 0;
        if(root) que.push(root);
        while(!que.empty()) {
            depth++;
            int size = que.size();
            //这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            while(size--) {
                TreeNode* node = que.front();
                que.pop();
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
                //如果左右子树皆为空，说明为最小深度节点
                if(!node->left && !node->right) return depth;
            }
        }
        return depth;
    }
};

翻转二叉树

• 题目：Leetcode226
• 思路：
  • 递归：前序后序都可，以前序为例，先交换左右孩子，然后反转左子树，反转右子树。中序遍历可能存在把某些节点的孩子重复翻转的情况。
  • 迭代：，在遍历左右孩子前交换左右孩子

//递归，前序
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 == NULL) 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;
    }
};

对称二叉树

• 题目：Leetcode101
• 思路：
  • 对于二叉树是否对称，要比较的是根节点的左子树与右子树是不是相互翻转的，也就是说要比较的是两个树(根节点的左右子树)，那就要比较两个子树里侧与外侧元素是否相等。

•  
  • 递归：本题只能使用“后序遍历”，因为要通过递归函数的返回值来判断两个子树的内侧节点和外侧节点是否相等，一棵子树的遍历顺序为左右中，另一棵为右左中。
  • 迭代：使用队列或栈，依次比较

//递归
class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        //判断子节点为空以及数值不等而不对称的情况
        if(!left && right) return false;
        else if(left && !right) return false;
        else if(!left && !right) 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);
    }
};

//迭代
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;
    }
};

总结

层序的考法很灵活，层序很好用，前中后序的使用再练习

参考链接

代码随想录：层序遍历 翻转二叉树 对称二叉树