LeetCode每日一题2021-7-31 987. 二叉树的垂序遍历

LeetCode 987. 二叉树的垂序遍历
题目描述
给你二叉树的根结点 root ，请你设计算法计算二叉树的 垂序遍历 序列。
对位于 (row, col) 的每个结点而言，其左右子结点分别位于 (row + 1, col - 1) 和 (row + 1, col + 1) 。树的根结点位于 (0, 0) 。
二叉树的 垂序遍历 从最左边的列开始直到最右边的列结束，按列索引每一列上的所有结点，形成一个按出现位置从上到下排序的有序列表。如果同行同列上有多个结点，则按结点的值从小到大进行排序。
返回二叉树的 垂序遍历 序列。

提示：

树中结点数目总数在范围 [1, 1000] 内
0 <= Node.val <= 1000

解题思路
本题目的是要给二叉树的每个节点标记一个位置信息（x,y)，最终要按列返回，即y相同的为一组，需要注意的是有些结点的位置信息会相同重复，位置相同的结果中要按升序排序。
本文按照层次遍历二叉树，在遍历过程中给每个节点标记位置信息，然后从上到下（从根到叶子节点）把在同一列（y相同）的解点再组成一个链表，最后遍历每个列链表便能得到最终结果。
题解代码

/**
 * 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 {
    struct AnsNode {
        int val;
        int x;
        AnsNode *next;
        AnsNode() : val(0), x(0), next(nullptr) {}
        AnsNode(int val,int x) : val(val), x(x), next(nullptr) {}
  };
public:
    vector<vector<int>> verticalTraversal(TreeNode* root) {
        AnsNode* nodeListHead[2001];
        AnsNode* nodeListNow[2001];
        for(int i=0;i<2001;i++){
            nodeListHead[i]=NULL;
            nodeListNow[i]=NULL;
        }
        queue<TreeNode*> q;
        queue<int> nodeY;
        q.push(root);
        nodeY.push(0);

        int levelX = -1;
        while(q.empty()!=true){
            int levelNum = q.size();
            levelX+=1;
            for (int i=0;i<levelNum;i++){
                TreeNode* tmp = q.front();
                int nodeYTmp = nodeY.front();
                int nodeIndex = nodeYTmp + 1000;
                AnsNode* nodeTmp = new AnsNode(tmp->val,levelX);
                if(nodeListNow[nodeIndex]==NULL){
                    nodeListHead[nodeIndex] = nodeTmp;
                    nodeListNow[nodeIndex] = nodeTmp;
                }else{
                    nodeListNow[nodeIndex]->next = nodeTmp;
                    nodeListNow[nodeIndex] = nodeTmp;
                }
                if (tmp->left != NULL){
                    q.push(tmp->left);
                    nodeY.push(nodeYTmp-1);
                }
                if(tmp->right != NULL){
                    q.push(tmp->right);
                    nodeY.push(nodeYTmp+1);
                }
                q.pop();
                nodeY.pop();
            }
        }
        vector<vector<int>> ans;
        for(int i=0;i<2001;i++){
            if(nodeListHead[i]!=NULL){//记录本列
            /*
                AnsNode* testNode = nodeListHead[i];
                cout<<(i-1000)<<"列: ";
                while(testNode!=NULL){
                    cout<<testNode->val<<" ";
                    testNode = testNode->next;
                }
                cout<<endl;
            */
                vector<int> tmp;
                AnsNode* node = nodeListHead[i];
                while(node!=NULL){
                    vector<int> sameList;
                    sameList.push_back(node->val);
                    while(node->next!=NULL && node->x==(node->next)->x){
                        node = node->next;
                        sameList.push_back(node->val);
                    }
                    sort(sameList.begin(),sameList.end());
                    for(int ii=0;ii<sameList.size();ii++){
                        tmp.push_back(sameList[ii]);
                    }
                    node = node->next;

                }
                ans.push_back(tmp);
            }
        }
        return ans;
    }
};