leetcode刷题/每日一题 987. 二叉树的垂序遍历

987. 二叉树的垂序遍历

给你二叉树的根结点 root ，请你设计算法计算二叉树的 垂序遍历 序列。

对位于 (row, col) 的每个结点而言，其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1) 。树的根结点位于 (0, 0) 。

二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，则按结点的值从小到大进行排序。

返回二叉树的 垂序遍历 序列。

示例 1：

输入：root = [3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]
解释：
列 -1 ：只有结点 9 在此列中。
列  0 ：只有结点 3 和 15 在此列中，按从上到下顺序。
列  1 ：只有结点 20 在此列中。
列  2 ：只有结点 7 在此列中。

示例 2：

输入：root = [1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
列 -2 ：只有结点 4 在此列中。
列 -1 ：只有结点 2 在此列中。
列  0 ：结点 1 、5 和 6 都在此列中。
          1 在上面，所以它出现在前面。
          5 和 6 位置都是 (2, 0) ，所以按值从小到大排序，5 在 6 的前面。
列  1 ：只有结点 3 在此列中。
列  2 ：只有结点 7 在此列中。

示例 3：

输入：root = [1,2,3,4,6,5,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
这个示例实际上与示例 2 完全相同，只是结点 5 和 6 在树中的位置发生了交换。
因为 5 和 6 的位置仍然相同，所以答案保持不变，仍然按值从小到大排序。

解题思路:

思路过程:

问	答
怎么把相等的col值就放在一起?	hash表没跑了
相同col值有多个对于的值怎么办?	用map容器,第二个参数设置为vector容器
不同层的时候怎么确保层数小的在前面?	用层序遍历,可以确保小的层数在上面
如何记录它的坐标?	在层序遍历用的队列中,压入节点同时用一个数组来记录坐标值
怎么,确保同一层的时候value小的在前面?	用一个map来存储每一层的值,然后每一层不同值对应的数组都排序,再用另外一个map容器来存储排序后结果

• 这时候已经完成了本题,答题过程就是两个哈希表,一个来存储同一层的值,然后排序完给结果容器.因为层序遍历保证小的层数在前,同一层排序又能保证同一层小的值在前.这样就完成了. 代码如下:

/**
 * 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>> verticalTraversal(TreeNode* root){
	vector<vector<int>> res;
	if (!root)
		return res;
   //层序遍历模板
	queue<pair<TreeNode *,vector<int>>> que;
        
    //用来记录坐标
	vector<int> index{ 0,0 };
    
    //记录节点同时保存坐标
	que.push( make_pair(root, index));
        
    //同一层节点的哈希表
	map<int, vector<int>> hash;
    //最终结果的哈希表
	map<int, vector<int>> hash_res;
	while(!que.empty())
	{
        //层序遍历模板
		int size = que.size();
		for (int i = 0; i < size; i++)
		{
			if (que.front().first->left)
			{
                //压入节点同时记录它的坐标,左孩子节点左+1,右-1
				vector<int>index{ que.front().second[0] + 1, que.front().second[1] - 1 };
				que.push(make_pair(que.front().first->left, index));
			}
			if (que.front().first->right)
			{
                //右孩子左+1,右+1
				vector<int>index{ que.front().second[0] + 1, que.front().second[1] + 1 };
				que.push(make_pair(que.front().first->right, index));
			}
            //每个节点都压入同一层对应的哈希表
			hash[que.front().second[1]].push_back(que.front().first->val);
			que.pop();
		}
		for (auto it = hash.begin(); it != hash.end(); it++)
		{
            //上面得到的哈希表中排序,排序后再加入最终结果容器
			sort(it->second.begin(),it->second.end());
			hash_res[it->first].insert(hash_res[it->first].end(),it->second.begin(), it->second.end());
		}
        //每一层都清空
		hash.clear();
	}
        
    //哈希表转为vector<vector<int>>容器,得到结果
	for (auto it = hash_res.begin(); it != hash_res.end(); it++)
	{
		res.push_back(it->second);
	}
	return res;
    }
};

总结:

这道题是困难题,题本身难度不高,更多的是对容器的熟悉程度.利用map容器和层序遍历即可完成.难点就是怎么让同一层的值排在前面,我用的是一个map容器来暂存每一层结果,排序之后再加入结果容器.这样就可以保证小的值在前.