精华内容
下载资源
问答
  • 二叉树遍历C语言递归实现
    2019-11-03 20:21:13

    /*

    .二叉树的遍历
      前序遍历
    		根左右
      中序遍历
    		左根右
      后序遍历
    		左右根
    

    */

    #include<stdio.h>
    #include<stdlib.h>
    //描述一个体
    typedef struct treeNode
    {
    	char data;//数据域字符表示
    	struct treeNode*LChild;
    	struct treeNode*RChild;
    }TREE,*LPTREE;
    //创建节点
    LPTREE createNode(char data)
    {
    	LPTREE newNode = (LPTREE)malloc(sizeof(TREE));
    	newNode->data = data;
    	newNode->LChild = NULL;
    	newNode->RChild = NULL;
    	return newNode;
    }
    void insertNode(LPTREE parentNode, LPTREE LChild, LPTREE RChild)
    {
    	parentNode->LChild = LChild;
    	parentNode->RChild = RChild;
    }
    void printCurNodeData(LPTREE curData)
    {
    	printf("%c\t",curData->data);
    }
    //递归法
    //先序
    void preOrder(LPTREE root)
    {
    	if (root != NULL)
    	{
    		printCurNodeData(root);
    		preOrder(root->LChild);
    		preOrder(root->RChild);
    	}
    }
    void midOrder(LPTREE root)
    {
    	if (root != NULL)
    	{
    		midOrder(root->LChild);
    		printCurNodeData(root);
    		midOrder(root->RChild);
    	}
    }
    void lastOrder(LPTREE root)
    {
    	if (root != NULL)
    	{
    		lastOrder(root->LChild);
    		lastOrder(root->RChild);
    		printCurNodeData(root);
    	}
    }
    
    int main()
    {
    	LPTREE A = createNode('A');
    	LPTREE B = createNode('B');
    	LPTREE C = createNode('C');
    	LPTREE D = createNode('D');
    	LPTREE E = createNode('E');
    	LPTREE F = createNode('F');
    	LPTREE G = createNode('G');
    	insertNode(A, B, C);
    	insertNode(B, D, E);	
    	insertNode(C, F, G);
    	printf("先序遍历:\n");
    	preOrder(A);
    	printf("\n");
    	printf("\n中序遍历:\n");
    	midOrder(A);
    	printf("\n");
    	printf("\n后序遍历:\n");
    	lastOrder(A)
    	printf("\n");
    	system("pause");
    	return 0;
    }
    
    
    
    更多相关内容
  • 数据结构 二叉树层次遍历 C语言

    千次阅读 多人点赞 2018-12-19 16:21:08
    C语言 数据结构 二叉树层次遍历 原创作者:小林 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #define max 100 typedef int ElemType; typedef struct BiTNode{ ElemType data; struct ...

    C语言 数据结构 二叉树层次遍历

    原创作者:小林
    #include<stdio.h>
    #include<stdlib.h>
    #define max 100

    typedef int ElemType;

    typedef struct BiTNode{
    ElemType data;
    struct BiTNode *lchild,*rchild;
    } BiTNode,*BinTree;

    //建立二叉树

    void CreateBinTree(BinTree &T){ //按先序次序输入,构造二叉链表表示的二叉树T
    int num;
    scanf("%d",&num);//输入函数。
    if(num==-1){
    T=NULL;
    }//输入#时为空
    else{
    T=(BinTree)malloc(sizeof(BiTNode));
    T->data=num;
    CreateBinTree(T->lchild);
    CreateBinTree(T->rchild);
    }
    }

    // 遍历二叉树
    void LevleOrder(BinTree T){ //从第一层开始,从左到右

    BinTree Queue[max],p; //用一维数组表示队列,front和rear分别表示队首和队尾指针

    int front,rear;

    front=rear=0;

    if (T) //若树非空
    {

    Queue[rear++]=T; //根结点入队列

    while (front!=rear){ // 队列非空
    p=Queue[front++]; // 队首元素出队列,并访问这个结点
    printf("%d",p->data);

    if (p->lchild!=NULL) Queue[rear++]=p->lchild; //左子树非空,入队列
    if (p->rchild!=NULL) Queue[rear++]=p->rchild;
    }
    }

    }

    //按要求输出二叉树

    int main() {

    BinTree T;

    printf("\n创建二叉树\n");
    CreateBinTree (T);
    printf("\n层次遍历二叉树 并输出遍历结果\n"); LevleOrder(T);

    return 0; }

    例题:
    二叉树的层次遍历
    关于二叉树的遍历方法,除了我们所熟知的先序遍历、中序遍历和后序遍历方法外,还有一种遍历方法,称为层次遍历。所谓层次遍历方法是指从二叉树的根结点开始自上而下,每一层从左到右逐一访问每个结点。例如,若二叉树如下所示。
    在这里插入图片描述

    则该二叉树的层次遍历序列为:1 2 3 5 6 7 10 11 13
    假设二叉树采用二叉链表存储结构,其二叉链表的类型定义如下。
    typedef struct bnode{
    int data; //结点的数据域用大于0的整数表示
    struct bnode *lchild;
    struct bnode *rchild;
    }bnode,*btree;
    要求:
    首先采用先序遍历的方法来创建一棵二叉树,创建时用-1来表示空树。最后输出所创建二叉树的层次遍历序列。
    例如,如果要创建上图所示的二叉树:
    应输入:
    1 2 -1 5 10 -1 -1 11 -1 -1 3 6 -1 13 -1 -1 7 -1 -1
    则输出:
    1 2 3 5 6 7 10 11 13

    运行结果如下:在这里插入图片描述

    展开全文
  • 二叉树层次遍历 提示:以下是本篇文章正文内容,下面案例可供参考 一、代码实现 代码如下(示例): #include <stdio.h> #include <stdlib.h> //二叉树 typedef struct BiTNode { BiTNode* ...


    二叉树的层次遍历


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、代码实现

    代码如下(示例):

    #include <stdio.h>
    #include <stdlib.h>
    
    
    //二叉树 
    typedef struct BiTNode {
    	BiTNode* lchild, * rchild;
    	int num;
    }BiTNode, * BiTree;
    //队列
    
    typedef struct LinkNode {
    	BiTNode* data;
    	LinkNode* next;
    }LinkNode;
    
    typedef struct {
    	LinkNode* front, * rear;
    }LinkQueue;
    
    
    
    
    
    
    //初始化 
    int InitQueue(LinkQueue& L) {
    	L.front = L.rear = (LinkNode*)malloc(sizeof(LinkNode));
    	if (L.front == NULL) return 0;
    	L.front->next = NULL;
    }
    
    void visit(BiTree T) {
    	printf("nmsl\n");
    }
    
    
    
    //出队列 
    void PushNode(LinkQueue& L, BiTree T) {
    	LinkNode* s = (LinkNode*)malloc(sizeof(LinkNode));
    	s->data = T;
    	s->next = NULL;
    	L.rear->next = s;
    	L.rear = s;
    }
    
    
    void PopNode(LinkQueue& L, BiTree& T1) {
    	T1 = L.front->next->data;
    	printf("%d\n", L.front->next->data->num);
    	L.front = L.front->next;
    }
    
    void LevelTraversal(BiTree& T) {
    	BiTree T1;
    	LinkQueue L;
    	InitQueue(L);
    	PushNode(L, T);
    	while (L.front != L.rear) {
    		PopNode(L, T1);
    		//visit(Tem);
    		if (T1->lchild != NULL) PushNode(L, T1->lchild);
    		if (T1->rchild != NULL) PushNode(L, T1->rchild);
    	}
    }
    int main() {
    	BiTree T = (BiTree)malloc(sizeof(BiTNode));
    	T->num = { 1 };
    	T->lchild = NULL;
    	T->rchild = NULL;
    
    	BiTree P = (BiTree)malloc(sizeof(BiTNode));
    	P->num = { 2 };
    	T->lchild = P;
    	P->lchild = NULL;
    	P->rchild = NULL;
    
    	BiTree I = (BiTree)malloc(sizeof(BiTNode));
    	I->num = { 3 };
    	T->rchild = I;
    	I->lchild = NULL;
    	I->rchild = NULL;
    
    	BiTree a = (BiTree)malloc(sizeof(BiTNode));
    	a->num = { 5 };
    	P->rchild = a;
    	a->lchild = NULL;
    	a->rchild = NULL;
    
    
    	LevelTraversal(T);
    }
    

    二.运行结果

    运行结果


    总结

    没什么好总结的

    展开全文
  • 二叉树层次遍历--C语言

    万次阅读 多人点赞 2018-12-21 17:54:22
    今天写一下二叉树层次遍历层次遍历用到的数据结构是队列。   层次遍历算法中增加了三个int型数据,其中levelcount用于记录现在处理的是树的第几层;curlevel用于记录当前层还有几个节点没有被访问过;next...

      之前写了二叉树的先序、中序、后序遍历,这些遍历都用到了栈结构。今天写一下二叉树的层次遍历,层次遍历用到的数据结构是队列。
      层次遍历算法中增加了三个int型数据,其中levelcount用于记录现在处理的是树的第几层;curlevel用于记录当前层还有几个节点没有被访问过;nextlevel用于记录本层的下一层的节点数。
    代码如下:

    #include "stdafx.h"
    #include "stdio.h"
    #include "stdlib.h"
    #define INITQUEUE 20
    
    typedef struct BiTNode
    {
    	char data;//节点数据
    	struct BiTNode *lchild;//节点左孩子指针
    	struct BiTNode *rchild;//节点右孩子指针
    }BiTNode,*BiTree;//二叉树节点
    
    typedef struct Queue
    {
    	BiTNode *front;//队列头指针
    	BiTNode *tail;//队列尾指针
    	int size;//队列空间大小
    }Queue;
    
    //创建队列
    int InitQueue(Queue &Q)
    {
    	Q.front = (BiTNode*)malloc(INITQUEUE * sizeof(BiTNode));
    	if(!Q.front)
    	{
    		return 0;
    	}
    	Q.tail = Q.front;
    	Q.size = INITQUEUE;
    	return 1;
    }
    
    //判断队列是否为空
    bool EmptyQueue(Queue Q)
    {
    	if(Q.tail == Q.front)
    	{
    		return true;
    	}
    	else
    	{
    		return false;
    	}
    }
    
    //入队列
    int EnQueue(Queue &Q,BiTNode e)
    {
    	if((Q.tail - Q.front + INITQUEUE) % INITQUEUE == INITQUEUE - 1)
    	{
    		return 0;
    	}
    	*Q.tail = e;
    	Q.tail++;
    	return 1;
    }
    
    //出队列
    int DeQueue(Queue &Q,BiTNode &e)
    {
    	if(Q.front == Q.tail)
    	{
    		return 0;
    	}
    	e = *Q.front;
    	Q.front++;
    	return 1;
    }
    
    //创建二叉树
    void CreateBiTree(BiTree &T)
    {
    	char ch;
    	scanf("%c",&ch);
    	if('#' == ch)
    	{
    		T = NULL;
    	}
    	else
    	{
    		T = (BiTree)malloc(sizeof(BiTNode));
    		T->data = ch;
    		CreateBiTree(T->lchild);
    		CreateBiTree(T->rchild);
    	}
    }
    
    //二叉树的层次遍历
    int levelTraverse(BiTree T)
    {
    	if(NULL == T)
    	{
    		return 0;
    	}
    	BiTNode e;
    	Queue Q;
    	int levelcount = 0;//树的深度
    	int curlevel = 1;//本层剩余的未访问的节点数
    	int nextlevel = 0;//下一层未访问的节点数
    	InitQueue(Q);
    	EnQueue(Q,*T);
    	while(!EmptyQueue(Q))
    	{
    		DeQueue(Q,e);
    		printf("%c ",e.data);
    		curlevel--;
    		if(NULL != e.lchild)
    		{
    			EnQueue(Q,*e.lchild);
    			nextlevel ++;
    		}
    		if(NULL != e.rchild)
    		{
    			EnQueue(Q,*e.rchild);
    			nextlevel++;
    		}
    		if(0 == curlevel)
    		{
    			levelcount++;
    			printf("第%d层节点遍历结束!\n",levelcount);
    			curlevel = nextlevel;
    			nextlevel =0;
    		}
    	}
    	return 1;
    }
    
    int main(int argc, char* argv[])
    {
    	BiTree T = NULL;
    	CreateBiTree(T);
    	levelTraverse(T);
    	return 0;
    }
    

    二叉树的结构为:
    在这里插入图片描述

    遍历结果:
    在这里插入图片描述
      二叉树的遍历基本上已经写过一遍了,有机会需要写一个二叉树的总结。当然现在写的都还只是二叉树的皮毛的东西,像二叉树的一些应用(平衡二叉树、红黑树等)都还没有写。但是这些东西需要先把理论弄清楚,才能着手去写,要不然思路不清晰,写出来的代码必然是不能看的!

    展开全文
  • 显然, 这样 就能 使出 队 的 顺序 满足 层次 遍历。 注意,这个实现不能使用递归的方式,因为按照递归的方式,一定是先把左子树或右子处理完全,才会处理另一颗树上的内容 代码实现 int ...
  • 对于二叉树来说,它是一个递归的定义,我们要实现层次遍历必然要满足从上到下、从左到右这个要求,从根结点出发,我们可以将所有意义上的根结点都存储在队列之中,那我们可以使用队列先进先出的特点来实现要求的遍历...
  • 二叉树层次遍历C语言

    千次阅读 2021-03-20 15:23:46
    二叉树层次遍历 二叉树结构 typedef struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; }TreeNode; 这里实现将二叉树的每层放入一个二维数组的一行中。 #define maxSize ...
  • 实现二叉树层次遍历实现二叉树层次遍历实现二叉树层次遍历实现二叉树层次遍历
  • 二叉树层次遍历C语言实现)

    万次阅读 多人点赞 2019-05-10 21:53:21
    非递归实现二叉树层次遍历: 想了大半个小时终于写出来了,通过自己思考出来的还是有很大成就感。学数据结构就是通过自己思考和参考而学得更深。 思路:层次遍历就是一层一层遍历,这棵二叉树层次遍历序列...
  • 二叉树层次遍历
  • 二叉树层次遍历. 使用队列 2. 代码 2.1 李毛毛 说明: 几种遍历方式集成在一个程序里, 我就偷懒没把它们分开. 队列应该叫做 enqueue, dequeue, 栈的操作才是 push, pop. // 李毛毛 #include<iostream> #...
  • #include <stdio.h> #include <stdlib.h> #define MAX 100 struct treeNode { char data; struct treeNode* LChild; struct treeNode* RChild; }; struct treeNode* createNode(char data)... struct...
  • 二叉树层次遍历详解(C语言版)

    千次阅读 2021-05-15 18:17:20
    非递归版的层次遍历,简单易懂!!!
  • 这是用c语言编写的二叉树层次遍历程序,使用非递归的方法实现。欢迎使用。
  • 前边介绍了二叉树的先序、中序和后序的遍历算法,运用了栈的数据结构,主要思想就是按照先...而后每次队列中一个结点出队,都将其左孩子和右孩子入队,直到树中所有结点都出队,出队结点的先后顺序就是层次遍历的最...
  • 层次遍历C语言

    千次阅读 2020-10-21 20:38:41
    编一个程序,读入用户输入的一串先序遍历字符串,根据输入建立一棵二叉树, 并输出该二叉树层次遍历序列。层次遍历是指逐层访问,每一层又按从左到右的次序访问结点。 输入 输入包括1行字符串,长度不超过100。 ...
  • 二叉树层次遍历C语言
  • 前两篇解释了二叉树的有关逻辑概念及前中后序输出递归代码的实现,这篇将讲述二叉树层次遍历输出如何实现以及二叉树前序遍历输入的两种情况。
  • 二叉树非递归遍历实现——C语言实现二叉树非递归遍历:前、中、后序三种遍历需要用到栈,层序遍历需要用到队列。首先用c语言实现栈和队列,然后再实现二叉树的非递归遍历详细解释参考:维基百科树的遍历...
  • /** 问题描述: 实现二叉树层次遍历算法,并对用”A(B(D,E(H(J,K(L,M(,N))))),C(F,G(,I)))”创建的二叉树进行测试。* 输入描述:无需输入* 程序输出:实现各种算法的函数的测试结果*/view plain copy#include #...
  • 故知道该题主要考察二叉树基本的层次遍历方法,需要打印出每层节点的关键字。 二叉树层次遍历实现思路是用一个队列记录每层节点,当记录第一层节点时,弹出第一层节点进行访问,访问的同时需要遍历对应节点的左右...
  • C语言实现二叉树层次遍历

    千次阅读 多人点赞 2020-07-27 21:29:07
    进行层次遍历时构建一个辅助队列,先将二叉树根节点入队,然后出队,访问出队结点,若它有左子树,将左子树根节点入队,然后出队,访问出队结点…,右子树也同样如此,循环往复直到队列为空。 2.代码 #include<...
  • 二叉树层次遍历算法

    2020-10-20 21:54:55
    二叉树层次遍历算法自上而下,从左到右自下而上,从右到左 typedef struct BiTNode{ ElemType data; struct BiTNode *lchild, *rchild; }BiTNode, *BiTree; 利用队列 #define MaxSize 30 typedef struct { ...
  • L)//层次遍历 { if (L == NULL) return 0; else { if(L->lchild!=NULL) printf("%c", L->lchild->data); if (L->rchild != NULL) printf("%c",L->rchild->data); show4(L-&...
  • 主要介绍了C语言排序方法,包含10种排序,数据结构课程设计实例二叉树建立遍历冒泡排序快速排序_二叉排序树_二叉树层次遍历_二叉树非递归遍历_二叉树建立括号匹配直接插入选择代码大学生本科毕业设计期末作业排序...
  • 层次遍历算法: void _PrintTree_f5(BiTree a) { LinkQueue b; b=InItQueue(); EnQueue(&b,a); while(!QueueEmpty(b)) { BiTree d; d=getFront(b); printf("%c\n",d->data); if(d->lchild)...
  • 二叉树层序遍历C语言

    千次阅读 多人点赞 2021-04-25 22:14:28
    二叉树的层序遍历即从上到下,在每一层从左到右依次打印数据。 如下: 层序遍历结果: ABCDEFG 基本思路即将根节点入队后,之后每次都将队首元素出队,打印队首元素数据,并将队首元素左右子树入队,一直重复上述...
  • 问题描述:二叉树采用链接存储结构,试设计一个按层次顺序(同一层次自左至右)遍历二叉树的...因为队列的特点是先进先出,从而达到层次遍历二叉树的目的。完整代码如下:/* 二叉树 - 层次遍历 */ #include "...
  • #二叉树 #Queue.h // // Created by Carry on 2021/10/26. // #ifndef EXAM_QUEUE_H #define EXAM_QUEUE_H #endif //EXAM_QUEUE_H #define MaxSize 50 typedef BiTNode ElemType; typedef struct { ElemType ...
  • /*水平遍历*/ void LevelOrderTraverse(BiTree T) { LQueue Q; InitQueue(&Q); BiTree p; EnQueue(&Q,T); while (!JudgeEmpty(&Q)) { p = DeQueue(&Q); printf("%c ",p->data); if(p->lchild != NULL)...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,787
精华内容 2,314
关键字:

二叉树层次遍历c语言