代码随想录算法训练营第十五天 | 层序遍历 ， 226.翻转二叉树 ， 101.对称二叉树 2

Day 15

层序遍历

tips：

1.TreeNode*是用来定义二叉树的，有left和right两个节点

Node*是定义树的，用node->children[ i ]来说明孩子，node->children.size()表示孩子的长度。

2.如果找最大值，可以先让max=INT_MIN;（最小值），然后更新就可以了。

max= node->val > max ? node->val : max;

226 翻转二叉树

其实就是遍历二叉树的应用，这里面要注意的思路，只要将所有节点的左右孩子都交换就行，所以目标是遍历所有的节点并对每一节点进行操作（也就是交换左右孩子），所以才可以对原始的二叉树进行遍历。

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root==NULL) return root;
        stack<TreeNode*> st;
        if(root!=NULL) st.push(root);
        while(!st.empty()){
            TreeNode* node=st.top();
            if(node!=NULL){
                st.pop();
                if(node->right) st.push(node->right);
                if(node->left) st.push(node->left);
                st.push(node);
                st.push(NULL);
            }
            else{
                st.pop();
                node=st.top();
                st.pop();
                swap(node->left,node->right);
            }
        }
        return root;
    }
};

101.对称二叉树

思路：看其左右子树翻转后是否相同。

比较外侧与内侧，

递归法：其实就是遍历左子树，然后对应的遍历右子树。（而且我认为其实更像是前序遍历，每次都先处理根节点，然后再处理左右孩子。）

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;
        else{
            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;
            }
            if((!leftNode && rightNode) || (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;
    }
};