二叉树 创建 释放 遍历

最新推荐文章于 2024-08-14 08:36:35 发布
原创 最新推荐文章于 2024-08-14 08:36:35 发布 · 1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

这篇博客介绍了如何进行二叉树的前序、中序、后序遍历，并通过示例展示遍历过程。同时，文章讲解了二叉树的创建，包括使用#表示没有子节点的情况，以及如何通过后序遍历释放二叉树。此外，还提到了计算叶子节点数目的方法，指出在不同遍历方式下，叶子节点的数目计算保持不变。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


前序遍历：ABDGHCEIF

中序遍历：GDHBAEICF

后序遍历：GHDBIEFCA

理解遍历：

void in_Order(BiTNode * root)    //先序遍历
{
    if(root == NULL)
    {
        return ;
    }
    printf("this is node %d\n",root->data);
    in_Order(root->lchild);//遍历左子树
	printf("node %d finish scanning left.\n",root->data);
    in_Order(root->rchild);//遍历右子树
	printf("node %d finish scanning right.\n",root->data);
}

int  main()
{
	BiTNode *p1 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p1,0,sizeof(BiTNode));
	p1->data = 1;
        BiTNode *p2 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p2,0,sizeof(BiTNode));
	p2->data = 2;
	BiTNode *p3 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p3,0,sizeof(BiTNode));
	p3->data = 3;
	BiTNode *p4 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p4,0,sizeof(BiTNode));
	p4->data = 4;

	p1->lchild = p2;
	p2->rchild = p3;
	p1->rchild = p4;
        in_Order(p1);            
    return 0;
}
结果输出：
this is node 1
this is node 2
node 2 finish scanning left.
this is node 3
node 3 finish scanning left.
node 3 finish scanning right.
node 2 finish scanning right.
node 1 finish scanning left.
this is node 4
node 4 finish scanning left.
node 4 finish scanning right.
node 1 finish scanning right.

请按任意键继续. . .


以下使用图上的前6个节点，1-2-3-4-5-6来创建二叉树；

1、二叉树的创建之关系创建（对象，需要使用memset初始化对象指针）

#include<stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode 
{
	int data;
	struct BiTNode *lchild;
	struct BiTNode *rchild;
}BiTNode, *BiTree;

//推导
//struct BiTNode
//{
//  int data;
//  struct BitNode *lchild;
//  struct BiTNode *rchild;
//};
//typedef struct BiTNode  BiTNode;
//typedef struct BiTNode* BiTree;


int main()
{
	//create node
	BiTNode t1; 
	BiTNode t2;
	BiTNode t3; 
	BiTNode t4;
	BiTNode t5; 
	BiTNode t6; 
    memset(&t1,0,sizeof(BiTNode)); t1.data = 1; 
	memset(&t2,0,sizeof(BiTNode)); t2.data = 2;
	memset(&t3,0,sizeof(BiTNode)); t3.data = 3;
	memset(&t4,0,sizeof(BiTNode)); t4.data = 4;
	memset(&t5,0,sizeof(BiTNode)); t5.data = 5;
	memset(&t6,0,sizeof(BiTNode)); t6.data = 6; 

	t1.lchild = &t2;
	t1.rchild = &t3;
	t2.lchild = &t4;
	t2.rchild = &t5;
	t3.lchild = &t6;

	return 0;
}

2、二叉树的创建之关系创建（指针，需要使用memset初始化指针）
#include<stdio.h>
#include <stdlib.h>
#include <string.h>

struct BiTNode 
{
	int data;
	struct BiTNode *lchild;
	struct BiTNode *rchild;
};

typedef struct BiTNode  BiTNode;
typedef struct BiTNode* BiTree;

int main()
{
	//create node
	BiTNode *p1 = (BiTNode *)malloc(sizeof(BiTNode)); 
	memset(p1,0, sizeof(BiTNode));
	p1->data = 1;
	BiTNode *p2 = (BiTNode *)malloc(sizeof(BiTNode)); 
	memset(p2,0, sizeof(BiTNode));
	p2->data = 2;
	BiTNode *p3 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p3,0, sizeof(BiTNode));
	p3->data = 3;
	BiTNode *p4 = (BiTNode *)malloc(sizeof(BiTNode)); 
	memset(p4,0, sizeof(BiTNode));
	p4->data = 4;
	BiTNode *p5 = (BiTNode *)malloc(sizeof(BiTNode));
	memset(p5,0, sizeof(BiTNode));
	p5->data = 5;
	BiTNode *p6 = (BiTNode *)malloc(sizeof(BiTNode)); 
	memset(p6,0, sizeof(BiTNode));
	p6->data = 6;


	p1->lchild = p2;
	p1->rchild = p3;
	p2->lchild = p4;
	p2->rchild = p5;
	p3->lchild = p6;
	return 0;
}
3、二叉树创建之使用全局变量（三个遍历）
#include<stdio.h>
#include <stdlib.h>
#include <string.h>

struct BiTNode 
{
	int pdata;
	int ldata;
	int rdata;
};

typedef struct BiTNode  BiTNode;
#define MAX 1000
#define NIL -1

BiTNode Node[MAX] ; //节点
int n = 6;//共6个节点

void preParse(int root)
{
	if(Node[root].pdata == NIL)
		return;
	printf("%d ",Node[root].pdata);
	preParse(Node[root].ldata);
	preParse(Node[root].rdata);
}

void postParse(int root)
{
	if(Node[root].pdata == NIL)
		return;
	postParse(Node[root].ldata);
	postParse(Node[root].rdata);
	printf("%d ",Node[root].pdata);
}

void inParse(int root)
{
	if(Node[root].pdata == NIL)
		return;
	inParse(Node[root].ldata);
	printf("%d ",Node[root].pdata);
	inParse(Node[root].rdata);
}

int main()
{
	//create node
    int i;
	for(i = 1; i <= n; i++)
	{
		Node[i].pdata = NIL;
		Node[i].ldata = NIL;
		Node[i].rdata = NIL;
	}
	Node[1].pdata = 1;
	Node[2].pdata = 2;
	Node[3].pdata = 3;
	Node[4].pdata = 4;
	Node[5].pdata = 5;
	Node[6].pdata = 6;

	Node[1].ldata = Node[2].pdata;
	Node[1].rdata = Node[3].pdata;

	Node[2].ldata = Node[4].pdata;
	Node[2].rdata = Node[5].pdata;

	Node[3].ldata = Node[6].pdata;
	//前序遍历
	preParse(1);
	printf("\n");
	//后序遍历
	postParse(1);
	printf("\n");
	//中序遍历
	inParse(1);
	return 0;
}

4、二叉树创建之使用#（没有子节点的用”#“替代，前序创建二叉树）包含二叉树的释放，使用后序遍历释放

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;
 
void in_Order(BiTNode * root)    //先序遍历
{
    if(root == NULL)
    {
        return ;
    }
    printf("%c",root->data);
    in_Order(root->lchild);//遍历左子树
    in_Order(root->rchild);//遍历右子树
}
 

BiTNode* create_tree()//先序创建
{
    BiTNode *node = NULL;
    BiTNode *pleft  = NULL;
    BiTNode *pright = NULL;
    char c = getchar(); 
    if(c == '#')
    {
        return NULL;
    }
    else
    {
        node = (BiTNode*)malloc(sizeof(BiTNode));
        memset(node,0,sizeof(BiTNode));
        node->data = c;
 
        pleft = create_tree();
        if(pleft != NULL)
        {
            node->lchild = pleft;
        }
        else
        {
            node->lchild = NULL;
        }
         
        pright = create_tree();
        if(pleft != NULL)
        {
            node->rchild = pright;
        }
        else
        {
            node->rchild = NULL;
        }
    }
    return node;  
}
 
void free_tree(BiTNode* T)//后序释放
{
    if(!T)
    {
        return ;
    }
    if(T->lchild)
    {
        free_tree(T->lchild);
        //T->lchild = NULL;
    }
    if(T->rchild)
    {
        free_tree(T->rchild);
        //T->rchild = NULL;
    }
    if(T)
    {
        free(T);
        T = NULL;
    }
}
 
int  main()
{
    BiTNode *p = create_tree(); 
    in_Order(p);            
	  printf("\n");
	 //释放空间
    free_tree(p);
    return 0;
}
输入与结果:
124##5##36###
124536

5.二叉树的层序遍历


5、计算叶子节点的数目；（无论是先序遍历,中序遍历,后序遍历,求叶子的数字都不变;因为本质都是一样的,任何一个节点都会遍历3趟）


#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;
 
void pre_Order(BiTNode * root)   //先序遍历
{
    if(root == NULL)
    {
        return ;
    }
    printf("%d ",root->data);
    pre_Order(root->lchild);//遍历左子树
    pre_Order(root->rchild);//遍历右子树
}
 
void in_Order(BiTNode * root)    //中序遍历
{
    if(root == NULL)
    {
        return ;
    }
    in_Order(root->lchild);//遍历左子树
    printf("%d ",root->data);
    in_Order(root->rchild);//遍历右子树
}
 
void post_Order(BiTNode * root)  //后序遍历
{
    if(root == NULL)
    {
        return ;
    }
    post_Order(root->lchild);//遍历左子树
    post_Order(root->rchild);//遍历右子树
    printf("%d ",root->data);
}
 
void count_leaf(BiTNode * root,int * num)   
{
    if(!root)
    {
        return ;
    }
    if(!root->rchild && !root->rchild)//当左右孩子都为空
    {
        (*num)++;
    }
    if(root->lchild)
    {
        count_leaf(root->lchild,num);//遍历左子树
    }
    if(root->rchild)
    {
        count_leaf(root->rchild,num);//遍历右子树
    }
    return ;
}
int main()
{
    //创建节点
    BiTNode t1;    memset(&t1,0,sizeof(BiTNode));  t1.data = 1;
    BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;
    BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;
    BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;
    BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;
    //建立关系
    t1.lchild = &t2;
    t1.rchild = &t3;
    t2.lchild = &t4;
    t3.lchild = &t5;
 
    //树的遍历
    pre_Order(&t1);     printf("    先序遍历\n");
    in_Order(&t1);      printf("    中序遍历\n");
    post_Order(&t1);    printf("    后序遍历\n");
 
    int num = 0;
    count_leaf(&t1,&num);   //解决多线程,资源竞争问题
    printf("叶子节点的个数 %d\n",num);
 
    return 0;
}
6.计算二叉树的高度 

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct BiTNode
{
    int data;
    struct BiTNode *lchild;
    struct BiTNode *rchild;
}BiTNode,*BiTree;
 
int tree_dept(BiTNode * root)
{
    int depth_left = 0;
    int depth_right = 0;
    if(!root)
    {
        return 0;
    }
    depth_left = tree_dept(root->lchild);
    depth_right = tree_dept(root->rchild);
    return  1+(depth_left>depth_right ? depth_left:depth_right);
}
int main()
{
    //创建节点
    BiTNode t1;    memset(&t1,0,sizeof(BiTNode));  t1.data = 1;
    BiTNode t2;    memset(&t2,0,sizeof(BiTNode));  t2.data = 2;
    BiTNode t3;    memset(&t3,0,sizeof(BiTNode));  t3.data = 3;
    BiTNode t4;    memset(&t4,0,sizeof(BiTNode));  t4.data = 4;
    BiTNode t5;    memset(&t5,0,sizeof(BiTNode));  t5.data = 5;
    BiTNode t6;    memset(&t6,0,sizeof(BiTNode));  t6.data = 6;
    //建立关系
    t1.lchild = &t2;
    t1.rchild = &t3;
    t2.lchild = &t4;
    t3.lchild = &t5;
    t2.rchild = &t6;
 
    int depth = 0;
    depth = tree_dept(&t1);  
    printf("树的高度 %d\n",depth);
 
    return 0;
}



   

二叉树的创建遍历和释放
m198984的博客
12-18 513
二叉树的创建遍历和释放 树（Tree）是n（n≥0）个节点的有限集合T，它满足两个条件 ： 有且仅有一个特定的称为根（Root）的节点，其余的节点可以分为m（m≥0）个互不相交的有限集合T1、T2、……、Tm，其中每一个集合又是一棵树，并称为其根的子树（Subtree）。 树的基本概念 一个节点的子树的个数称为该节点的度数，一棵树的度数是指该树中节点的最大度数。 度数为零的节点称为树叶或终端节点，...
二叉树的创建与遍历（附有C++实现详细代码）
Weirdo的博客
05-29 7567
在计算机科学中，二叉树是一种常见的数据结构，它的每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的应用广泛，包括但不限于搜索算法、排序算法、存储结构等。本文将详细讨论二叉树的创建与遍历方法，并通过代码示例进行说明。
二叉树的应用 二叉树的建立 删除等全部操作
07-14
二叉树的应用 二叉树的建立 删除等全部操作 课直接运行
二叉树的拷贝和释放
I_O_fly的博客
04-18 503
/*树的定义: 由一个或多个(n &gt;= 0)结点组成的有限集合T,有且仅有一个结点称为根(root),当 n&gt;1时,其余的结点分为m(m &gt; 0)个相互不相交的有限集合T1, T2, ..., Tm。每个集合本身又是棵树,被称作这个根的子树。 树的结构特点: 1.非线性结构,有一个直接前驱,但可能有多个直接后继(1:n) 2.树的定义具有递归行,树中还有树。 3.树可以为空,即结...
【数据结构】释放二叉树：释放左子树、右子树、根节点
weixin_62372119的博客
05-20 585
二叉树操作，先思考两个问题：是否可以递归；用什么序列 递归：可以分解，且每次递的问题是同一个，归的时候调用函数自己。 序列：释放二叉树，应该用后序。 后序递归 （伪代码）
有序二叉树的释放（要点剖析）
最新发布
qq_62850449的博客
08-14 830
如果你尝试访问一个已经被释放的内存地址，结果是未定义行为。崩溃：访问无效内存通常会导致程序崩溃。输出随机数据：有时，已经释放的内存区域并不会立即被系统回收，你可能会看到原来的数据，但这些数据是无效的，因为内存已经不再属于你的程序。其他不可预测的行为：未定义行为意味着程序可能做任何事情，完全不受控制。
二叉树的建立、遍历及其应用（递归建立二叉树，顺序表建立二叉树）
莞工杰仔的博客
05-23 1464
通过二叉树的相关操作深刻理解递归算法以及二叉树的操作算法 最近已经很久没写博客主要是因为没时间，不过最近的这个二叉树我着实又很多的感悟，所以尽管要花时间，我还是想要写下来，希望对大家也有帮助，我会先从二叉树的一些性质讲起，并讲明该性质的作用，最后附上一道综合题及代码详解帮助大家理解 首先是二叉树的性质，及一些重要的算法 1.对于具有n个节点的二叉树，如果按照从上到下从左到右的顺序对所有的节点从零开始顺序编号，则对于i(0<=i<=n)的节点，有： （1）如果i>0,则序号为i的节点的双亲节
【数据结构】-二叉树的层次遍历(队列的应用)
RunningSnail的博客
08-08 8350
二叉树的层次遍历★算法思想★1.头文件及元素类型定义2.相关类型定义3.函数声明4.基本操作4.1 初始化队列4.2 判空4.3 入队操作4.4 出队操作4.5 先序建立二叉树4.6 打印结点4.7 二叉树的层次遍历4.8 main函数4.9 测试4.9.1 二叉树结构4.9.2 测试结果5.小结 ★算法思想★ 初始化一个辅助队列 根结点入队 若队列非空，则队头结点出队，访问该结点，并将其左、右孩子插入队尾（如果有的话） 重复3中的操作直至队列为空 PS：从上述算法思想中可以看出需要用到的队列相关操作
二叉树非递归遍历算法分析
weixin_43875867的博客
05-08 1220
本文介绍了二叉树非递归遍历算法的一种实现方式，以及这种遍历算法是怎么推导出来的。
数据结构 二叉树建立、遍历、销毁的递归算法（C语言）
weixin_43774911的博客
11-01 1457
这些是较为简单的二叉树的建立、遍历、销毁的递归算法。 假设二叉树都用二叉链作为存储结构，并约定根节点的指针用T表示。 为了简化问题，我们用char类型的字符代替树中的数据，并且用前序遍历的算法，建立二叉树过程如下： 输入一个根节点。 若输入的是“ ”（即空格字符），则表明改结点为空，T设置为NULL； 若输入的不是“ ”（空格字符），则将字符存入到T->data中，并依次递归建立它的左子树...
二叉树的创建和释放以及各种遍历方法（递归和非递归）
u011514451的专栏
03-13 822
好久不看数据结构，感觉很多东西都有点生疏了，这两天趁着不是特别忙抽时间把有关二叉树的知识复习了一下，并用代码实现了一遍。主要功能有二叉树的创建和释放、前序遍历（递归和非递归两种方式）、中序遍历（递归和非递归两种方式）、后序遍历（递归和非递归两种方式）、层次遍历（递归和非递归两种方式）。 代码： #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; ...
根据先序序列和中序序列递归创建二叉树
慢慢的博客
10-03 2308
根据先序序列和中序序列递归创建二叉树 源代码如下： #include <iostream> using namespace std; //二叉树的结构 typedef struct BTNode { char data; struct BTNode *left; struct BTNode *right; }BTNode; //根据先序序列和中序序列递归创建二叉树 BTNode * BTCreate(char a[],char b[],int n) { int k; if (
二叉树的创建和释放
u011415955的专栏
08-16 4389
/********************************************************* * Description:参数传递：C++ 二叉树的实现以及指针使用注意事项 * Author:charley * DateTime:2010-12-8 11:00 * Compile Environment：win7+vs2008 ***********************
【二叉树的内存管理】创建和释放一棵二叉树
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-09 2760
二叉树的创建与释放，动态管理二叉树的内存。通过递归实现二叉树的创建算法。
二叉树的拷贝和释放操作
m0_53157173的博客
03-05 677
思路：先通过递归一直找到叶子（即最后一层结点）,再回溯，拷贝叶子的左子树，再右子树，然后重复往上面根结点回溯，直到最上层的根结点 释放：释放在堆区创建的结点 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h> //二叉树的递归遍历 struct BinaryNode { //数据域 char ch; //指针域 BinaryNode* lchild; //指向左孩子的指针 BinaryN
C++数据结构X篇_16_二叉树的拷贝和释放（采用递归的方法）
分享学习成长历程，Winter is coming！
10-17 822
在上篇的基础上，本篇介绍如何进行二叉树的拷贝和释放。从代码中可以看到采用递归方式进行的拷贝、释放操作，基本套路都是一样的。
二叉树构造、遍历和释放--自己写数据结构
XIAO_PING_PING的专栏
12-16 1687
直接上代码 bitree.h文件如下： #ifndef _BITREE_H_ #define _BITREE_H_ typedef char TElemType; typedef struct _BitNode { TElemType data; struct _BitNode *lchild,*rchild; }BitNode,*pBit
二叉树的遍历、高度、叶子数量、拷贝以及释放
热门推荐
Hello_MyDream的博客
11-05 2万+
先给出二叉树的结构体定义： #define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; struct BinaryTree { char value; struct BinaryTree *LChild; struct BinaryTree *RChild; }; 再提供一个mai...
销毁二叉树
进阶的小宋
11-04 2378
/*遍历是将节点数据元素找出来，同样利用便利的思想，也可以将节点指向的内存空间释放掉。这里需要注意的问题时，释放的先后问题，根节点必须在左子树和右子树的后面释放，因此，利用后续遍历的方法可以释放掉二叉树中多有节点的存储空间。*/ void BTreeSetNull(BTree *tree) { if(tree==NULL) { return; } BTreeSetNull(tree->left); BTreeSetNu
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值