数据结构 C 代码 x: 二叉树层次遍历的队列实现

已于 2024-04-07 10:52:09 修改
阅读量647 收藏 1
点赞数
分类专栏： 数据结构 C 代码 文章标签： 数据结构 二叉树
于 2021-05-27 10:46:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minfanphd/article/details/117323632
版权

本贴为《数据结构》课程服务.

1. 主要内容

  1. 二叉树的层次遍历.
  2. 使用队列

2. 代码

2.1 李毛毛

说明:

  1. 几种遍历方式集成在一个程序里, 我就偷懒没把它们分开.
  2. 队列应该叫做 enqueue, dequeue, 栈的操作才是 push, pop.
// 李毛毛

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

typedef struct BinTreeNode
{
    char data;
    struct BinTreeNode *leftChild;
    struct BinTreeNode *rightChild;
}*myTree;

//函数申明
void CreateBinTree(myTree tree);

//二叉树递归遍历
void preorderTraversal(myTree tree); //（中左右）
void inorderTraversal(myTree tree);  //（左中右）
void orderTraversal(myTree tree);    //（右中左）

//二叉树的栈（非递归）遍历
void PreOrder_NoRecurve1(myTree p); //先序遍历
void InOrder_NoRecurve(myTree p);   //中序遍历
void PostOrder_NoRecurve(myTree p); //后序遍历

//二叉树的队列（非递归）遍历
void LevelOrder(myTree p);

int main()
{
    cout<<"请输入你要创建的二叉树（以#结束）:";
    myTree root = NULL;
    CreateBinTree(root);
    return 0;
}

//使用广义表创建二叉树函数,这里以“字符”创建二叉树,以'#'字符代表结束
void CreateBinTree(myTree root)
{
    stack<myTree> s;
    int k;           //k是处理左、右子树的标记
    myTree p,t;      //p用来记住当前创建的节点，t用来记住栈顶的元素
    char ch;
    cin>>ch;

    while(ch != '#')
    {
        switch(ch)
        {
        case '(':       //对(做处理
            s.push(p);
            k=1;
            break;

        case ')':      //对)做处理
            s.pop();
            break;

        case ',':      //对,做处理
            k=2;
            break;

        default:
            p = (myTree)malloc(sizeof(BinTreeNode));    //构造一个结点
            p->leftChild = NULL;
            p->rightChild = NULL;
            if (root == NULL)    //如果头节点是空
            {
                root = p;
                p->data = ch;
            }
            else if (k == 1)    //链入*t的左孩子
            {
                t = s.top();
                t->leftChild = p;
                p->data = ch;
            }
            else    //链入*t的右孩子
            {
                t = s.top();
                t->rightChild = p;
                p->data = ch;
            }
        }
        cin>>ch;
    }
    cout<<endl<<"采用递归遍历二叉树"<<endl;

    cout<<"使用中左右输出：";
    preorderTraversal(root);
    cout<<endl;
    cout<<"使用左中右输出：";
    inorderTraversal(root);
    cout<<endl;
    cout<<"使用左右中输出：";
    orderTraversal(root);

    cout<<endl<<endl<<"采用栈遍历二叉树："<<endl;

    cout<<"使用先序输出：";
    PreOrder_NoRecurve1(root);
    cout<<endl;
    cout<<"使用中序输出: ";
    InOrder_NoRecurve(root);
    cout<<endl;
    cout<<"使用后序输出：";
    PostOrder_NoRecurve(root);
    cout<<endl;

    cout<<endl<<"采用层次遍历（队列）二叉树：" <<endl;
    LevelOrder(root);
    cout<<endl;

}

/*myTree constructABinaryTree() {                        //创建一个二叉树
	myTree root = (myTree)malloc(sizeof(BinTreeNode));
	root->data = 5;
	root->leftChild = NULL;
	root->leftChild = NULL;
	myTree leftChild = (myTree)malloc(sizeof(BinTreeNode));
	leftChild->data = 7;
	leftChild->leftChild = NULL;
	leftChild->rightChild = NULL;
	root->leftChild = leftChild;
	myTree rightChild = (myTree)malloc(sizeof(BinTreeNode));
	rightChild->data = 6;
	rightChild->leftChild = NULL;
	rightChild->rightChild = NULL;
	root->rightChild = rightChild;
	myTree twoLeftChild = (myTree)malloc(sizeof(BinTreeNode));
	twoLeftChild->data = 4;
	twoLeftChild->leftChild = NULL;
	twoLeftChild->rightChild = NULL;
	leftChild->leftChild = twoLeftChild;
	myTree leftRightChild = (myTree)malloc(sizeof(BinTreeNode));
	leftRightChild->data = 3;
	leftRightChild->leftChild = NULL;
	leftRightChild->rightChild = NULL;
    leftChild->rightChild = leftRightChild;
	return root;
}*/

void preorderTraversal(myTree tree)
{
    cout << tree->data << "  ";
    if (tree->leftChild != NULL) preorderTraversal(tree->leftChild);
    if (tree->rightChild != NULL)preorderTraversal(tree->rightChild); //中左右
}

void inorderTraversal(myTree tree)
{

    if (tree->leftChild != NULL) inorderTraversal(tree->leftChild);   //左中右
    cout << tree->data << "  ";
    if (tree->rightChild != NULL)inorderTraversal(tree->rightChild);
}

void orderTraversal(myTree tree)                                       //左右中、
{

    if (tree->leftChild != NULL) orderTraversal(tree->leftChild);
    if (tree->rightChild != NULL)orderTraversal(tree->rightChild);
    cout << tree->data<<"  ";
}

void PreOrder_NoRecurve1(myTree p)     //先序遍历
{
    stack<myTree> s;
    s.push(NULL); /*最先push一个NULL，到最后一个结点没有左右子树时，
	栈里只有一个NULL了，令指针p指向这个NULL，再判断就会结束循环*/

    while (p!=NULL)
    {
        cout << p->data << "  ";
        if(p->rightChild!=NULL)    //预留右子树指针在栈中
        {
            s.push(p->rightChild);
        }

        if (p->leftChild!=NULL)    //进左子树
        {
            p = p->leftChild;
        }
        else    //左子树为空
        {
            p = s.top();
            s.pop();
        }
    }

}

void InOrder_NoRecurve(myTree p)       //中序遍历
{
    stack<myTree> s;
    do
    {
        while (p!=NULL)
        {
            s.push(p);
            p = p->leftChild;
        }
        if (!s.empty())
        {
            p = s.top();
            s.pop();
            cout << p->data << "  ";
            p = p->rightChild;
        }
    }
    while (p!=NULL||!s.empty());

}

void PostOrder_NoRecurve(myTree p)    //后序遍历
{
    if (p == NULL)
        return ;
    stack<myTree> s;
    s.push(p);
    myTree lastPop = NULL;
    while (!s.empty())
    {
        while (s.top()->leftChild != NULL)
            s.push(s.top()->leftChild);
        while (!s.empty())
        {
            //右叶子结点 || 没有右结点
            if (lastPop == s.top()->rightChild || s.top()->rightChild == NULL)
            {
                cout << s.top()->data << "  ";
                lastPop = s.top();
                s.pop();
            }
            else if (s.top()->rightChild != NULL)
            {
                s.push(s.top()->rightChild);
                break;
            }
        }
    }

}

void LevelOrder(myTree p)      //队列层次遍历
{
    queue<myTree> Q;
    Q.push(p);    //根节点进队
    myTree t;
    while (!Q.empty())
    {
        t = Q.front();    //t先记住队头,再将队头出队
        Q.pop();
        cout << t->data << "  ";    //访问队头元素的数据

        if (t->leftChild != NULL)
        {
            Q.push(t->leftChild);
        }

        if (t->rightChild != NULL)
        {
            Q.push(t->rightChild);
        }
    }
}

2.2 付乐兵

助教辜果推荐.

//付乐兵，202031061023，计算机类1班
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#define MAXSIZE 100
#define	TRUE 1
#define FALSE 0
#define YES 1
#define NO 0
#define ERROR 0
#define SUCCESS 1
typedef int QElemType;
typedef int Status;
typedef char TElemType;
typedef char ElemType;
typedef struct BiTNode
{
    TElemType data;          //结点元素
    struct BiTNode *lchild;    //左孩子指针
    struct BiTNode *rchild;    //右孩子指针
} BiTNode,*BiTree;
//-----------------------//
typedef struct StackNode
{
    BiTree Stack_data;		//栈的数据域存放树的结点
    struct StackNode *next;
} StackNode,*LinkStack;
//-----------------------//
typedef struct QNode
{
    BiTree QT;		 	//数据域存放树的结点
    struct QNode *next;
} QNode,*QueuePtr;
typedef struct
{
    QueuePtr front;		//队头指针
    QueuePtr rear;		//队尾指针
} LinkQueue;
//----------------------//
LinkStack InitStack(LinkStack &S);	//初始化
bool StackEmpty(LinkStack S);		//判空
void Push(LinkStack &S,BiTree e);	//入栈
BiTree Pop(LinkStack S);			//出栈
//-----------------------------------//
void InitBiTree(BiTree &T);
//构造空二叉树T
BiTree CreateBiTree(BiTree &T);
//创建二叉树
Status BiTreeEmpty(BiTree T);
//判断二叉树是否为空
BiTree frontNode(BiTree T);
//后序时前驱节点
void PreOrderTraverse(BiTree T);
//非递归算法先序遍历二叉树
void InOrderTraverse(BiTree T);
//非递归算法中序遍历二叉树
void PostOrderTraverse(BiTree T);
//非递归算法后序遍历二叉树
void LevelOrderTraverse(BiTree T);
//层序遍历二叉树

//---------------------//
void InitQueue(LinkQueue &Q);
//构造一个空队列Q
void EnQueue(LinkQueue &Q,BiTree T);
//入队
BiTree DeQueue(LinkQueue &Q);
//出队
//---------------------//

int main()
{
    BiTree T;
    InitBiTree(T);
    printf("测试样例:1,2,4,#,#,5,#,#,3,6,#,#,7,#,#\n");
    printf("请输入头结点:");
    CreateBiTree(T);
    printf("前序遍历\n");
    PreOrderTraverse(T);
    printf("\n");
    printf("中序遍历\n");
    InOrderTraverse(T);
    printf("\n");
    printf("后序遍历\n");
    PostOrderTraverse(T);
    printf("\n");
    printf("队列实现层次遍历\n");
    LevelOrderTraverse(T);
}
LinkStack InitStack(LinkStack &S)
{
    S=(StackNode*)malloc(sizeof(StackNode*));
    S->next=NULL;
    return S;
}
void Push(LinkStack &S,BiTree e)
{
    if(e)	//若树不为空
    {
        StackNode *p=(StackNode *)malloc(sizeof(StackNode));
        p->Stack_data=e;
        p->next=S->next;
        S->next=p;
    }
}
bool StackEmpty(LinkStack S)
{
    if(S==NULL)
        return false;
    else
        return S->next==NULL;
}
BiTree Pop(LinkStack S)
{
    if(StackEmpty(S))
    {
        printf("Stack is empty!\n");
        return NULL;
    }
    BiTree mid = S->next->Stack_data;
    LinkStack p = S->next;
    S->next = p->next;
    free(p);

    return mid;
}
//----------------------------------------//
void InitBiTree(BiTree &T)//构造空二叉树T
{
    T = NULL;
    printf("初始化成功！\n");
    return ;
}

BiTree CreateBiTree(BiTree &T)//创建二叉树
{
    TElemType ch;
    scanf("%c",&ch);
    getchar();			//吃掉回车键
    if(ch == '#')		//若输入#表示该位置为NULL
        return  NULL;
    T = (BiTree)malloc(sizeof(BiTNode));	//分配树结点
    if(!T)
        printf("失败\n");
    T->data = ch;

    printf("请输入%c的左子树：",T->data);
    T->lchild=	CreateBiTree(T->lchild);

    printf("请输入%c的右子树：", T->data);
    T->rchild = CreateBiTree(T->rchild);

    return T;
}

Status BiTreeEmpty(BiTree T)//判断二叉树是否为空
{
    if(T==NULL)
        return TRUE;
    else
        return FALSE;
}

BiTree frontNode(BiTree T)
{
    if (T->rchild)
        return T->rchild;
    return T->lchild;
}

void PreOrderTraverse(BiTree T)//栈实现先序遍历二叉树
{
    LinkStack stackTop;
    InitStack(stackTop);
    while(T)
    {
        //从根开始，往左遍历到头
        while(T)
        {
            printf("%c ", T->data);    	//遇到结点就输出
            Push(stackTop,T->rchild);   //将该节点的右节点进行压栈，压栈操作会自己判断数据是否有效
            T = T->lchild;    			//依次输出左节点
        }

        if (!StackEmpty(stackTop))		//若栈不为空
            T = Pop(stackTop);			//最近的右结点出栈
    }
}

void InOrderTraverse(BiTree T)	//堆栈实现中序遍历
{
    LinkStack stackTop;
    InitStack(stackTop);

    while(T || !StackEmpty(stackTop))
    {
        while(T)
        {
            Push(stackTop, T);
            T = T->lchild;
        }
        if (!StackEmpty(stackTop))
        {
            T = Pop(stackTop);
            printf("%c ", T->data);
            T = T->rchild;
        }
    }
}

void PostOrderTraverse(BiTree T)//栈后序遍历二叉树
{
    LinkStack stackTop;
    InitStack(stackTop);
    BiTree last = NULL;

    while(T || !StackEmpty(stackTop))
    {
        while(T)		//遍历左子树压栈
        {
            Push(stackTop, T);
            T = T->lchild;
        }
        if (!StackEmpty(stackTop))
        {
            BiTree judge = stackTop->next->Stack_data->rchild;
            if (judge)
            {
                T = judge;    //判断是否有右子节点，有就把它当做子树的根节点先行遍历
            }
            else
            {
                last = Pop(stackTop);    //如果没有右子节点，那说明为叶子节点，出栈
                printf("%c ", last->data);
                while(!StackEmpty(stackTop) && last == frontNode(stackTop->next->Stack_data))
                {
                    //当弹出一个叶子节点之后，需要将前驱节点已经弹出的全部都弹出
                    last = Pop(stackTop);
                    printf("%c ", last->data);
                }
                T = NULL;    //弹出前面的节点以后，说明该子树已经遍历完，不再进行重复遍历
            }
        }
    }
}

void InitQueue(LinkQueue &Q)
{
    Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));//此处不用->要用.
    if(!Q.front) exit(OVERFLOW);
    Q.front->next=NULL;
}

void EnQueue(LinkQueue &Q,BiTree T)		//入队
{
    QueuePtr p = (QueuePtr)malloc(sizeof(QNode));
    if(p == NULL)
        exit(0);
    else
    {
        p->QT = T;
        p->next = NULL;
        Q.rear->next = p;
        Q.rear = p;
        return ;
    }
}

BiTree DeQueue(LinkQueue &Q)	//出队
{
    QueuePtr p = Q.front->next;
    if(Q.front == Q.rear)
        return NULL;
    Q.front->next = p->next;
    if(Q.rear == p)
        Q.rear = Q.front;
    return p->QT;
}

void LevelOrderTraverse(BiTree T)//层序遍历二叉树
{
    BiTree t = NULL;
    LinkQueue Q;
    InitQueue(Q);
    if(T != NULL)
        EnQueue(Q,T);                      //若树不空，让根节点入队
    else
        return;
    while(Q.front != Q.rear)                 //队列不空
    {
        t = DeQueue(Q);                    	//元素出队
        printf("%c ",t->data);
        if(t->lchild != NULL)               //判断子左子树是否为空
            EnQueue(Q,t->lchild);           //不空则让它入队
        if(t->rchild != NULL)               //判断子右子树是否为空
            EnQueue(Q,t->rchild);          	//不空则让它入队
    }
    printf("\n");
    return;
}

3. 建议与意见

来拍砖吧!

闵帆
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
层次遍历二叉树
weixin_46314022的博客
11-17 1651
void HierarchyOrder(BiTreeNode* root) // 二叉树的层次遍历（队列实现） // 参数：二叉树根节点root // 输出：二叉树的层次遍历，中间没有空格，末尾不换行。 { // 请在这里补充代码，完成本关任务 /********** Begin *********/ queue<BiTreeNode*> q; if(root!=NULL) { q.push(root); } while(!
数据结构-C：二叉树的遍历
DaI253的博客
12-08 1098
数据结构-C：二叉树的遍历递归和非递归算法 这里使用严书中的严格封闭定义，中序遍历递归算法 二叉树定义 typedef int Status; typedef char ElemType; // 二叉树结点元素类型 typedef struct BiTNode{ // 二叉树结点结构 char data; // 结点数据 struct BiTNode *lchild;
层次遍历二叉树（C语言版）
sskdspdl的博客
08-27 2125
用C语言实现层次遍历二叉树
数据结构实验：二叉树遍历
qq_53216148的博客
12-03 9251
1、实验要求 实现功能：建立二叉树存储结构、求二叉树的先序遍历、求二叉树的中序遍历、求二叉树的后序遍历、求二叉树的层次遍历、求根到给定结点的路径。主控菜单： 1．建立二叉树存储结构 2．求二叉树的先序遍历 3．求二叉树的中序遍历 4．求二叉树的后序遍历 5．求二叉树的层次遍历 6．求根到给定结点的路径 0．退出系统 此外还要实现容错处理，检测任何不...
⌈C语言⌋ 用队列实现二叉树的层序遍历（广度优先搜索）
Dusong_的博客
12-28 1966
用纯C语言实现层序遍历+经典例题
代码实现层序遍历二叉树（C语言）
Prefectkn的博客
07-20 3201
本篇博客将介绍二叉树的层序遍历原理及代码实现。
二叉树的层序遍历以及队列的实现
qq_41934502的博客
06-12 2334
层序遍历的C语言实现
数据结构：二叉树的递归遍历（C++）
英雄爱吃土豆片的博客
10-05 747
前序遍历（图示）： 后序遍历（图示）： 代码实现： #include <iostream> using namespace std; struct TNode { int _val; TNode* _left; TNode* _right; TNode(int val):_val(val), _left(NULL), _right(NULL) {} }; class Tree { public: Tree(); ~Tree(); public: void P
c代码-二叉树的层次遍历（队列实现）
07-14
在IT领域，二叉树是一种基础且重要的...总之，通过队列实现的二叉树层次遍历是C语言编程中的一项基本技能，它能帮助理解和处理复杂的数据结构问题。理解这一概念并能够熟练编写相关代码，对于提升编程能力大有裨益。
数据结构课程设计报告-二叉树的遍历.docx
03-07
数据结构课程设计报告-二叉树的遍历 本报告基于二叉树的遍历方法，旨在通过递归和非递归两种方法创建一棵二叉树，并对其进行先序遍历、中序遍历、后序遍历及层次遍历，并求出该二叉树的深度和叶子结点数。同时，...
数据结构利用队列实现二叉树的层次遍历实验三
04-19
设计一个利用队列实现二叉树层次遍历的程序。假设二叉树结点的元素数据类型为字符型，二叉树以二叉链表存储。利用二叉树的递归结构性质，通过读取键盘输入的如图所示二叉树的先序序列，建立其二叉链表。
数据结构实验3 二叉树层次遍历 二叉树的层次遍历
07-05
二叉树层次遍历的实现可以使用队列来实现。队列是一种先进先出（FIFO）的数据结构，队列的操作包括入队、出队、取队头元素和判断队列是否为空或满。 在本实验中，我们使用了一个名为Queue的队列结构体来实现队列，...
利用队列实现对二叉树的层序遍历
qq_54190360的博客
09-28 554
二叉树层序遍历
【数据结构】——队列实现二叉树的功能
最新发布
Lehjy的博客
12-09 997
队列实现二叉树的层序遍历和判断是否是完全二叉树
二叉树的层序遍历算法
api_variable811的博客
09-12 314
二叉树的层序遍历算法是一种按照层级顺序访问节点的方法，它利用队列的先进先出特性来实现。通过遍历每一层的节点，并将其子节点入队，我们可以按照层级顺序获取二叉树中的节点值。在这篇文章中，我们将介绍如何实现二叉树的层序遍历算法，并给出相应的源代码。在每一次迭代中，我们首先取出队首节点，访问它，并将它的左右子节点（如果存在）依次入队。如果该节点存在右子节点，则将右子节点入队。变量记录当前层的节点数量，这是为了在内层循环中准确地遍历当前层的节点。以上示例中，我们创建了一个二叉树，并使用层序遍历算法对其进行遍历。
使用队列实现二叉树按层次遍历（C++）
yezaiwei的专栏
08-25 2576
背景：二叉树的遍历，在计算机专业课程《数据结构》中应该都学习过。但很可惜，我是半道出家，没有系统化学习过，呵呵~~ 最近看到一个题目，要求按层次遍历一颗二叉数，想检测一下自身的基本功底，所以就有了本文的诞生。   基本思想：首先将二叉树根节点入队列，然后开始逐个出队列操作，每出一个节点，就将该节点的左右孩子依次入队列，以此循环，直到所有的节点进行了“入队列--出队列”的操作为止。   例
【数据结构】二叉树的层序遍历(BFS)
Colorful___的博客
10-06 7576
层序遍历是一种广度优先搜索的遍历方式，适用于树结构。通过利用队列实现层序遍历，我们可以按照从上到下、从左到右的顺序逐层遍历树中的节点。层序遍历广泛应用于树的分析、最短路径寻找、二叉树的构建等场景。掌握层序遍历的原理和实现方法将对解决相关问题非常有帮助。
运用队列实现二叉树的按层遍历
10-19 783
在本人“二叉树的基本操作”这篇博文中运用编程之美中的思想用vector实现二叉树的按层遍历但是老感觉不是很好这次我又用法deque以队列的方式在此实现了层次遍历和大家分享一下。 首先说明一下思想： 1,构造二叉树：个人该觉向书上的那种构造太麻烦，所以我选择了二叉排序树的那种构造方法（当然没有经过旋转也就是说不是AVL或者红黑树）。 2,遍历，先将给节点入队列，然后在出队列之前先将其两个孩子入
二叉树的层序遍历（队列实现）
weixin_46272577的博客
04-26 1104
层序遍历函数 void LevelOrder(BinTree T) { queue<BinTree> q;//创建树类型的队列 if (T!=NULL) q.push(T);//树不为空，入队 while (q.size()) { if (T != NULL) { T = q.front();//获取队头 cout << q.front()->data << "->"; if (T->left != NULL) {//.
数据结构：二叉树遍历详解
“这是一份关于数据结构的英文教学课件，专注于树与二叉树的第二部分，涵盖了二叉树节点的抽象数据类型（ADT）以及遍历算法，包括层次遍历、前序遍历、中序遍历和后序遍历。课件讨论了递归和非递归两种遍历算法实现...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值