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

102. 二叉树的层序遍历

类型： #二叉树 #层序遍历
难度： #中等
题目：给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
思路：

1. 创建一个队列queue<TreeNode*> que，将二叉树的根节点入队。
2. 当队列不为空时，表示还有节点需要遍历，进入循环。
3. 获取当前队列中的节点数量size，表示当前层级的节点数量。
4. 创建一个 vector<int> vec，遍历当前层级的节点，将其值存入vec中，并将其子节点入队 。
5. 将vec存入结果result中。
6. 循环结束后，返回result。

实现：
cpp:

/**
 * 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>> res;

        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);
            }
            res.push_back(vec);
        }
        return res;
    }
};

go:用递归完成的

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */

func levelOrder(root *TreeNode) [][]int {
	arr := [][]int{}

	depth := 0

	var order func(root *TreeNode, depth int)

	order = func(root *TreeNode, depth int) {
		if root == nil {
			return
		}
		if len(arr) == depth {
			arr = append(arr, []int{})
		}
		arr[depth] = append(arr[depth], root.Val)

		order(root.Left, depth+1)
		order(root.Right, depth+1)
	}

	order(root, depth)

	return arr
}

226.翻转二叉树

类型： #二叉树
难度： #简单
题目：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
思路：

用前序遍历，递归三部曲：

1. 参数传节点指针，不需要返回值
2. 节点为空返回
3. 前序遍历，先交换左右孩子节点，然后翻转左子树，翻转右子树

实现：

/**
 * 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:
    void invert(TreeNode* cur){
        if(cur == NULL) return;
        swap(cur->left, cur->right);
        invert(cur->left);
        invert(cur->right);
    }
    TreeNode* invertTree(TreeNode* root) {
        invert(root);
        return root;
    }
};

101. 对称二叉树

类型： #二叉树
难度： #简单
题目：给你一个二叉树的根节点 root ， 检查它是否轴对称。
思路：比较两棵子树是否对称，所以要同时遍历两棵树
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qT490L21-1677730612945)(…/…/…/assets/Pasted%20image%2020230302120556.png)]
遍历的顺序只能是后序遍历，因为要通过递归函数的返回值来判断两子树内侧节点和外侧节点是否相等。
所以一棵树是左右中，另一棵是中左右
三部曲：

1. 参数左右节点，返回值 bool
2. 排除掉节点为空的多种情况，剩下的就是左右不为空，比较，不同返回 false
   1. 左节点为空，右节点不为空，false
   2. 左不为空，右为空，false
   3. 左右都空，true
3. 处理左右节点不为空，数值相等的情况
   1. 比较外侧是否对称：传左节点左孩子，右节点右孩子
   2. 比较内侧是否对称：传左节点右孩子，右节点左孩子
   3. 都对称 true，一侧不对称 false
      实现：

/**
 * 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 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);
    }
};

/**
 * Definition for a binary tree node.
 * type TreeNode struct {
 *     Val int
 *     Left *TreeNode
 *     Right *TreeNode
 * }
 */
func defs(left *TreeNode, right *TreeNode) bool {
    if left == nil && right == nil {
        return true;
    };
    if left == nil || right == nil {
        return false;
    };
    if left.Val != right.Val {
        return false;
    }
    return defs(left.Left, right.Right) && defs(right.Left, left.Right);
}

func isSymmetric(root *TreeNode) bool {
    return defs(root.Left, root.Right);
}