Day15 代码随想录| 10.层序遍历 ● 226.翻转二叉树 ● 101.对称二叉树

10.层序遍历

层序遍历方式就是图论中的广度优先遍历，使用队列

代码如下：

/**
 * 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:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=NULL)
            que.push(root);
        vector<vector<int>>result;
        while(!que.empty()){
            int size=que.size();
            vector<int>vec;
            for(int i=0;i<size;i++){
                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);

            }
            result.push_back(vec);
        }
        return result;

    }
};

226.翻转二叉树

递归法：

/**
 * 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:
    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) {
        stack<TreeNode*>st;
        if(root==NULL)
            return root;
        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.对称二叉树 

递归逻辑

• 比较二叉树外侧是否对称：传入的是左节点的左孩子，右节点的右孩子。
• 比较内侧是否对称，传入左节点的右孩子，右节点的左孩子。
• 如果左右都对称就返回true ，有一侧不对称就返回false

 代码如下

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 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 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;
        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->val!=rightnode->val))){
                return false;
            }
            que.push(leftnode->left);
            que.push(rightnode->right);
            que.push(leftnode->right);
            que.push(rightnode->left);
        }
        return true;
    }
};