从上往下打印出二叉树的每个结点,同一层的结点按照从左到右的顺序打印

题目:

解答:

首先创建BinaryTreeNode

 1 public class BinaryTreeNode {
 2     int data;
 3     BinaryTreeNode lchind;
 4     BinaryTreeNode rchind;
 5
 6     public BinaryTreeNode(int data) {
 7         this.data = data;
 8         lchind = null;
 9         rchind = null;
10     }
11
12     private int getData() {
13         return data;
14     }
15
16     private BinaryTreeNode getLchildNode() {
17         return lchind;
18     }
19
20     private void setLchildNode(BinaryTreeNode node) {
21         lchind = node;
22     }
23
24     private BinaryTreeNode getRchildNode() {
25         return rchind;
26     }
27
28     private void setRchildNode(BinaryTreeNode node) {
29         rchind = node;
30     }
31 }

接着:

 1 import java.util.*;
 2
 3 public class Solution {
 4
 5     public static void main(String[] args) {
 6         BinaryTreeNode node1=new BinaryTreeNode(8);
 7         BinaryTreeNode node2=new BinaryTreeNode(6);
 8         BinaryTreeNode node3=new BinaryTreeNode(10);
 9         BinaryTreeNode node4=new BinaryTreeNode(5);
10         BinaryTreeNode node5=new BinaryTreeNode(7);
11         BinaryTreeNode node6=new BinaryTreeNode(9);
12         BinaryTreeNode node7=new BinaryTreeNode(11);
13         node1.setLchildNode(node2);node1.setRchildNode(node3);
14         node2.setLchildNode(node4);node2.setRchildNode(node5);
15         node3.setLchildNode(node6);node3.setRchildNode(node7);
16
17         printFromTopToBottom(node1);
18     }
19
20     private static void printFromTopToBottom(BinaryTreeNode root) {
21         if(root == null) {
22             return;
23         }
24
25         Queue<BinaryTreeNode> queue = new LinkedList<BinaryTreeNode>();
26
27         queue.add(root);
28
29         while(!queue.isEmpty()) {
30             BinaryTreeNode node = queue.poll();
31             System.out.println(node.getData());
32
33             if(node.getLchildNode() != null) {
34                 queue.add(node.getLchildNode());
35             }
36
37             if(node.getRchildNode() != null) {
38                 queue.add(node.getRchildNode());
39             }
40         }
41     }
42 }

原文地址:https://www.cnblogs.com/wylwyl/p/10366253.html

时间: 2024-09-30 08:16:46

从上往下打印出二叉树的每个结点,同一层的结点按照从左到右的顺序打印的相关文章

16.输入一颗二元树,从上往下按层打印树的每个结点,同一层中按照从左往右的顺序打印

转载请注明出处:http://www.cnblogs.com/wuzetiandaren/p/4261605.html 声明:现大部分文章为寻找问题时在网上相互转载,此博是为自己做个记录记录,方便自己也方便有类似问题的朋友,本文的思想也许有所借鉴,但源码均为本人实现,如有侵权,请发邮件表明文章和原出处地址,我一定在文章中注明.谢谢. 题目:输入一颗二元树,从上往下按层打印树的每个结点,同一层中按照从左往右的顺序打印. 题目分析:可以用一个LinkedList的数据结构模拟队列来完成此操作.传入树

剑指offer22:从上往下打印出二叉树的每个节点,同层节点从左至右打印。

1 题目描述 从上往下打印出二叉树的每个节点,同层节点从左至右打印. 2 思路和方法 使用一个队列存放节点.先将根节点加入到队列中,然后循环遍历队列中的元素,遍历过程中,访问该节点的左右子节点,再将左右子节点加入到队列中. 例子:1 2 3 4 5 6 7 8 ? 对于第一层,只有根节点 1,第二层有节点2和3.先将根节点1加入到队列中,接下来要打印节点为1的两个子节点,应该在遍历到该根节点时把值为2和3的两个子节点保存到队列.按照从左向右打印的要求,取出2,保存其子节点4:随后取出3,保存其子

从上往下打印出二叉树的每个节点,同层节点从左至右打印。

1 /* 2 思路:借助栈来实现 3 树为空时 返回空 4 树不为空 将根节点如队列 5 然后将队列首元素出队列 如果该元素有左子节点那么左子节点入队了 如果该元素有右子节点那么右子节点入队列 6 最后 进队列的顺序也就是出队列的顺序 7 */ 8 import java.util.ArrayList; 9 import java.util.*; 10 import java.util.Iterator; 11 /** 12 public class TreeNode { 13 int val

(C++实现)从上往下打印出二叉树的每个节点,同层节点从左至右打印。

/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } };*/ class Solution { public: vector<int> PrintFromTopToBottom(TreeNode* root) { vector<int> a; queue<TreeNod

C++从上往下打印出二叉树的每个节点,同层节点从左至右打印(牛客剑指offer)

/* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<int> PrintFromTopToBottom(TreeNode *root) { queue<TreeNode *> Q; vector<

数据结构-从上往下打印二叉树

题目:从上往下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印. 分析:其实就是按层的遍历方式 #include <iostream> #include <deque> using namespace std; struct BinaryTree{ int data; BinaryTree* lchild; BinaryTree* rchild; }; void PrintLeverTree(BinaryTree* root){ if(root == NULL){ ret

【剑指Offer】面试题32 - I. 从上到下打印二叉树

题目 从上到下打印出二叉树的每个节点,同一层的节点按照从左到右的顺序打印. 例如: 给定二叉树:?[3,9,20,null,null,15,7], 3 / 9 20 / 15 7 返回: [3,9,20,15,7] 提示: 节点总数 <= 1000 思路 借助队列简单层次遍历. 代码 时间复杂度:O(n) 空间复杂度:O(n) class Solution { public: vector<int> levelOrder(TreeNode* root) { vector<int&g

从上往下打印二叉树(分层遍历)

从上往下打印二叉树的每个节点,同一层的节点按照从左到右的顺序打印. 从上到下打印二叉树的规律:每一次打印一个节点的时候,如果该节点有子节点,则把该节点的子节点放到一个队列的末尾.接下来到队列的头部取出最早进入队列的节点,重复前面的打印操作,直到队列中所有的节点都被打印出来为止. struct TreeNode { int val; TreeNode* left; TreeNode* right; }; void LevelOrder(BinaryTreeNode* root) { if (roo

从上往下打印二叉树——23

从上往下打印出二叉树的每个结点,同一层的结点按照从左到右的顺序打印.例如如下二叉树打印出的结果为1.2.3.4.5.6.7.8.9. 上面所说的也就是二叉树的层序遍历,对于层序遍历来说,首先访问的肯定是根节点,然后是其左右结点,之后就是左子树的左右结点和右子树的左右结点,依次往下,如果使用像前中后序遍历那样按照左右结点去递归打印的话肯定是不行的,因为并不能一直先访问某个左结点或者右结点,而是应该左右交叉访问: 上面的二叉树中,打印的顺序是1.2.3.4.5.6.7.8.9,可以想到按照队列的方式