C++ 二叉树BFS的队列

我只是在尝试一些代码，不是一个有经验的程序员。我实现了（至少我认为是）级别的顺序遍历，而且很容易就完成了。想知道这是否是正确的方法

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

#包括
#包括
使用名称空间std；
类节点{
公众：
节点*右；
节点*左；
国际信息；
}*根；
队列inf；
无效bfs（节点*t）
{
如果（t！=NULL）
{
如果（t->right！=NULL）
inf.push（t->右->信息）；
如果（t->left！=NULL）
inf.push（t->左->信息）；
bfs（t->右）；
bfs（t->左）；
}
}
int main（）
{
node*temp=新节点（）；
温度->信息=1；
根=温度；
根->右=新节点（）；
根->右->信息=2；
根->右->右=根->右->左=空；
根->左=新节点（）；
根->左->信息=3；
根->左->右=根->左->左=空；
node*tmp=root；
根=根->右；
根->右=新节点（）；
根->右->信息=4；
根->右->右=根->右->左=空；
根->左=新节点（）；
根->左->信息=5；
根->左->右=根->左->左=空；
根=tmp；
根=根->左；
根->右=新节点（）；
根->右->信息=6；
根->右->右=根->右->左=空；
根->左=新节点（）；
根->左->信息=7；
根->左->右=根->左->左=空；
根=温度；
节点*it；
它=根；
inf.push（根->信息）；
bfs（根）；
对于（；inf.size（）！=0；）
{
是的，你做得很好，但是
您正在实现DFS算法。因为“”

换一段时间更干净：

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

while（inf.size（））
{
是的，你做得很好，但是
您正在实现DFS算法。因为“”

换一段时间更干净：

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

while（inf.size（））
{
cout这使用
std:：queue
以DFS顺序打印节点！仅在某处使用队列不会使遍历顺序成为BFS。您需要的是一个
std:：queue
，在其中放置根节点。然后在队列不为空的情况下进行迭代，在每次迭代中，将下一个节点从队列中取出，并将其子节点放入队列中队列：

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

for（std:：queue inf（1，root）；！inf.empty（）；inf.pop（））{
n=inf.front（）；
进程（n->info）；
如果（n->left）inf.push（n->left）；
如果（n->right）inf.push（n->right）；
}

请注意：

不要在容器上使用
size（）
来确定是否有元素：例如，它可能会遍历元素以计数它们（尽管没有标准容器这样做），并且
empty（）
会说出您真正想知道的内容（尽管它应该被称为
is_empty（）
）
不要使用全局变量
您的程序似乎泄漏了所有
节点
对象
您应该给
节点
类一个构造函数来初始化子节点和
信息
的指针
这将使用
std:：queue
以DFS顺序打印节点！仅在某处使用队列不会使遍历顺序成为BFS。您需要的是一个
std:：queue
放置根节点的位置。然后在队列不为空的情况下进行迭代，在每次迭代中，您将下一个节点从队列中取出，并将其子节点放入队列：

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

for（std:：queue inf（1，root）；！inf.empty（）；inf.pop（））{
n=inf.front（）；
进程（n->info）；
如果（n->left）inf.push（n->left）；
如果（n->right）inf.push（n->right）；
}

请注意：

不要在容器上使用
size（）
来确定是否有元素：例如，它可能会遍历元素以计数它们（尽管没有标准容器这样做），并且
empty（）
会说出您真正想知道的内容（尽管它应该被称为
is_empty（）
）
不要使用全局变量
您的程序似乎泄漏了所有
节点
对象
您应该给
节点
类一个构造函数来初始化子节点和
信息
的指针
您正在填充队列，但在遍历树时没有使用它。稍后您将使用它按访问顺序打印节点，但此顺序是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，您希望使用实际队列。您的实现大致相当于以下算法（我只是用实际的显式堆栈替换了递归）：

它非常相似，但是它通过使用堆栈更改顺序。
您正在填充队列，但在遍历树时没有使用它。稍后您将使用它按访问顺序打印节点，但此顺序是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，您希望使用实际队列。您的实现大致相当于以下算法（我只是用实际的显式堆栈替换了递归）：

它非常相似，但是它通过使用堆栈来改变顺序。
我明白你的意思，我试图根据级别打印树中的值，即从级别0[根]到级别n[叶].但我明白你说的！谢谢。@Aadroid:是的，这是BFS遍历你的树的方式。每一层都是如此。但是你使用的是DFS，这首先会深入到深度。你使用的队列稍后只会打印节点，而不是以不同的顺序。我明白你的意思，我正试图以一种不同的方式打印值