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

层序遍历

文档讲解：代码随想录

视频讲解：讲透二叉树的层序遍历 | 广度优先搜索 | LeetCode：102.二叉树的层序遍历_哔哩哔哩_bilibili

状态：通过

非递归法代码实现： 

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()){
			vector<int> vec;
			int size = que.size();
			for(int i = 0; i < size; i++){
				TreeNode* node = que.front();
				vec.push_back(node->val);
				que.pop();
				if(node->left) que.push(node->left);
				if(node->right) que.push(node->right);
			}
			result.push_back(vec);
		}
		return result;
	}
}; 

226.翻转二叉树

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

视频讲解：听说一位巨佬面Google被拒了，因为没写出翻转二叉树 | LeetCode：226.翻转二叉树_哔哩哔哩_bilibili

状态：未通过

递归写法：

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;
    }
};

层序遍历写法： 

class Solution {
public:
    TreeNode* invertTree(TreeNode* root) {
        if(root == NULL){
            return root;
        }
        queue<TreeNode*> que;
        que.push(root);
        while(!que.empty()){
            int size = que.size();
            while(size--){
                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.对称二叉树

题目链接：. - 力扣（LeetCode）

文档讲解：代码随想录

视频讲解：新学期要从学习二叉树开始！ | LeetCode：101. 对称二叉树_哔哩哔哩_bilibili

状态：未通过

解题思路：需要使用后续遍历的方法，先判断左右子树是否对称，然后根据子树的对称结果再进一步判断整个树是否对称。 

递归写法代码实现： 

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);
        return out && in;
    }
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        bool isSym = compare(root->left, root->right);
        return isSym;
    }
};

 非递归写法代码实现（队列）：

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* left = que.front();
            que.pop();
            TreeNode* right = que.front();
            que.pop();
            if(!left && !right) continue;
            if(!left || !right || left->val != right->val) return false;
            que.push(left->left);
            que.push(right->right);
            que.push(left->right);
            que.push(right->left);
        }
        return true;
    }
};

 非递归写法代码实现（栈）：

class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        if(root == NULL) return true;
        stack<TreeNode*> st;
        st.push(root->left);
        st.push(root->right);
        while(!st.empty()){
            TreeNode* left = st.top();
            st.pop();
            TreeNode* right = st.top();
            st.pop();

            if(!left && !right) continue;
            if(!left || !right || left->val != right->val) return false;

            st.push(left->left);
            st.push(right->right);
            st.push(left->right);
            st.push(right->left);
        }
        return true;
    }
};