LeetCode-662. 二叉树最大宽度

给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。

每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。

示例 1:

输入: 

           1
         /   \
        3     2
       / \     \  
      5   3     9 

输出: 4
解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。
示例 2:

输入: 

          1
         /  
        3    
       / \       
      5   3     

输出: 2
解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。
示例 3:

输入: 

          1
         / \
        3   2 
       /        
      5      

输出: 2
解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。
示例 4:

输入: 

          1
         / \
        3   2
       /     \  
      5       9 
     /         \
    6           7
输出: 8
解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。
注意: 答案在32位有符号整数的表示范围内。

/*
* 这个问题中的主要想法是给每个节点一个 position 值，如果我们走向左子树，
* 那么 position -> position * 2，如果我们走向右子树，那么 position -> positon * 2 + 1。
* 当我们在看同一层深度的位置值 L 和 R 的时候，宽度就是 R - L + 1。
*/


#include<iostream>
#include<queue>
#include<algorithm>
using namespace std;

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


typedef struct depStruct {
	TreeNode* node;
	long depth;      //深度
	long position;   //左右宽度
	depStruct() :node(nullptr), depth(0), position(0) {}
}depS;


class Solution {
public:
	int widthOfBinaryTree(TreeNode* root) {
		int ans = 0;
		if (root == NULL) {
			return 0;
		}

		depS* node = new depS();
		node->node = root;
		node->depth = 0;
		node->position = 1;

		qNode.push(node);

		while (!qNode.empty()) {
			long count = qNode.size();
			long left = qNode.front()->position;
			long right = 0;

			while (count--) {
				depS* tmp = qNode.front();
				right = tmp->position;
				//cout << tmp->node->val << ",";
				qNode.pop();

				if (tmp->node->left) {
					depS* l = new depS();
					l->node = tmp->node->left;
					l->depth = tmp->depth + 1;
					l->position = 2 * right - left;         //减去left防止数据过大
					qNode.push(l);
				}

				if (tmp->node->right) {
					depS* r = new depS();
					r->node = tmp->node->right;
					r->depth = tmp->depth + 1;
					r->position = 2 * right + 1 - left;   //减去left防止数据过大
					qNode.push(r);
				}

			}
			ans = max(right - left + 1, ans);
		}
		return ans;
	}

private:
	long max(long a, long b) {
		return a > b ? a : b;
	}

private:
	queue<depS*> qNode;

};