void traverse(Node* root)
{
queue<Node*> q;
Node* temp_node= root;
while(temp_node)
{
cout<<temp_node->value<<endl;
if(temp_node->left)
q.push(temp_node->left);
if(temp_node->right)
q.push(temp_node->right);
if(!q.empty())
{
temp_node = q.front();
q.pop();
}
else
temp_node = NULL;
}
}
以上发布的代码是我的级别订单遍历代码。这段代码对我来说很好，但我不喜欢的一件事是我明确地初始化temp_node = NULL或者我使用break。但它对我来说似乎不是一个好的代码。
是否有比这更好的实现或如何更好地使用此代码？
答案 0 :(得分：13)
void traverse(Node* root)
{
queue<Node*> q;
if (root) {
q.push(root);
}
while (!q.empty())
{
const Node * const temp_node = q.front();
q.pop();
cout<<temp_node->value<<"\n";
if (temp_node->left) {
q.push(temp_node->left);
}
if (temp_node->right) {
q.push(temp_node->right);
}
}
}
在那里，没有更特殊的情况。并且压痕被清理干净，因此可以更容易理解。
可替换地：
void traverse(Node* root)
{
queue<Node*> q;
if (!root) {
return;
}
for (q.push(root); !q.empty(); q.pop()) {
const Node * const temp_node = q.front();
cout<<temp_node->value<<"\n";
if (temp_node->left) {
q.push(temp_node->left);
}
if (temp_node->right) {
q.push(temp_node->right);
}
}
}
完成for循环。就个人而言，我喜欢额外的变量。变量名称比一直说'q.front（）`更简洁。
答案 1 :(得分：3)
您可以尝试这种方式：
struct Node
{
char data;
Node* left;
Node* right;
};
void LevelOrder(Node* root)
{
if(root == NULL) return;
queue<Node*> Q;
Q.push(root);
while(!Q.empty())
{
Node* current = Q.front();
cout<< current->data << " ";
if(current->left != NULL) Q.push(current->left);
if(current->right != NULL) Q.push(current->right);
Q.pop();
}
}
答案 2 :(得分：2)
现有代码存在一个严重问题，即在空树（root = NULL）上调用它时会崩溃。
您需要决定是否要在队列中包含NULL指针。
如果不是它们，则只能将非NULL值排入队列。
void traverse(Node* root) {
queue<Node*> q;
// no tree no level order.
if(root == NULL) {
return;
}
// push the root to start with as we know it is not NULL.
q.push(root);
// loop till there are nodes in the queue.
while(!q.empty()) {
// dequeue the front node.
Node *tmpNode = q.front();
q.pop();
// print it..we are sure it is not NULL.
cout<<tmpNode->value<<" ";
// enqueue left child if it exists.
if(tmpNode->left) {
q.push(tmpNode->left);
}
// enqueue right child if it exists.
if(tmpNode->right) {
q.push(tmpNode->right);
}
}
}
或者，如果您决定在队列中设置NULL，则可以执行以下操作：
void traverse(Node* root) {
queue<Node*> q;
// push the root..even if it is NULL.
q.push(root);
// loop till the queue is not empty.
while(!q.empty()) {
// dequeue the front node.
Node *tmpNode = q.front();
q.pop();
// the dequeued pointer can be NULL or can point to a node.
// process the node only if it is not NULL.
if(tmpNode) {
cout<<tmpNode->value<<" ";
q.push(tmpNode->left);
q.push(tmpNode->right);
}
}
}
第一种方法是首选方法，因为一棵大树有很多NULL个子节点（叶子节点的子节点），当我们以后只是不处理它们时，没有必要让它们排入队列。< / p>
答案 3 :(得分：1)
尝试：
void traverse(Node* root)
{
queue<Node*> q;
q.push(root);
while(!q.empty())
{
Node* temp_node = q.front();
q.pop();
if (temp_node == NULL)
{ continue;
}
cout << temp_node->value << endl;
q.push(temp_node->left);
q.push(temp_node->right);
}
}
答案 4 :(得分：1)
我认为上面的代码片段允许以数组格式打印级别顺序遍历。此代码可以帮助以级别顺序的形式编写解决方案。
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> a ;
vector<int> b;
if (root == NULL) return a;
std::queue<TreeNode *> q;
q.push(root);
int nodeCount ;
TreeNode* temp;
while(true){
nodeCount = q.size();
if (nodeCount == 0) break;
while(!nodeCount){
temp = q.front();
b.push_back(temp->val);
q.pop();
if(temp->left != NULL) q.push(temp->left);
if(temp->right!= NULL) q.push(temp->right);
nodeCount-- ;
}
a.push_back(b);
b.resize(0);
}
return a;
}
输出：
[ [1],
[2,3],
[4,5]
]
答案 5 :(得分：0)
使用队列数据结构和BFS算法的My Java解决方案：
void levelOrder(Node root) {
//LinkedList is class of Queue interface
Queue<Node> queue=new LinkedList<>();
queue.add(root);
//Using BFS algorithm and queue used in BFS solution
while(!queue.isEmpty()) {
Node node=queue.poll();
System.out.print(node.data+" ");
if(node.left!=null)
queue.add(node.left);
if(node.right!=null)
queue.add(node.right);
}
}
答案 6 :(得分：0)
#include<iostream>
#include<queue>
using namespace std;
struct node{
int data;
node *left,*right;
};
// function for creating nodes of the tree dynamically...
node * new_node(int item){
node *temp = new node();
temp->data = item;
temp->left = NULL;
temp->right = NULL;
}
//function to perform the level order tree traversal...
void level_order(node *temp){
queue <node*> q;
q.push(temp);
while(q.empty() == false){
temp = q.front();
cout<<temp->data<<endl;
if(temp->left != NULL ){
q.push(temp->left);
}
if(temp->right !=NULL){
q.push(temp->right);
}
q.pop();
}
}
int main(){
node *root = new node(); //Creating object of the structure node...
root = NULL;
root = new_node(4);
root->left = new_node(3);
root->right = new_node(2);
root->left->left = new_node(1);
level_order(root);
return 0;
}
答案 7 :(得分：0)
class Node():
def __init__(self,value):
self.value=value
self.left_node=None
self.right_node=None
class BTree():
def __init__(self):
self.root_node=None
self.pre_order_list=[]
def push_element(self,value):
node=Node(value)
if self.root_node is None:
self.root_node=node
return
else:
self.recursion_insert(value,self.root_node)
def recursion_insert(self,value,crnt_node):
node=Node(value)
if node.value<crnt_node.value:
if crnt_node.left_node is None:
crnt_node.left_node=node
elif crnt_node.left_node is not None and node.value>crnt_node.left_node.value:
crnt_node.left_node.right_node=node
else:
self.recursion_insert(value,crnt_node.left_node)
elif node.value>crnt_node.value:
if crnt_node.right_node is None:
crnt_node.right_node=node
elif crnt_node.right_node is not None and node.value<crnt_node.right_node.value:
crnt_node.right_node.left_node=node
else:
self.recursion_insert(value,crnt_node.right_node)
else:
print('Duplicate Values')
def print_preorder_traversal(self):
self.preOrder(self.root_node)
for i in self.pre_order_list:
print(i,end='->')
print('None')
def print_inorder_traversal(self):
self.in_order(self.root_node)
def print_post_order_traversal(self):
self.post_order(self.root_node)
def print_level_order_traversal(self):
self.level_order(self.root_node)
def preOrder(self,crnt_node):
if crnt_node:
self.pre_order_list.append(crnt_node.value)
#print(crnt_node.value,end='->')
self.preOrder(crnt_node.left_node)
self.preOrder(crnt_node.right_node)
def in_order(self,crnt_node):
if crnt_node:
self.in_order(crnt_node.left_node)
print(crnt_node.value,end='->')
self.in_order(crnt_node.right_node)
def post_order(self,crnt_node):
if crnt_node :
self.post_order(crnt_node.left_node)
self.post_order(crnt_node.right_node)
print(crnt_node.value)
def level_order(self,crnt_node):
queue_list=[]
queue_list.append(crnt_node.value)
while queue_list:
if crnt_node.left_node:
queue_list.append(crnt_node.left_node)
if crnt_node.right_node:
queue_list.append(crnt_node.right_node)
queue_list.pop(0)
print(crnt_node.value,end='->')
if queue_list:
crnt_node=queue_list[0]
tree_obj=BTree()
tree_obj.push_element(70)
tree_obj.push_element(31)
tree_obj.push_element(93)
tree_obj.push_element(34)
tree_obj.push_element(14)
tree_obj.push_element(23)
tree_obj.push_element(73)
tree_obj.push_element(94)
#tree_obj.print_preorder_traversal()
#tree_obj.print_inorder_traversal()
#tree_obj.print_post_order_traversal()
tree_obj.print_level_order_traversal()