LeetCode 662. 二叉树最大宽度

广度优先，层序遍历

/**
 * 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:
    int widthOfBinaryTree(TreeNode* root) {
        if(!root)
            return 0;

        unsigned long long res = 1;

        // 记录每层的节点，以及节点下标
        vector<pair<TreeNode*, unsigned long long>> level_tree;
        level_tree.emplace_back(root, 1);

        // 逐层遍历
        while(!level_tree.empty())
        {
            // 当前层下一层的节点
            vector<pair<TreeNode*, unsigned long long>> tmp;
            for(auto& [node, index] : level_tree)
            {
                if(node->left)
                    tmp.emplace_back(node->left, index*2);
                if(node->right)
                    tmp.emplace_back(node->right, index*2+1);
            }
            // 当前层的宽度：最右边节点下标-最左边节点下标
            res = max(res, level_tree.back().second - level_tree[0].second + 1);
            // 将下一层move到当前层
            level_tree = move(tmp);
        }
        return res;
    }
};

深度优先，递归

/**
 * 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) {}
 * };
 */
/**
 * 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 {
    unordered_map<int,unsigned long long> level_min_index;
public:
    unsigned long long dfs(TreeNode* root, int depth, unsigned long long index)
    {
        if(!root)
            return 0LL;
        // 由于每次递归先遍历的左子树
        // 所以每个深度第一次出现的一定是本层最左边的值
        if(!level_min_index[depth])
            level_min_index[depth] = index;
    
        return max(index - level_min_index[depth] + 1LL, max(dfs(root->left, depth+1, index*2), dfs(root->right, depth+1, index*2+1)) );
    }
    int widthOfBinaryTree(TreeNode* root) {
        return dfs(root, 1, 1LL);
    }
};