Question

提供树的左/右视图的有效代码是什么。

EX： -

                                1
                              /   \
     left view--->>          4     7                    <<--right view
                            / \   /
                           3   2  9
                                 /
                                8

此树的左视图是 - 1 4 3 8，右视图是 - 1 7 9 8

我尝试过水平顺序遍历，但如果树上有一些丢失的孩子，那么我很难找到水平的起点（在左视图的情况下）或终点（在右视图中），请提出建议

Answer 1

仅使用单个队列获取左（或右）视图并不困难。在将最右边的子节点排队后，在队列中插入“null”作为标记，以在执行水平顺序遍历时标记下一个（子级）级别的结束。

class Node{
    Node left, right;
    int value;
    Node(int value){
        left=right=null;
        this.value = value;
    }
}
public class BinaryTree
{
    Node root;
    public void leftView(){
        //Using single queue.
        boolean leftmost = true;
        if(this.root == null) return;
        Queue<Node> q = new LinkedList<>();
        q.add(this.root);
        q.add(null);
        while(q.isEmpty() == false){
            Node rear = q.poll();
            if(leftmost == true) {
                if(rear == null) break; 
                System.out.print(rear.value + " ");
                leftmost = false;
            }
            if(rear.left != null)  q.add(rear.left);
            if(rear.right != null) q.add(rear.right);
            if(q.peek() == null) {
                leftmost = true;
                q.poll();    //remove it from rear
                q.add(null); //add it at front.
            }
        }
        //OUTPUT : 12 10 25 50
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        BinaryTree bt = new BinaryTree();
        bt.root = new Node(12);
        bt.root.left = new Node(10);
        bt.root.right = new Node(30);
        bt.root.right.left = new Node(25);
        bt.root.right.left.left = new Node(50);
        bt.root.right.right = new Node(40);
        //          12
        //       /     \
        //     10       30
        //            /    \
        //          25      40 
        //         /
        //       50
        bt.leftView();
    }
}

Answer 2

你是对的，通过像

这样的水平顺序遍历

Queue<Node> queue = new ArrayDeque<Node>();
for (Node node = root; node != null; node = queue.poll()) {
    if (node.leftChild != null) queue.add(node.leftChild);
    if (node.rightChild != null) queue.add(node.rightChild);
}

很难知道一个级别结束而下一个级别何时开始。这可以通过使用两个队列来解决。

Queue<Node> currentLevel = new ArrayDeque<Node>();
if (root != null) currentLevel.add(root);
while (true) {
    Node node = currentLevel.poll();
    if (node == null) break;
    /* node is the leftmost on its level */
    Queue<Node> nextLevel = new ArrayDeque<Node>();
    do {
        if (node.leftChild != null) nextLevel.add(node.leftChild);
        if (node.rightChild != null) nextLevel.add(node.rightChild);
        node = currentLevel.poll();
    } while (node != null);
    currentLevel = nextLevel;
}

Answer 3

打印左视图的算法：

使用全局变量maxLevel来跟踪到目前为止所涵盖的最高级别。
现在，只要我们收到的级别高于maxLevel，我们就会打印该节点的值。
我们以预先订购的方式进行，以便在出现之前打印左边。

以下是最终代码：

class BinaryTree {

    class TreeNode {
        int data;
        TreeNode left;
        TreeNode right;

        public TreeNode(int data) {
            this.data=data;
        }
    }

    private static int maxLevel = -1;

    public static leftView(TreeNode root) {
       left_view(root, 0);
    }

    private static void left_view(BTNode root, int level) {
       if (root == null)
           return;

       if (level > maxLevel) {
           System.out.println(root.data);
           maxLevel = level;
       }

       left_view(root.left, level + 1);
       left_view(root.right, level + 1);
   }

Answer 4

package com.Trees.sumit;

import java.util.LinkedList; import java.util.Queue;

public class LeftView {

public static void main(String[] args) {
    // TODO Auto-generated method stub

    TreeNode root = createBinaryTree();
    Queue<TreeNode> queue = new LinkedList<>();
    System.out.println("Left View" );
    queue.add(root);
    while (!queue.isEmpty()) {

        System.out.println(queue.peek().data);

        int queueSize = queue.size();

        while (queueSize > 0) {

            TreeNode removedNode = queue.poll();


            if (removedNode.left != null)
                queue.add(removedNode.left);

            if (removedNode.right != null)
                queue.add(removedNode.right);



            queueSize--;
        }

    }

}

public static class TreeNode {

    int data;
    TreeNode left;
    TreeNode right;

    public TreeNode(int data) {
        super();
        this.data = data;
    }

}

private static TreeNode createBinaryTree() {
    // TODO Auto-generated method stub
    TreeNode rootNode = new TreeNode(40);
    TreeNode root20 = new TreeNode(20);
    TreeNode root10 = new TreeNode(10);
    TreeNode root30 = new TreeNode(30);
    TreeNode root50 = new TreeNode(50);
    TreeNode root55 = new TreeNode(55);
    TreeNode root57 = new TreeNode(57);

    TreeNode root60 = new TreeNode(60);
    TreeNode root70 = new TreeNode(70);

    rootNode.left = root20;
    rootNode.right = root60;

    root50.right = root55;
    root55.right = root57;

    root20.left = root10;
    root20.right = root30;

    root60.left = root50;
    root60.right = root70;

    return rootNode;
}

}

树的左视图或右视图

4 个答案: