Question

我只是尝试了一些代码，而不是经验丰富的编码器。我实现了（至少认为）Level Order遍历，并且它很容易完成。想知道它是否是正确的方法。

#include<iostream>
#include<queue>
using namespace std;

class node {
public :
  node *right;
  node *left;
  int info;
}*root;

queue<int> inf;

void bfs(node *t)
{
if(t!=NULL)
{
    if(t->right!=NULL)
        inf.push(t->right->info);

    if(t->left!=NULL)
        inf.push(t->left->info);

    bfs(t->right);
    bfs(t->left);
}
}

int main()
{
node *temp = new node();
temp->info = 1;

root = temp;

root->right = new node();
root->right->info = 2;
root->right->right = root->right->left = NULL;

root->left = new node();
root->left->info = 3;
root->left->right = root->left->left = NULL;

node *tmp = root;
root=root->right;

root->right = new node();
root->right->info = 4;
root->right->right = root->right->left = NULL;

root->left = new node();
root->left->info = 5;
root->left->right = root->left->left = NULL;

root = tmp;
root = root->left;

root->right = new node();
root->right->info = 6;
root->right->right = root->right->left = NULL;

root->left = new node();
root->left->info = 7;
root->left->right = root->left->left = NULL;

root = temp;


node *it;
it = root;

inf.push(root->info);


bfs(root);
for(;inf.size()!=0;)
{
    cout<<inf.front()<<" : ";
    inf.pop();
}

return 0;

}

Answer 1

是的，你做得很好，但是您正在实施DFS算法。因为“it goes deeper until it reaches to a leaf and then back tracks.”

将for更改为一段时间更清晰：

while(inf.size())
{
    cout<<inf.front()<<" : ";
    inf.pop();
}

Answer 2

这使用std::queue<int>以DFS顺序打印节点！只是在某处使用队列不会使遍历顺序BFS。你想要的是std:: queue<node*>放置根节点的地方。然后在队列不为空时进行迭代，并在每次迭代中将下一个节点从队列中取出并将其子节点放入队列中：

for (std::queue<node*> inf(1, root); !inf.empty(); inf.pop()) {
    n = inf.front();
    process(n->info);
    if (n->left) inf.push(n->left);
    if (n->right) inf.push(n->right);
}

只是几点说明：

不要在容器上使用size()来确定是否存在元素：例如遍历元素来计算它们（虽然没有标准容器可以）和empty()说出你真正想知道的东西（尽管它应该被称为is_empty()）。
不要使用全局变量。
您的程序似乎泄漏了所有node个对象。
您应该为node类提供一个构造函数来初始化子项和info的指针。

Answer 3

您正在填充队列，但您没有在遍历树时使用它。您稍后使用它按照您访问过的顺序打印节点，但此顺序是DFS而不是BFS。此外，您可以在这种简单的情况下立即打印节点，目前不需要队列。

这是C ++中的实际DFS算法，如伪代码：

queue q;
q.push_back( tree.root() );

while( !q.empty() ) {
  node n = q.pop_front();
  // Visit n here (i.e. print it in your case)
  for all( c in n.children() ) {
    q.push_back( c );
  }
}

正如您所看到的，BFS没有任何递归调用。

如果使用递归，这通常意味着使用简单的可用堆栈数据结构。但是对于BFS，您希望使用实际队列。您的实现大致相当于以下算法（我只是通过实际显式堆栈替换了递归）：

stack s;
s.push( tree.root() );

while( !s.empty() ) {
   node n = s.pop();
  // Visit n here (i.e. print it in your case)
  for all( c in n.children() ) {
    s.push( c );
  }
}

它非常相似，但它通过使用堆栈来改变顺序。

二叉树BFS的队列

3 个答案: