C++层次遍历二叉树

#include <iostream>
#define maxSize 5
using namespace std;

typedef struct BTNode
{
    char data;
    struct BTNode * lchild;
    struct BTNode * rchild;
}BTNode;

BTNode * initBTNode()
{
    BTNode *node = (BTNode*)malloc(sizeof(BTNode));
    node->lchild=0;
    node->rchild=0;
    return node;
}

BTNode * init(BTNode *p)
{
    BTNode *A=initBTNode();
    BTNode *B=initBTNode();
    BTNode *C=initBTNode();
    BTNode *D=initBTNode();
    BTNode *E=initBTNode();
    BTNode *F=initBTNode();

    A->data=‘A‘;
    B->data=‘B‘;
    C->data=‘C‘;
    D->data=‘D‘;
    E->data=‘E‘;
    F->data=‘F‘;

    C->lchild=E;
    C->rchild=F;
    B->lchild=D;
    A->rchild=C;
    A->lchild=B;

    p=A;
    return p;
}

void visit(BTNode *p)
{
    cout << p->data << " ";
}

void preorder(BTNode *p)
{
    if(p!=0)
    {
        visit(p);
        preorder(p->lchild);
        preorder(p->rchild);
    }
}

void inorder(BTNode *p)
{
    if(p!=0)
    {
        inorder(p->lchild);
        visit(p);
        inorder(p->rchild);
    }
}

void postorder(BTNode *p)
{
    if(p!=0)
    {
        postorder(p->lchild);
        postorder(p->rchild);
        visit(p);
    }
}

void level(BTNode *p)
{
    int front,rear;
    BTNode *que[maxSize];
    front = rear = 0;
    BTNode *q;
    if(p!=0)
    {
        rear=(rear+1)%maxSize;
        que[rear]=p;
        while(front!=rear)
        {
            front = (front+1)%maxSize;
            q=que[front];
            visit(q);
            if(q->lchild!=0)
            {
                rear=(rear+1)%maxSize;
                que[rear]=q->lchild;
            }
            if(q->rchild!=0)
            {
                rear=(rear+1)%maxSize;
                que[rear]=q->rchild;
            }
        }
    }
}

int main(int argc, char* argv[])
{
    BTNode *node=new BTNode;
    BTNode *p=init(node);
    cout << "先序遍历：" ;
    preorder(p);
    cout << endl;
    cout << "中序遍历：" ;
    inorder(p);
    cout << endl;
    cout << "后序遍历：" ;
    postorder(p);
    cout << endl;
    cout << "层次遍历：" ;
    level(p);
    cout << endl;
    return 0;
}

时间： 2024-10-26 04:53:18

C++层次遍历二叉树的相关文章

层次遍历二叉树

层次遍历二叉树,编程之美上看过解法,然后在练习了一下.用递归和vector,队列实现了,然后加上了测试函数,测试函数的二叉树创建方法待改进. //有一棵二叉树,请设计一个算法,按照层次打印这棵二叉树. //给定二叉树的根结点root,请返回打印结果,结果按照每一层一个数组进行储存,所有数组的顺序按照层数从上往下,且每一层的数组内元素按照从左往右排列.保证结点数小于等于500. #include <iostream> using namespace std; #include <vecto

二叉树各种相关操作(建立二叉树、前序、中序、后序、求二叉树的深度、查找二叉树节点，层次遍历二叉树等）（C语言版)

将二叉树相关的操作集中在一个实例里,有助于理解有关二叉树的相关操作: 1.定义树的结构体: 1 typedef struct TreeNode{ 2 int data; 3 struct TreeNode *left; 4 struct TreeNode *right; 5 }TreeNode; 2.创建根节点: 1 TreeNode *creatRoot(){ 2 TreeNode * root =(TreeNode *)malloc(sizeof(TreeNode)); 3 if(NULL=

网易：层次遍历二叉树

题目描述分层遍历二叉树用java实现树结构,分层遍历二叉树.给定一棵二叉树,要求按分层遍历该二叉树,即从上到下按层次访问该二叉树(每一层单独输出一行),每一层要求访问的顺序为从左到右,再按照相同规则从下至上遍历一遍,树节点定义如下 class Node { int data; Node left; Node right; } 输入描述图: __1__ / __2__ 3__ / \ 4 __5__ 6 7 8 上面的输入为:1, 2, 3, 4, 5, 0, 6, 0, 0, 7, 8注:

按层次遍历二叉树

void traverse(bitree bt) { linkqueue q; bitree p; initqueue(q); //初始化一个空的队列 p=bt; enqueue(q,p); //入队 while(queueempty(q)!=1) { dequeue(q,p); //出队 if(p->lchild!=NULL) enqueue(q,p->lchild); //访问左子树 if(p->rchild

数据结构之二叉树---求二叉树后序遍历和层次遍历（先建树，再遍历）

数据结构实验之求二叉树后序遍历和层次遍历 Time Limit: 1000MS Memory limit: 65536K 题目描述已知一棵二叉树的前序遍历和中序遍历,求二叉树的后序遍历. 输入输入数据有多组,第一行是一个整数t (t<1000),代表有t组测试数据.每组包括两个长度小于50 的字符串,第一个字符串表示二叉树的先序遍历序列,第二个字符串表示二叉树的中序遍历序列. 输出每组第一行输出二叉树的后序遍历序列,第二行输出二叉树的层次遍历序列示例输入 2 abdegcf dbgeaf

<二叉树的基本操作（有层次遍历）>

#include<stdio.h> #include<stdlib.h> #include<string.h> #define num 100 #define OK 1 #define ERROR 0 #define OVERFLOW -1 #define FALSE 0 #define TRUE 1 typedef int Status; typedef char DataType; typedef struct node { DataType data; struc

二叉树的先序中序、后序遍历、层次遍历以及树状打印等操作

#include <stdio.h> #include <stdlib.h> #define MAXSIZE 50 typedef struct Node { char data; struct Node *LChild; struct Node *RChild; }BiTNode,*BiTree; typedef struct { BiTree element[MAXSIZE]; int front; int rear; }SeqQueue; /*初始化队列*/ void Ini

【数据结构】二叉树层次遍历

package 蓝桥练习; public class 二叉树层次遍历 { public static int MAXSIZE = 100; public static Node queue[] = new Node[MAXSIZE]; public static void main(String[] args) { Node h = new Node('H', null, null); Node i = new Node('I', null, null); Node f = new Node('

二叉树的层次遍历和（叶子）节点

#include<stdio.h> #include<string.h> #include<stdlib.h> #define size 100 #define resize 10 typedef struct Bitnode{ //定义结点 char data; struct Bitnode *lchild,*rchild; }Bitnode,*Bitree; typedef struct { //定义队列 Bitree *base; int front; int r