LeetCode 2415. 反转二叉树的奇数层

一、题目

1、题目描述

给你一棵?完美?二叉树的根节点?root?，请你反转这棵树中每个?奇数?层的节点值。

• 例如，假设第 3 层的节点值是?[2,1,3,4,7,11,29,18]?，那么反转后它应该变成?[18,29,11,7,4,3,1,2]?。

反转后，返回树的根节点。

完美?二叉树需满足：二叉树的所有父节点都有两个子节点，且所有叶子节点都在同一层。

节点的?层数?等于该节点到根节点之间的边数。

2、接口描述

?

/**
 * 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* reverseOddLevels(TreeNode* root) {
        
    }
};

3、原题链接

2415. 反转二叉树的奇数层

---

二、解题报告

1、思路分析

由于题目保证了二叉树为完美二叉树，也就是说满二叉树，所以我们把奇数层的节点的值对称位置进行交换即可，我们有两种选择：dfs/bfs

对于dfs，我们定义dfs(Node*l , Node*r , int level)，其中l和r是处于对称位置上的节点

那么如果level是奇数，我们就交换它们的值

否则dfs(l->right , r->left , level + 1)????????dfs(l->left, r->right?, level + 1)

这样我们保证了传入的两个节点参数一定是对称位置上的节点

对于bfs：用队列模拟dfs过程即可

2、复杂度

dfs：时间复杂度： O(N) 空间复杂度：O(N)

bfs：时间复杂度： O(N) 空间复杂度：O(N)

3、代码详解

dfs：

/**
 * 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:
typedef TreeNode Node;
    TreeNode* reverseOddLevels(TreeNode* root) {
        function<void(Node* , Node* , int)> dfs = [&](Node* l , Node* r , int level){
            if(!l && !r) return;

            if(level & 1) swap(l -> val , r -> val);
            dfs(l->right,r->left,level+1);
            dfs(l->left,r->right,level+1);
        };
        dfs(root->left,root->right,1);
        return root;
    }
};

?bfs：

/**
 * 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:
typedef TreeNode Node;
    TreeNode* reverseOddLevels(TreeNode* root) {
        queue<Node*> q;
        if(root->left){
        q.push(root -> left);q.push(root -> right);}
        int level = 1;

        while(q.size())
        {
            for(int i = 0 , n = q.size() / 2 ; i < n ; i++)
            {
                Node* l = q.front();q.pop();
                Node* r = q.front();q.pop();
                if(level & 1)
                {
                    swap(l->val,r->val);
                }
                if(l->right){
                q.push(l->right);
                q.push(r->left);
                q.push(l->left);
                q.push(r->right);
                }
            }
            level++;
        }
        return root;
    }
};