分层遍历二叉树

最新推荐文章于 2024-04-21 20:55:42 发布
最新推荐文章于 2024-04-21 20:55:42 发布
阅读量730 收藏 1
点赞数
分类专栏： 编程之美
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chenxieyy/article/details/48470227
版权

1，问题一：给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一次将单独输出一行），每一层要求访问的顺序为从左到右，并将结点依次编号。

     解法一：基本思想：用层序遍历的方法，初始化一个队列，当每一层结点进队时，统计当前层的下一层结点数目，当结点出队时，统计出队次数是不是和上一层结点数目相等，若相等，则表明上一层的结点输出完毕，换行；否则不换行打印，继续统计当前层的下一层结点数目，直到队列为空。

 

     代码如下：

   

#include "stdafx.h"
#include<stdio.h>
#include<malloc.h>
#define STACK_INCREMENT  10
#define STACK_INIT_SIZE 100
#define MAXSIZE         50
//char*ch="ABC  D  EFH  I  G  ";
//char*ch="AB  CD  E  ";
//char*ch="-+a  *b  -c  d  /e  f  ";
char*ch="124  57  8  3 6  ";
//二叉排序树的链式存储结构
typedef struct BiTNode
{
	char data;
	int count;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//队列的链式存储结构
typedef struct QNode
{
	BiTree data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//栈的顺序存储结构
typedef struct
{
	BiTree *base;
	BiTree *top;
	int stacksize;
}Sqstack;

//初始化一个队列，用于二叉树的层次遍历
bool InitQueue(LinkQueue&Q)
{
	Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q.front )
		exit(OVERFLOW);
	Q.front ->next =NULL;
	return true;
}

//初始化一个栈，用于二叉树的遍历
void InitStack(Sqstack&S)
{
	S.base=(BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
	if(!S.base)
		exit(0);
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
}

bool EnQueue(LinkQueue&Q,BiTree T)
{
	QueuePtr p;
	p=(QueuePtr)malloc(sizeof(QNode));
	if(!p)
		return false;
	p->data =T;
	p->next =NULL;
	Q.rear->next =p;
	Q.rear=p;
	return true;
}

bool DeleteQueue(LinkQueue&Q,BiTree &e)
{
	QueuePtr q;
	if(Q.front ==Q.rear )
		return false;
	q=Q.front->next ;
	e=q->data;
	Q.front->next=q->next ;
	if(q==Q.rear )
		Q.rear=Q.front ;
	free(q);
	return true;
}

//采用先序递归遍历创建一个二叉树
void CreateBiTree(BiTree&T)
{
	//static int n=0;//用静态变量保存上次运算结果的值。
	//char ch;
	//static char *ch="ABCD  E   F  ";
	//ch=ch+n;
	//scanf("%c",&ch);
	if(*ch==' ')
	{
		T=NULL;
		ch++;
		//n++;
		return;
	}
	else
	{
		if(!(T=(BiTNode*)malloc(sizeof(BiTNode))))
			exit(OVERFLOW);
		T->data=*ch++;
		T->count =0;
		//n++;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	
}


//二叉树的分层遍历算法
void LevelTraverse(BiTree T)
{
	int level[20];
	int i,j;//i表示当前层的结点数目，j表示当前层的下一层节点数目。
	int deCount;//用于记录某一层的出队次数，也就是改层的结点数。
	LinkQueue Q;
	InitQueue(Q);
	BiTree p;
	if(T)
	{
	  EnQueue(Q,T);//根结点入队
	  i=j=0;//初始时，为第一层
	  j++;//第二层
	  deCount=0;//初始时，出队次数。
	  level[0]=1;//初始时，第一层的结点数目
	  level[1]=0;//初始时，第二层的结点数目
	}
	//一次循环，完成的任务是：队头结点出队并打印；统计当前层的出队次数；累计当前层的下一层的结点数目；
	while(Q.front!=Q.rear )
	{
		DeleteQueue(Q,p);//出队
		deCount++;//出队次数加1，当前层的结点数。
		if(p->lchild )//如果当前结点的左孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->lchild);
		     level[j]++;//统计下一层结点数目
		  }
	    if(p->rchild )//如果当前结点的右孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->rchild);
		     level[j]++;//统计下一层结点数目
		  }
		if(deCount!=level[i])//如果当前的出队次数不等于上一层的结点数目，不换行输出
		{
		    printf("%c ",p->data);
		}
		else                
		{
			printf("%c\n",p->data);//如果当前层的出队次数等于上一层的结点数目，换行输出，
			deCount=0;             //当前层输出完毕，同时下一层统计结点数的过程也完毕，并初始化下下一层统计结点数目的参数。
		    i=j;
		    j++;
		    level[j]=0;            //当前层的下一层的初始结点数目。
		}

	}
  printf("\n");
}

void main()
{
	int length;
	BiTree BST;
	printf("*************************************************\n");
	printf("        二叉树按层次遍历算法           \n");
	printf("*************************************************\n");
	printf("输入的待建二叉树序列为：");
	printf("%s",ch);
	printf("\n");
	CreateBiTree(BST);
	printf("\n");
	printf("输出按层次遍历结果：\n");
	LevelTraverse(BST);
	printf("\n");
	free(BST);
}



运行结果如下：




 2，问题二，打印二叉树中某层次的结点（从左至右），其中根结点为第1层。

        再上一个问题的基础上，用一个判断语句：如果当前层等于要打印层，则输出，否则不输出

        注意：上一题中，else语句中打印的是某一层的最后一个结点，再换行的，所以，else中也要有个判断句，否则某一层中的最后一个结点无法输出。

   代码如下：

#include "stdafx.h"
#include<stdio.h>
#include<malloc.h>
#define STACK_INCREMENT  10
#define STACK_INIT_SIZE 100
#define MAXSIZE         50
//char*ch="ABC  D  EFH  I  G  ";
//char*ch="AB  CD  E  ";
char*ch="-+a  *b  -c  d  /e  f  ";
//char*ch="124  57  8  3 6  ";
//二叉排序树的链式存储结构
typedef struct BiTNode
{
	char data;
	int count;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//队列的链式存储结构
typedef struct QNode
{
	BiTree data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//栈的顺序存储结构
typedef struct
{
	BiTree *base;
	BiTree *top;
	int stacksize;
}Sqstack;

//初始化一个队列，用于二叉树的层次遍历
bool InitQueue(LinkQueue&Q)
{
	Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q.front )
		return false;
	Q.front ->next =NULL;
	return true;
}

//初始化一个栈，用于二叉树的遍历
void InitStack(Sqstack&S)
{
	S.base=(BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
	if(!S.base)
		return ;
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
}

bool EnQueue(LinkQueue&Q,BiTree T)
{
	QueuePtr p;
	p=(QueuePtr)malloc(sizeof(QNode));
	if(!p)
		return false;
	p->data =T;
	p->next =NULL;
	Q.rear->next =p;
	Q.rear=p;
	return true;
}

bool DeleteQueue(LinkQueue&Q,BiTree &e)
{
	QueuePtr q;
	if(Q.front ==Q.rear )
		return false;
	q=Q.front->next ;
	e=q->data;
	Q.front->next=q->next ;
	if(q==Q.rear )
		Q.rear=Q.front ;
	free(q);
	return true;
}

//采用先序递归遍历创建一个二叉树
void CreateBiTree(BiTree&T)
{
	//static int n=0;//用静态变量保存上次运算结果的值。
	//char ch;
	//static char *ch="ABCD  E   F  ";
	//ch=ch+n;
	//scanf("%c",&ch);
	if(*ch==' ')
	{
		T=NULL;
		ch++;
		//n++;
		return;
	}
	else
	{
		if(!(T=(BiTNode*)malloc(sizeof(BiTNode))))
			return;
		T->data=*ch++;
		T->count =0;
		//n++;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	
}

//计算二叉树的深度
int depth(BiTree T)
{
	int d1,d2;
	if(!T)
		return 0;
	else
	{
	d1=depth(T->lchild);
	d2=depth(T->rchild);
	return (d1>d2)?(d1+1):(d2+1);
	}

}

//二叉树的分层遍历算法
void LevelTraverse(BiTree T,int levels)
{
	int level[20];
	int i,j;//i表示当前层的结点数目，j表示当前层的下一层节点数目。
	int deCount;//用于记录某一层的出队次数，也就是改层的结点数。
	LinkQueue Q;
	InitQueue(Q);
	BiTree p;
	if(T)
	{
	  EnQueue(Q,T);//根结点入队
	  i=j=0;//初始时，为第一层
	  j++;//第二层
	  deCount=0;//初始时，出队次数。
	  level[0]=1;//初始时，第一层的结点数目
	  level[1]=0;//初始时，第二层的结点数目
	}
	//一次循环，完成的任务是：队头结点出队并打印；统计当前层的出队次数；累计当前层的下一层的结点数目；
	while(Q.front!=Q.rear )
	{
		DeleteQueue(Q,p);//出队
		deCount++;//出队次数加1，当前层的结点数。
		if(p->lchild )//如果当前结点的左孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->lchild);
		     level[j]++;//统计下一层结点数目
		  }
	    if(p->rchild )//如果当前结点的右孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->rchild);
		     level[j]++;//统计下一层结点数目
		  }
		if(deCount!=level[i])//如果当前的出队次数不等于上一层的结点数目，不换行输出
		{
			if(i==levels)
		    printf("%c ",p->data);
		}
		else                
		{
			if(i==levels)
			printf("%c",p->data);//如果当前层的出队次数等于上一层的结点数目，换行输出，
			deCount=0;             //当前层输出完毕，同时下一层统计结点数的过程也完毕，并初始化下下一层统计结点数目的参数。
		    i=j;
		    j++;
		    level[j]=0;            //当前层的下一层的初始结点数目。
		}

	}
  printf("\n");
}

void main()
{
	int level;
	int length;
	BiTree BST;
	printf("*************************************************\n");
	printf("             输出二叉树第n层结点的算法           \n");
	printf("*************************************************\n");
	printf("输入的待建二叉树序列为：");
	printf("%s",ch);
	printf("\n");
	CreateBiTree(BST);
	printf("\n");
	length=depth(BST);
	printf("输出此二叉树的深度为：%d\n",length);
	printf("\n");
	printf("请输入二叉树的level层(level<=%d，输出的为二叉树的第level+1层结点)：",length);
	scanf("%d",&level);
	printf("\n");
	printf("输出二叉树第%d层的结点：\n",level+1);
	LevelTraverse(BST,level);
	printf("\n");
	free(BST);
}

运行结果如下：



3，问题三，输出二叉树某一层结点的数目。

     代码如下：

    

#include "stdafx.h"
#include<stdio.h>
#include<malloc.h>
#define STACK_INCREMENT  10
#define STACK_INIT_SIZE 100
#define MAXSIZE         50
//char*ch="ABC  D  EFH  I  G  ";
//char*ch="AB  CD  E  ";
char*ch="-+a  *b  -c  d  /e  f  ";
//char*ch="124  57  8  3 6  ";
//二叉排序树的链式存储结构
typedef struct BiTNode
{
	char data;
	int count;
	struct BiTNode *lchild,*rchild;
}BiTNode,*BiTree;

//队列的链式存储结构
typedef struct QNode
{
	BiTree data;
	struct QNode *next;
}QNode,*QueuePtr;

typedef struct
{
	QueuePtr front;
	QueuePtr rear;
}LinkQueue;

//栈的顺序存储结构
typedef struct
{
	BiTree *base;
	BiTree *top;
	int stacksize;
}Sqstack;

//初始化一个队列，用于二叉树的层次遍历
bool InitQueue(LinkQueue&Q)
{
	Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
	if(!Q.front )
		return false;
	Q.front ->next =NULL;
	return true;
}

//初始化一个栈，用于二叉树的遍历
void InitStack(Sqstack&S)
{
	S.base=(BiTree*)malloc(STACK_INIT_SIZE*sizeof(BiTNode));
	if(!S.base)
		return ;
	S.top=S.base;
	S.stacksize=STACK_INIT_SIZE;
}

bool EnQueue(LinkQueue&Q,BiTree T)
{
	QueuePtr p;
	p=(QueuePtr)malloc(sizeof(QNode));
	if(!p)
		return false;
	p->data =T;
	p->next =NULL;
	Q.rear->next =p;
	Q.rear=p;
	return true;
}

bool DeleteQueue(LinkQueue&Q,BiTree &e)
{
	QueuePtr q;
	if(Q.front ==Q.rear )
		return false;
	q=Q.front->next ;
	e=q->data;
	Q.front->next=q->next ;
	if(q==Q.rear )
		Q.rear=Q.front ;
	free(q);
	return true;
}

//采用先序递归遍历创建一个二叉树
void CreateBiTree(BiTree&T)
{
	//static int n=0;//用静态变量保存上次运算结果的值。
	//char ch;
	//static char *ch="ABCD  E   F  ";
	//ch=ch+n;
	//scanf("%c",&ch);
	if(*ch==' ')
	{
		T=NULL;
		ch++;
		//n++;
		return;
	}
	else
	{
		if(!(T=(BiTNode*)malloc(sizeof(BiTNode))))
			return;
		T->data=*ch++;
		T->count =0;
		//n++;
		CreateBiTree(T->lchild);
		CreateBiTree(T->rchild);
	}
	
}

//计算二叉树的深度
int depth(BiTree T)
{
	int d1,d2;
	if(!T)
		return 0;
	else
	{
	d1=depth(T->lchild);
	d2=depth(T->rchild);
	return (d1>d2)?(d1+1):(d2+1);
	}

}

//二叉树的分层遍历算法
void LevelTraverse(BiTree T,int levels)
{
	int level[20];
	int i,j;//i表示当前层的结点数目，j表示当前层的下一层节点数目。
	int deCount;//用于记录某一层的出队次数，也就是改层的结点数。
	LinkQueue Q;
	InitQueue(Q);
	BiTree p;
	if(T)
	{
	  EnQueue(Q,T);//根结点入队
	  i=j=0;//初始时，为第一层
	  j++;//第二层
	  deCount=0;//初始时，出队次数。
	  level[0]=1;//初始时，第一层的结点数目
	  level[1]=0;//初始时，第二层的结点数目
	}
	//一次循环，完成的任务是：队头结点出队并打印；统计当前层的出队次数；累计当前层的下一层的结点数目；
	while(Q.front!=Q.rear )
	{
		DeleteQueue(Q,p);//出队
		deCount++;//出队次数加1，当前层的结点数。
		if(p->lchild )//如果当前结点的左孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->lchild);
		     level[j]++;//统计下一层结点数目
		  }
	    if(p->rchild )//如果当前结点的右孩子存在，下一层结点数加1
		 {
		     EnQueue(Q,p->rchild);
		     level[j]++;//统计下一层结点数目
		  }
		if(deCount==level[i])
		{
		    if(i==levels)//如果等于输入的层数，则输出该层结点数目
		    printf("%d",level[i]);	
		    deCount=0;             
		    i=j;
		    j++;
		    level[j]=0; 
		}
	}
  printf("\n");
}

void main()
{
	int level;
	int number;
	int length;
	BiTree BST;
	printf("*************************************************\n");
	printf("             输出二叉树第n层结点数目的算法           \n");
	printf("*************************************************\n");
	printf("输入的待建二叉树序列为：");
	printf("%s",ch);
	printf("\n");
	CreateBiTree(BST);
	printf("\n");
	length=depth(BST);
	printf("输出此二叉树的深度为：%d\n",length);
	printf("\n");
	printf("请输入二叉树的level层(level<=%d，输出的为二叉树的第level+1层结点数目)：",length);
	scanf("%d",&number);
	printf("\n");
	printf("输出二叉树第%d层的结点数目：\n",number+1);
	LevelTraverse(BST,number);
	printf("\n");
	free(BST);
}

运行结果如下：

 


yychenxie21
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
二叉树的分层遍历
sicofield的专栏
06-09 7371
二叉树除了前、中、后序三种遍历方式外，有时候还要用到分层遍历。分层遍历就是二叉树的广度优先算法，暂时还没有见过图的广度优先算法，据说广度优先算法都要使用一个辅助队列。 题目一：分层遍历二叉树，从上往下打印二叉树的每一个节点，同一层次的节点按照从左到右的顺序打印。 下图顺序输出1 2 3 4 5 6 7 8 //用queue更好 void PrintBinayTree(BinaryTr
二叉树的路径与分层遍历
m0_63471305的博客
11-17 508
查找二叉树从根到x的最长路径;查找每层结点；查找两个结点之间的路径；
从下至上按层遍历二叉树
qq_45670253的博客
08-15 1506
【问题描述】 给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。 【输入形式】 广义表表示的二叉树，结点元素类型为整型，且都大于0，例如：1( 2( 3 ( 4, 5 ) ), 6( 7, 8( 9, 10 ) ) ) 【输出形式】 从下至上，打印每一层的结点元素值，元素间以空格隔开。每层的访问顺序是从左到右，每一层单独输出一行。 【样例输入】 1(2(3(4,5)),6(7,8(9,10)))，字符串内没有空格 【样例输出】 4 5 9 10 3 7 8 2 6 1
给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。广义表表示的二叉树，结点元素类型为整型，且都大于0。
最新发布
2401_83694443的博客
04-21 208
第一行是测试数据{少了个逗号 应该是1（2（3（4，5）），6（7，8（9，10））），}，代码块里的“//”是我的错误！代码思路：用一个数组记录每一颗左子树，并通过index索引查找，defalut中实现连接！注意：parseNodeValue函数有bug 这里的转换强调的是两位数以下！其他代码，倒叙同层次输出（二维数组） 但思路简单版！
考研真题：给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。
m0_63168183的博客
04-15 2210
【问题描述】 考研真题：给定一颗二叉树，要求从下至上按层遍历二叉树，每层的访问顺序是从左到右，每一层单独输出一行。 【输入形式】 广义表表示的二叉树，结点元素类型为整型，且都大于0，例如：1( 2( 3 ( 4, 5 ) ), 6( 7, 8( 9, 10 ) ) ) 【输出形式】 从下至上，打印每一层的结点元素值，元素间以空格隔开。每层的访问顺序是从左到右，每一层单独输出一行。 【样例输入】 1(2(3(4,5)),6(7,8(9,10)))，字符串内没有空格 【样例输出】 4 5 9 10 .
编程之美-分层遍历二叉树
My_Jobs的专栏
02-03 1933
问题：给定一个二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一层将单独输出一行），每一层要求访问的顺序为从左到右，并将节点依次编号。那么分层遍历如图的二叉树，正确的输出应该为：
二叉树遍历
08-10
在"遍历二叉树的神级方法"这个文件中，可能包含了各种优化的遍历策略或算法，比如非递归的 Morris遍历或线程化遍历，这些方法在某些情况下能提高效率或节省空间。Morris遍历利用了空指针，无需额外的空间就能完成...
二叉树的先序、中序、后序、分层遍历C++实现
04-22
以三元组的方式输入二叉树，先序、中序、后序、分层遍历并输出，哈工大
二叉树建立以及递归、非递归遍历
07-03
如果有子节点，则子节点也可以是二叉树，形成树的分层结构。二叉树的节点通常包含数据域和指向子节点的指针域。 在C语言中建立二叉树，我们需要定义一个结构体来表示节点，如下所示： ```c typedef struct ...
遍历二叉树的四种方式和图解
一个旅人
02-06 2538
二叉树的遍历是指从根结点出发,按照某种次序依次访问二叉树中所有结点,使得每个结点被访问一次且仅被访问一次 1.前序遍历算法 规则是若二叉树若为空,则空操作返回,否则先访问根结点,然后遍历左子树,然后再遍历右子树 2.中序遍历 若树为空,则空操作返回,否则从根结点开始,中序遍历根结点的左子树,然后就是访问根结点,最后中序遍历右子树 3.后序遍历 若树为空,则空操作返回,否则从左到右先叶子后结点的...
编程之美——3.10 分层遍历二叉树
Solidfish的专栏
09-16 1171
学过数据结构我们很容易知道如何进行宽度优先遍历树，那么这道题就是对宽度优先遍历树的算法进行改进。          1        /    \      2      3    /   \       \  4    5       6       /  \      7   8 运用BFS只能输出1，2，3，4，5，6，7，8这个序列，并不知道分层信息，因此如何分层打印呢？
面试题_分层遍历二叉树
weixin_34214500的博客
03-31 82
编程之美上的题目。 问题1：给定一棵二叉树，要求按分层遍历该二叉树，即从上到下按层次访问该二叉树（每一行将单输出一行），每一层要求访问的顺序为从左向右，并将节点依次编号。 问题2:写一个函数，打印二叉树中某层次的节点（从左向右），其中根结点为第1层。 #include&lt;iostream&gt;#include&lt;queue&gt;using namespace std;stru...
【LeetCode】二叉树层次遍历 （一次让人疯掉的超低级bug）
lengxiaohe的博客
05-10 1858
我对递归的思想有点犯怵，递归这个东西确实需要天赋和训练。所以二叉树遍历我首先掌握的是迭代方法。层次遍历的基本思路是，因为要从上到下，从左到右进行遍历，我们进行碰到数据的过程和要处理的过程方向是一致的，所以最好使用队列queue数据结构：在while循环中，每处理一个数据，一次把它的左子节点（如果有的话）和右子节点（如果有的话）入队，直到队列变空。LeetCode上这一题，不仅要按正确的方式（层次遍...
数据结构层次遍历二叉树
08-09
总结起来，层次遍历二叉树是一种基于队列的遍历方式，按照从上到下、从左到右的顺序遍历二叉树的每个节点，可以很方便地处理树的层级相关问题。 ### 回答3： 层次遍历二叉树是一种广度优先搜索的方式，它按照每一...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值