使用队列的二叉树级顺序遍历答案

【问题标题】：Binary Tree- Level Order Traversal using Queue使用队列的二叉树级顺序遍历
【发布时间】：2017-08-12 21:21:06
【问题描述】：

树遍历 :: 使用队列的级别顺序树遍历。

给我一个解决方案。

层次顺序树遍历

在进入较低级别之前，我们会访问一个级别上的每个节点。这种搜索称为广度优先搜索 (BFS)，因为在进入下一个深度之前，搜索树会在每个深度上尽可能地拓宽。

我想以 Level Order 遍历 二叉树，或者你可以说 BFS 但我想使用 Queue。

提前感谢您的帮助。

树形结构::

输出会像 ::

1 2 3 4 5

#include<stdio.h>
#include<stdlib.h>
struct node
{
    int data;
    struct node* left;
    struct node* right;
};

struct queue
{
    struct node* info;
    struct queue* next;
};

struct node* NewNode(int data)
{
    struct node* root=(struct node*)malloc(sizeof(struct node));
    root->left=NULL;
    root->right=NULL;
    root->data=data;
    return root;
}


void enqueue(struct queue** que,struct node* newnode)
{
    struct queue* qnode = (struct queue*)malloc(sizeof(struct queue));
    struct queue* temp=*que;
    qnode->info=newnode;
    qnode->next=NULL;
    if(*que==NULL)
    {
        *que=qnode;
        return;
    }
    while(temp!=NULL)
        temp=temp->next;
    temp->next=qnode;
}
struct node* dequeue(struct queue** que)
{
    if(que!=NULL){
        struct node* a=*que->info;
        *que=*que->next;
        return a;
    }
    return NULL;
}



void levelorder(struct node* root)
{

    struct queue* que=(struct queue*)malloc(sizeof(struct queue));
    struct node* temp=root;
    while(temp)
    {
        printf("%d\t",temp->data);
        if(temp->left)
            enqueue(&que,temp->left);
        if(temp->right)
            enqueue(&que,temp->right);
        temp=dequeue(&que);
    }
}
int main()
{
    struct node* root=NewNode(1);
    root->left             = NewNode(2);
    root->right           = NewNode(3);
    root->left->left     = NewNode(4);
    root->left->right   = NewNode(5);

    levelorder(root);
    return 0;
}

【问题讨论】：

这不是问题。这是一个问题和答案的网站——你需要自己调试，得出一个假设，然后提出一个精确的问题。另外，使用问题编辑器中的代码格式化按钮。
@MarcusMüller 谢谢你的回复.. 你能建议我一种使用队列实现二叉树级顺序遍历的方法吗？
没有。因为，这仍然不是一个精确的问题。你可以做得更好，我保证！进行调试，格式化代码，编写问题描述，查看我的第一条评论。
@MarcusMüller 好的，谢谢.. 我做到了。谢谢！

标签： data-structures tree queue traversal

【解决方案1】：

使用队列的二叉树级顺序遍历

我在这里声明了一个类型结构的队列。这是代码::

#include<stdio.h>
#include<stdlib.h>
struct Node
{
    int data;
    struct Node* left;
    struct Node* right;
};
struct Node* newnode(int data)
{
    struct Node* root=(struct Node*)malloc(sizeof(struct Node));
    root->left=NULL;
    root->right=NULL;
    root->data=data;
    return root;
}
struct Node* queue[100];
int rear=0;
int front=-1;
void enqueue(struct Node* node)
{
    queue[rear++]=node;
}
struct Node* dequeue()
{
    return queue[++front];
}
void levelOrder(struct Node* root)
{
    struct Node* temp=root;
    while(temp)
    {
        printf("%d\t",temp->data);
        if(temp->left)
            enqueue(temp->left);
        if(temp->right)
            enqueue(temp->right);
        temp=dequeue();
    }
}
int main()
{
    struct Node* root   =    newnode(2);
    root->left          =    newnode(3);
    root->right         =    newnode(4);
    root->left->left    =    newnode(7);
    root->left->left->left = newnode(1);

    levelOrder(root);
    return 0;
}

【讨论】：