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) {
    
    
        int result = 0;
        queue<TreeNode*> myQueue;
        deque<int> myDeque;
        myQueue.push(root);

        int size = myQueue.size();
        while(myQueue.size() > 0)
        {
    
    
            size = myQueue.size();
            for(int i=0 ; i<size ; i++)
            {
    
    
                TreeNode* tmp = myQueue.front();
                myQueue.pop();
                myDeque.push_back(tmp->val);
               
                if(tmp->left != nullptr) myQueue.push(tmp->left);
                else 
                {
    
    
                    TreeNode* left_tmp = new TreeNode(-1);
                    myQueue.push(left_tmp);
                }

                if(tmp->right != nullptr) myQueue.push(tmp->right);
                else 
                {
    
    
                    TreeNode* right_tmp = new TreeNode(-1);
                    myQueue.push(right_tmp);
                }
            }
           

            while(myDeque.front() == -1) myDeque.pop_front();
            if(myDeque.size() == 0) return result;
            while(myDeque.back() == -1) myDeque.pop_back();

            // for(auto it=myDeque.begin() ; it!=myDeque.end();it++)
            //     cout<<*it<<' ';
            // cout<<"cont:"<<myDeque.size();
            // cout<<endl;

            if(result < myDeque.size()) result = myDeque.size();
            myDeque.clear();

        }

        return result;
    }
};

高刷题（深度搜索）

假设根节点的编号为1，左子节点为2，右子节点为3……以此类推，会得出如下结论：

root的编号=N
root.left的编号=2 * N
root.right的编号=2 * N + 1

那么我们通过编号就可以计算同层中两个节点直接的距离了。我们还是以root = [1,3,2,5,null,null,9,6,null,7]为例，看看通过编号怎么去解题。

由于深度优先，是先从最上层沿着一条父子关系链遍历的下层，类似一个分支一个分支的去遍历，那么，我们就需要一个Map来帮助我们存储层级与当前层级最小值的对应关系了——即：key=level，value=minValue。那么，我们每当遍历一个节点时，就可以通过当前的level值去获取最小节点值：

如果Map中不存在该level的最小值，则将该节点的值放入到map中作为当前level下的最小值；
如果存在，那么则用当前节点值node.val减去从Map中获取的当前level下的最小值；

我们还是以root = [1,3,2,5,null,null,9,6,null,7]为例，看看通过深度优先怎么去解题。请见下图：

/**
 * 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:
    unordered_map<int,unsigned long long> myMap;
    unsigned long long result = 0;
    void dfs( TreeNode* cur , int level , unsigned long long indox )
    {
    
    
        if(cur == nullptr) return;
        if(myMap.count(level) == 0) myMap[level] = indox;

        result = max( result , indox - myMap[level]  + 1);

        dfs(cur->left , level+1 , indox*2);
        dfs(cur->right , level+1 , indox*2 + 1);
    }
    int widthOfBinaryTree(TreeNode* root) {
    
    
        dfs(root,0,1);
        return result;
    }
};