二叉树的垂序遍历| vertical-order-traversal-of-a-binary-tree

/*
Sologala @github https://github.com/Sologala/LeetCode.git
LeetCode 二叉树的垂序遍历
| vertical-order-traversal-of-a-binary-tree

*/

给定二叉树，按垂序遍历返回其结点值。

对位于 (X, Y) 的每个结点而言，其左右子结点分别位于 (X-1, Y-1) 和 (X+1, Y-1)。

把一条垂线从 X = -infinity 移动到 X = +infinity ，每当该垂线与结点接触时，我们按从上到下的顺序报告结点的值（ Y 坐标递减）。

如果两个结点位置相同，则首先报告的结点值较小。

按 X 坐标顺序返回非空报告的列表。每个报告都有一个结点值列表。

示例 1：

输入：[3,9,20,null,null,15,7]
输出：[[9],[3,15],[20],[7]]
解释： 
在不丧失其普遍性的情况下，我们可以假设根结点位于 (0, 0)：
然后，值为 9 的结点出现在 (-1, -1)；
值为 3 和 15 的两个结点分别出现在 (0, 0) 和 (0, -2)；
值为 20 的结点出现在 (1, -1)；
值为 7 的结点出现在 (2, -2)。

示例 2：

输入：[1,2,3,4,5,6,7]
输出：[[4],[2],[1,5,6],[3],[7]]
解释：
根据给定的方案，值为 5 和 6 的两个结点出现在同一位置。
然而，在报告 "[1,5,6]" 中，结点值 5 排在前面，因为 5 小于 6。

##思路：

递归思路：

? 我们可以前序遍历这棵树，同时在遍历这颗树的时候记录下他的 一个下标比如 根节点的下标设为 0 当我们遍历 r->left 的时候就将 idx-1 当遍历 r->right 的时候就将 idx+1 。对于这个下标 我们用一个 hash 表 map<int,vector<int> > 来记录一下 并且将所有这个下标的 节点的值都存下来。 这样我们只需要 遍历这个 map 就能遍历每一列了。

? 但是题目要求我们每一列中数字需要按照一个层次的顺序来排序。因此我们在遍历的时候可以 保存一下它的 层次。最后在按照这个顺序来排序。

? 这里我使用了一个 unordered_map<TreeNode*,int> 来保存每个节点的树高。 这里出现顺序不一致的情况非常少， 如果用快排 会导致退化成冒泡。这里我直接就写成一个 冒泡，并且通过一个tag 来优化一下。

先来看 递归版本。

ac_code

class Solution {
public:
    map<int,vector<int> > m;// record idx
    unordered_map<int,int> h; //record high
    void preorder(int idx,TreeNode* root,int high){//前序遍历 记录位置 和层次
        if(!root) return;
        m[idx].push_back(root->val);
        h[root->val] = high;
        preorder(idx-1,root->left,high+1);
        preorder(idx+1,root->right,high+1);
    }
    void mysort(vector<int> &a){//每一列的 排序
        for(int i = 0;i<a.size();++i){
            bool tag= false;
            for(int j = a.size()-1;j>i;--j){
                if(h[a[j-1]]>h[a[j]]){
                    swap(a[j-1],a[j]);
                    tag= true;
                }
                else if(h[a[j-1]]==h[a[j]]&&a[j-1]>a[j]){
                    swap(a[j-1],a[j]);
                    tag= true;
                }
            }
            if(tag==false) break;
        }
    }
    
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        vector<vector<int>> ret;
        if(!root) return ret;
        
        preorder(0,root,0);   
        for(auto &it:m){
            mysort(it.second);
            ret.push_back(it.second);
        }
        return ret;
    }
};

非递归（快一点，空间少一点）

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
struct node{
    TreeNode* r;
    int idx,h;
};

class Solution {
public:
    map<int,vector<int> > m;
    unordered_map<int,int> h;
    void mysort(vector<int> &a){
        for(int i = 0;i<a.size();++i){
            bool tag= false;
            for(int j = a.size()-1;j>i;--j){
                if(h[a[j-1]]>h[a[j]]){
                    swap(a[j-1],a[j]);
                    tag= true;
                }
                else if(h[a[j-1]]==h[a[j]]&&a[j-1]>a[j]){
                    swap(a[j-1],a[j]);
                    tag= true;
                }
            }
            if(tag==false) break;
        }
    }
    
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        vector<vector<int>> ret;
        if(!root) return ret;
        //preorder(0,root,0);   
        stack<node> s;
        node temp = {root,0,0};
        s.push(temp);
        while(!s.empty()){
            temp = s.top();s.pop();
            m[temp.idx].push_back(temp.r->val);
            h[temp.r->val] = temp.h;
            node newnode;
            if(temp.r->left){
                newnode.r = temp.r->left;
                newnode.idx = temp.idx-1;
                newnode.h = temp.h+1;
                s.push(newnode);
            }   
            if(temp.r->right){
                newnode.r = temp.r->right;
                newnode.idx = temp.idx+1;
                newnode.h = temp.h+1;
                s.push(newnode);
            }  
        }
        for(auto &it:m){
            mysort(it.second);
            ret.push_back(it.second);
        }
        return ret;
    }
};