二叉树的垂直顺序遍历

Posted 2023-02-21

【中文标题】二叉树的垂直顺序遍历

【英文标题】：Vertical order traversal of binary tree

【发布时间】：2017-06-04 04:22:40

【问题描述】：

我正在尝试执行，如下所示： 1）找出每个节点到根节点的最小和最大水平距离 2）创建一个将水平距离映射到相应节点的哈希图（Map>）

但是我得到了不想要的输出，我认为实现中有问题，因为算法对我来说似乎是正确的。

完整代码如下：

 import java.util.*;

class Node
    int data;
    Node right;
    Node left;
    Node(int data)
        this.data = data;
    


class Min_Max
    int min;
    int max;
    Min_Max(int min, int max)
        this.min=min;
        this.max=max;
    


class VerticalOrderTraversalUsingHashing

    public static void findMinMax(Node root,Min_Max obj, int hd)

        if(root==null)
            return;

        if(hd > obj.max)
            obj.max = hd;
        else if(hd < obj.min)
            obj.min = hd;

        findMinMax(root.left, obj, hd-1);
        findMinMax(root.right, obj, hd+1);
    

    public static void verticalOrderTraversal(Node root, Map<Integer,Vector<Integer>> map,int hd)

        if(root == null)
            return;
        if(map.get(hd)==null)
            Vector<Integer> temp = new Vector<>();
            temp.add(root.data);
            map.put(hd,temp);
         else 
            Vector<Integer> temp = map.get(hd);            
            temp.add(root.data);
            map.put(hd,temp);
        
    
    public static void main(String [] args)
        Node root = new Node(12);
        root.left = new Node(6);
        root.right = new Node(19);
        root.left.right = new Node(8);
        root.left.left = new Node(-23);
        root.right.left = new Node(18);
        root.right.right = new Node(52);

        Min_Max obj = new Min_Max(99999, -99999);
        findMinMax(root, obj, 0);

        Map<Integer,Vector<Integer>> map = new HashMap<>();

        for(int  i=obj.min;i<=obj.max;i++)
            Vector <Integer> v = new Vector<>();
            v.add(99999);//dummy node to initialize the map
            map.put(i,v);
        

        verticalOrderTraversal(root, map, 0);

        Set keys = map.keySet();
        Iterator itr=keys.iterator();

        System.out.println(map); 
    

输出：-1=[99999], 0=[99999, 12], -2=[99999], 1=[99999], 2=[99999] 那么我的方法有什么问题呢？

【问题讨论】：

你理解的水平距离是多少？

@TimBiegeleisen 它基本上是节点到根节点的距离......左子节点在第 0 层的根节点的水平距离为负数，而右子节点的水平距离为正数。跨度>

最低高清在这里有意义吗？ root 节点 hd 为 0 显然是最小的。

@Xlee Nope..root 不是最小值.. 例如，如果根有一个左孩子....它与根节点的水平距离将是-1..类似地，如果根孩子的左孩子有一个左孩子和右孩子......那么他们的水平距离将分别为-2和0......因此最左边的孩子将有最小的水平距离......

【参考方案1】：

您可以做一个 bfs 并在左侧添加 -1 并在右侧添加 +1。 然后，您可以继续将结果添加到 TreeMap 中，然后将所有值添加到结果中。

class Solution 
    public List<List<Integer>> verticalOrder(TreeNode root) 
        List<List<Integer>> result = new ArrayList<>();
        if(root == null)  return result; 
        Map<Integer, List<Integer>> map = new TreeMap<>();
        helper(root, map);
        result.addAll(map.values());
        return result;
    
    
    private void helper(TreeNode root, Map<Integer, List<Integer>> map) 
        Queue<TreeNode> q1 = new LinkedList<>();
        Queue<Integer> q2 = new LinkedList<>();
        
        q1.offer(root);
        q2.offer(0);
        
        while(!q1.isEmpty()) 
            TreeNode curr = q1.poll();
            int order = q2.poll();
            
            List<Integer> list = map.getOrDefault(order, new ArrayList<>());
            list.add(curr.val);
            map.put(order, list);
            
            if(curr.left != null) 
                q1.offer(curr.left);
                q2.offer(order - 1);
            
            
            if(curr.right != null) 
                q1.offer(curr.right);
                q2.offer(order + 1);