Java 树的左视图或右视图

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

例：-

1
/   \
左视图-->>47您是对的，具有像

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 Queue=new ArrayDeque（）；
for（Node=root；Node！=null；Node=queue.poll（））{
如果（node.leftChild！=null）queue.add（node.leftChild）；
如果（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;
}

Queue currentLevel=new ArrayDeque（）；
如果（root！=null）currentLevel.add（root）；
while（true）{
Node Node=currentLevel.poll（）；
如果（node==null）中断；
/*节点是其级别上最左侧的节点*/
Queue nextLevel=new ArrayDeque（）；
做{
如果（node.leftChild！=null）nextLevel.add（node.leftChild）；
如果（node.rightChild！=null）nextLevel.add（node.rightChild）；
node=currentLevel.poll（）；
}while（node！=null）；
currentLevel=nextLevel；
}
仅使用单个队列获取左（或右）视图并不困难。将最右边的子节点排队后，在队列中插入“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();
    }
}

类节点{
左、右淋巴结；
int值；
节点（int值）{
左=右=空；
这个值=值；
}
}
公共类二叉树
{
节根；
public void leftView（）{
//使用单队列。
布尔最左边=真；
if（this.root==null）返回；
队列q=新的LinkedList（）；
q、 添加（this.root）；
q、 添加（空）；
while（q.isEmpty（）==false）{
节点后部=q.poll（）；
如果（最左边==真）{
如果（后==null）中断；
System.out.print（rear.value+“”）；
最左=假；
}
如果（左后！=null）q.add（左后）；
如果（右后！=null）q.add（右后）；
如果（q.peek（）==null）{
最左=真；
q、 poll（）；//将其从后部卸下
q、 add（null）；//将其添加到前面。
}
}
//产出：1210250
}
公共静态void main（字符串[]args）引发java.lang.Exception
{
BinaryTree bt=新的BinaryTree（）；
bt.root=新节点（12）；
bt.root.left=新节点（10）；
bt.root.right=新节点（30）；
bt.root.right.left=新节点（25）；
bt.root.right.left.left=新节点（50）；
bt.root.right.right=新节点（40）；
//          12
//       /     \
//     10       30
//            /    \
//          25      40 
//         /
//       50
bt.leftView（）；
}
}
打印左视图的算法：

使用全局变量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);
   }

包com.Trees.sumit

导入java.util.LinkedList；
导入java.util.Queue

公共类左视图{

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;
}

publicstaticvoidmain（字符串[]args）{
//TODO自动生成的方法存根
TreeNode root=createBinaryTree（）；
Queue Queue=new LinkedList（）；
System.out.println（“左视图”）；
添加（根）；
而（！queue.isEmpty（））{
System.out.println（queue.peek（）.data）；
int queueSize=queue.size（）；
而（队列大小>0）{
TreeNode removedNode=queue.poll（）；
if（removedNode.left！=null）
添加（removedNode.left）；
if（removedNode.right！=null）
添加（removedNode.right）；
队列大小--；
}
}
}
公共静态类树节点{
int数据；
左树突；
特雷诺德右翼；
公共树节点（int数据）{
超级（）；
这个数据=数据；
}
}
私有静态树节点createBinaryTree（）{
//TODO自动生成的方法存根
TreeNode rootNode=新的TreeNode（40）；
TreeNode root20=新的TreeNode（20）；
TreeNode root10=新的TreeNode（10）；
TreeNode root30=新的TreeNode（30）；
TreeNode root50=新的TreeNode（50）；
TreeNode root55=新的TreeNode（55）；
TreeNode root57=新的TreeNode（57）；
TreeNode root60=新的TreeNode（60）；
TreeNode root70=新的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；
返回根节点；
}

}
无递归
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;
}