举例演示链式二叉树的各类操作——包括遍历、求总的(叶子)节点个数、深度、查找、删除节点等

最新推荐文章于 2023-04-24 20:21:24 发布
最新推荐文章于 2023-04-24 20:21:24 发布
阅读量292 收藏 2
点赞数
分类专栏： 数据结构基础 文章标签： 二叉树 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/khqxf/article/details/105611133
版权

参考博客：数据结构-链式二叉树
参考视频：郝斌之链式二叉树遍历具体演示

在这里插入图片描述
创建如上图所示的二叉树，并使用链式二叉树实现，先序、中序和后序遍历，求叶子结点和总的节点个数，求二叉树的深度以及删除节点等操作。

/*******************************************************
* 功能: 实现链式二叉树的相关操作，包括创建、遍历、删除
*       查找、销毁以及求总的节点和叶子结点数和数的深度等
* 作者: khq
* 时间: 2020年4月20日
********************************************************/

#include<stdio.h>
#include<malloc.h>
#include<stdlib.h>

//定义二叉树的参数
typedef struct BTree{
	char data;  //数据域
	struct BTree *lchild;  //左子树
	struct BTree *rchild;  //右子树
}BTNODE,*PBTREE;

//方法声明
PBTREE creatBTree();   //创建二叉树
void preTraverse(PBTREE);  //先序遍历
void inTraverse(PBTREE);  //中序遍历
void postTraverse(PBTREE);  //后序遍历
int getLeafCount(PBTREE);  //求叶子结点数
int getTotalNodeCount(PBTREE);  //获取总的节点数
int getTreeDepth(PBTREE);  //获取树的深度
void destoryBTNode(PBTREE);  //销毁二叉树上的节点

/*******************************************************
*  查找有没有节点的数据为x，若有，返回true，并将该节点
* 的地址给p，否则，返回false,*不可或缺 
********************************************************/
bool findNode(PBTREE,char,PBTREE *);  

/********************************************************
* 已知二叉树含有某节点，求该节点的父节点，并指出该节点
* 是父节点的左孩子还是右孩子，并保存父节点的地址
********************************************************/
bool getParentNode(PBTREE,char,PBTREE *,int *);  
bool deleteBTNode(PBTREE,char);  //删除某一节点

int main(void){
	printf("开始创建二叉树......\n");
	PBTREE bTree = creatBTree();
	printf("先序遍历二叉树结果......\n");
	preTraverse(bTree);
	printf("\n中序遍历二叉树的结果......\n");
	inTraverse(bTree);
	printf("\n后序遍历二叉树的结果......\n");
	postTraverse(bTree); 
	printf("\n该二叉树的叶子结点数为: %d\n",getLeafCount(bTree));
	printf("该二叉树总的节点数为: %d\n",getTotalNodeCount(bTree));
	printf("该二叉树的深度为: %d\n",getTreeDepth(bTree));
	char x = 'H';
	PBTREE pT;
	printf("在二叉树中查找节点:%c \n",x);
	if(findNode(bTree,x,&pT))
		printf("该二叉树中含有数据为%c的节点.\n",pT->data);
	else
		printf("该二叉树中不包含数据为%c的节点.\n",x);
	PBTREE parent;
	int lr;
	if(getParentNode(bTree,x,&parent,&lr)){
		printf("节点%c的父节点是%c.\n",x,parent->data);
		if(lr==0)
			printf("节点%c是父节点%c的左孩子\n.",x,parent->data);
		else
			printf("节点%c是父节点%c的右孩子.\n",x,parent->data);
	}else
		printf("节点%c在该二叉树中没有父节点.\n",x);
	printf("删除节点%c.\n",x);
	if(deleteBTNode(bTree,x))
		printf("节点%c删除成功.\n",x);
	else
		printf("删除失败!\n");
	printf("删除节点%c后，先序遍历二叉树结果......\n",x);
	preTraverse(bTree);
	return 0;
}

//创建二叉树
PBTREE creatBTree(){	  //返回根节点的地址，也就是pA的地址
	//创建所需要的节点
	PBTREE pA = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pB = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pC = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pD = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pE = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pF = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pG = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pH = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pI = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pJ = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pK = (PBTREE)malloc(sizeof(BTNODE));
	PBTREE pL = (PBTREE)malloc(sizeof(BTNODE));

	//每个节点存储相应的数据
	pA->data = 'A';
	pB->data = 'B';
	pC->data = 'C';
	pD->data = 'D';
	pE->data = 'E';
	pF->data = 'F';
	pG->data = 'G';
	pH->data = 'H';
	pI->data = 'I';
	pJ->data = 'J';
	pK->data = 'K';
	pL->data = 'L';

	//各个节点之间通过指针相连
	pA->lchild = pB;
	pA->rchild = pF;
	pB->lchild = pC;
	pB->rchild = pD;
	pC->lchild = pE;
	pC->rchild = NULL;
	pD->lchild = pD->rchild = NULL;
	pE->lchild = pE->rchild = NULL;
	pF->lchild = pG;
	pF->rchild = pH;
	pG->lchild = pI;
	pG->rchild = pJ;
	pH->lchild = NULL;
	pH->rchild = pL;
	pI->lchild = pI->rchild = NULL;
	pJ->lchild = NULL;
	pJ->rchild = pK;
	pK->lchild = pK->rchild = NULL;
	pL->lchild = pL->rchild = NULL;

	return pA;  //返回根节点的地址
}

/*
* 递归实现大部分算法
*/

//先序遍历二叉树
void preTraverse(PBTREE pBT){
	if(NULL != pBT){  //不可忽略
		printf("%c ",pBT->data);  //先访问（子树的）根节点的数据
		if(NULL != pBT->lchild){
			preTraverse(pBT->lchild);  //再访问左子树
		}
		if(NULL != pBT->rchild){
			preTraverse(pBT->rchild);  //再访问右子树
		}
	}
} 

//中序遍历二叉树 
void inTraverse(PBTREE pBT){
	if(NULL != pBT){ 
		if(NULL != pBT->lchild){
			inTraverse(pBT->lchild);  //先访问左子树
		}
		printf("%c ",pBT->data);  //再访问（子树的）根节点的数据
		if(NULL != pBT->rchild){
			inTraverse(pBT->rchild);  //再访问右子树
		}
	}
}

//后序遍历二叉树
void postTraverse(PBTREE pBT){
	if(NULL != pBT){
		if(NULL != pBT->lchild){
			postTraverse(pBT->lchild);  //先访问左子树
		}
		if(NULL != pBT->rchild){
			postTraverse(pBT->rchild);  //再访问右子树
		}
		printf("%c ",pBT->data);  //再访问（子树的）根节点的数据
	}
}

//求叶子结点数(没有子节点的节点)
int getLeafCount(PBTREE pBT){
	if(NULL == pBT)
		return 0;
	if(NULL==pBT->lchild && pBT->rchild==NULL)
		return 1;
	return getLeafCount(pBT->lchild)+getLeafCount(pBT->rchild);
}

//求总的节点数
int getTotalNodeCount(PBTREE pBT){
	if(NULL == pBT)
		return 0;
	else{
		return getTotalNodeCount(pBT->lchild) + getTotalNodeCount(pBT->rchild) + 1;  //1表示树（子树）的根节点
	}
}

//求树的深度
int getTreeDepth(PBTREE pBT){
	int d,d1,d2;
	if(NULL == pBT)
		d = 0;
	else{
		d1 = getTreeDepth(pBT->lchild);
		d2 = getTreeDepth(pBT->rchild);
		d = (d1>d2)?(d1+1):(d2+1);
	}
	return d;
}

//销毁所有节点
void destoryBTNode(PBTREE pBT){
	if(NULL!=pBT){
		destoryBTNode(pBT->lchild);
		destoryBTNode(pBT->rchild);
		free(pBT);
		pBT=NULL;
	}
}

//查找有没有节点的数据为x，若有，返回true，并将该节点的地址给p，否则，返回false
//总结：对什么类型的数据的值进行修改，就传入该类型的地址，指针的地址也就是指针的指针
bool findNode(PBTREE pBT,char x,PBTREE *p){  //小心p为野指针,加上*，让其用来保存地址,指针的指针
	if(NULL == pBT){		
		*p = NULL;
		return false;
	}else if(pBT->data == x){
		*p = pBT;   //相当于pT = pBT;
//		printf("找到%c\n",p->data);
		return true;
	}else{
		if(findNode(pBT->lchild,x,p))
			return true; 
		else if(findNode(pBT->rchild,x,p))
			return true;
		else{
			p = NULL;
			return false;
		}
	}
}

//已知二叉树含有某节点，求该节点的父节点，并指出该节点是父节点的左孩子还是右孩子，并保存父节点的地址
bool getParentNode(PBTREE pBT,char x,PBTREE *pnt,int *LR){
	if(pBT->data == x){  //该节点是根节点，无父节点
		*pnt = NULL;
		LR = NULL;
		return false;
	} else if(pBT->lchild && pBT->lchild->data == x){  //在左子树上查找
		*LR = 0;
		*pnt = pBT;
		return true;
	} else if(pBT->rchild && pBT->rchild->data == x){  //在右子树上查找
		*LR = 1;
		*pnt = pBT;
		return true;
	}else{
		if(pBT->lchild && getParentNode(pBT->lchild,x,pnt,LR)){  //在左子树上递归查找
			return true;
		}else if(pBT->rchild && getParentNode(pBT->rchild,x,pnt,LR)){  //在右子树上递归查找
			return true;
		}else{
			*pnt = NULL;
			LR = NULL;
			return false;
		}
	}	
}

bool deleteBTNode(PBTREE pBT,char x){  //删除某一节点
	PBTREE p,parent;
	int LR;
	if(findNode(pBT,x,&p)){  //先找到该节点的位置
		if(getParentNode(pBT,x,&parent,&LR)){  //找到该节点的父节点
			if(LR==0){
				destoryBTNode(parent->lchild);
				return true;
			}else{
				destoryBTNode(parent->rchild);
				return true;
			}
		}else{  //如果是根节点
			destoryBTNode(pBT);
			return true;
		}  			
	} else  //没有找到该节点
		return false;	
}

结果显示：
在这里插入图片描述
至于节点的查找和删除等其他操作接下来继续研究，搞懂它，加油！——2020年4月19

未完成的已经补上来了，在查找(父)节点时，注意传入的指针类型，也即：对什么类型的数据的值进行修改，就传入该类型的地址，指针的地址也就是指针的指针

khq溪风
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
树和二叉树的链式存储实现
lxjune1st61的博客
12-06 976
树和二叉树的链式存储
链式二叉树的实现以及常用操作（C语言） 超详细！
qq_42890853的博客
08-03 633
#include<stdio.h> #include <stdlib.h> typedef struct bin_node//结点 { char data;//数据域 struct bin_node* right;//右子树 struct bin_node* left;//左子树 }node;//取小名 int cur;//现在指向的结点 char str[1000];//数组存放遍历字符串 node* create_tree()//创建树 {
Data Structure--二叉树的链式结构及实现
贵在坚持,我相信只要我努力,未来肯定是美好的!
02-22 480
二叉树链式结构二叉树链式结构的遍历前序遍历(NLR)中序遍历(LNR)后序遍历(LRN)(1)链式的具体结构(2)链式的接口声明(3)链式的接口实现1.通过前序遍历的数组创建二叉树2.前序遍历3.中序遍历4.后序遍历5.求节点数6.求叶子节点数7.求第K层的节点8.查找节点9.销毁二叉树10.层序遍历11.是否为完全二叉树 二叉树链式结构的遍历 这里的N(根) L(左子树) R(右子树) 前序遍历(NLR) 访问根结点的操作发生在遍历其左右子树之前 中序遍历(LNR) 访问根结点的操作发生在遍历其左
遍历二叉树，求结点总数及叶子总数
10-22
遍历二叉树，求结点总数及叶子总数 遍历二叉树，求结点总数及叶子总数
二叉树构建、删除、遍历、求深度、求节点数
07-12 221
http://blog.itchuan.net/posts/85 原文链接 //Notice: this file.cpp can run on your pc; //input: example // 1 // 2 3 // you can input 1 2 0 0 3 0 0 // then you'll get a binaryTree like line 3、4...
数据结构与算法——二叉树的前中后序遍历、查找与删除
nswdiphone6的博客
03-08 392
树 1. 常用存储方式分析 数组存储方式的分析： 优点：通过下标方式访问元素，速度块，对于有序数组，还可以使用二分查找提高检索速度。 缺点：如果要插入值（按一定顺序）会整体移动，效率低，扩容时底层要创建两个数值进行copy… 访问容易，插入和删除困难； 链式存储方式的分析： 优点：在一定程度上对数组存储方式有优化（比如：插入一个数值节点，只需要将插入节点，连接到链表中即可——前一个节点的next指向插入节点，插入节点next指向下个节点），删除效率也是很好的 缺点：在进行检索时，效率很低，检索某个值
数据结构——树和二叉树
FREEDOM’s blog
07-13 1558
1.树、森林 2.二叉树 3.并查集（2022新增考点）
二叉树的递归、非递归遍历
weixin_43201538的博客
12-26 632
介绍： 本文简单的介绍一下二叉树的前、中、后序遍历的递归和非递归的实现方法。最后再来看看一道折纸问题来加深对遍历的理解。 先简单说说概念： 顾名思义： 前序遍历：二叉树结点的访问顺序为 ： 根节点、左节点、右节点。 中序遍历：二叉树结点的访问顺序为 ： 左节点、根节点、右节点。 后序遍历：二叉树结点的访问顺序为 ： 左节点、右节点、根节点。 递归和非递归的关系。理论上来说可以用递归方法实现的，也可...
二叉树详解
热门推荐
weixin_59371851的博客
07-09 5万+
目录前言一、树的概念和结构1、树的概念2、树的表示 3、树在实际中的应用（表示文件系统的目录树结构）二、二叉树概念及结构1.概念 2、特殊的二叉树3、二叉树的性质4、二叉树的存储4.1顺序存储4.2链状存储 三、二叉树的顺序结构和实现1、二叉树的顺序结构2、堆的概念及结构3、堆的实现3.1堆的代码框架3.2堆的插入3.3堆的删除3.4堆的建立 3.5建堆的时间复杂度 4、堆的应用4.1堆排序 4.2TOP-K问题四、二叉树链式结构的实现 1、建二叉树2、二叉树的遍历2.1前序、中序以及后序遍历2.2层序遍历
二叉树顺序存储-实现前序中序后序遍历
Passer-Go
06-01 1792
一、顺序存储二叉树简介 二叉树的存储结构有两种，分别为顺序存储和链式存储。 二叉树的顺序存储，指的是使用顺序表（数组）存储二叉树。只有完全二叉树才可以使用顺序表存储。因此，如果我们想顺序存储普通二叉树，需要提前将普通二叉树转化为完全二叉树。 从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，逻辑示意图如下 二、代码实现 要求：给定已知数组{1,2,3,4,5,6,7}，要求以二叉树前序，中序，后续遍历的方式进行遍历，达到如下结果。 前序遍历：1，2，4，5，3
数据结构与算法 | 二叉树的实现
凌桓丶的博客
03-17 626
前几章实现了二叉树的顺序结构和二叉树的几种遍历，这次就来实现二叉树的链式结构 数据结构 typedef char BTDataType; typedef struct BTNode { BTDataType data; struct BTNode* left; struct BTNode* right; }BTNode; 实现的接口 // 通过前序遍历的数组构建二叉树 BTNode* B...
二叉树的基本操作精集（创建、遍历、求深度结点以及叶子结点个数）
Zxn、Sirius荣耀之路
07-31 4064
对于二叉树的操作一般的我们使用递归的方法，因为在二叉树中每一个子树又是一颗二叉树。 这篇代码主要是演示了二叉树的以下操作 二叉树的创建 二叉树的三种遍历 求解二叉树的高度 求解指定层数的结点个数 求解二叉树的叶子结点个数 /********************************************************* - Copyright (C): 2016 - File
递归求二叉树的结点总数及叶子结点总数
最新发布
Anne_Aust的博客
04-24 4957
这里需要注意叶子结点的定义，即左孩子和右孩子同时为空，同时也需要同时判断左子树以及右子树。
求二叉树中叶子结点的个数
认知 行动 坚持
11-05 2万+
#include #define N 63 using namespace std; char str[] = "ab#d##c#e##"; int i = -1; typedef struct node { struct node *leftChild; struct node *rightChild; char data; }BiTreeNode, *Bi
完全二叉树，知道总节点数，计算叶子结点的数量
点点滴滴
07-26 7344
昨天面试，有一道题是：完全二叉树，知道总节点数，计算叶子结点的数量。由于当时要求在纸上写代码，没有实际运行，所以回来后他这个代码调试一下. // Challenge8.cpp : Defines the entry point for the console application. // #include "stdafx.h" #include "math.h" //问
【数据结构】A．输入根据用户的输入信息，建立二叉树的二叉链表。 B．利用递归和非递归实现二叉树的先序、中序、后序遍历，利用队列实现二叉树的层次遍历。 C．求所有叶子结点总数及深度。
Up_Long的博客
10-18 2182
程序代码 #include<stdio.h> #include<stdlib.h> #include<string.h> #define MaxSize 100 //二叉树 typedef struct BTN { char data; struct BTN *lchild,*rchild; }BTN,*BiTNode; //二叉树非递归遍历栈 ty...
求二叉树叶子结点及其个数
Hello，小高同学
09-05 8576
先序遍历、中序遍历、后序遍历，其实本质都是一样的 图片来源于传智播客课程 //求叶子节点个数,先序 int sum = 0; void Ynumber(BinNode * root) { if (root) { if ((root->lchild == NULL) &&amp...
数据结构--二叉树的遍历--统计二叉树中叶子结点的个数（先序遍历）
复兴之路
08-03 1万+
//统计二叉树中叶子结点的个数 void CountLeaf(BitTree T,int& count)//累加和存储于变量count中，其初值为0 { if(T)//二叉树T如果为空，则什么都不做；不为空时往下执行 { if((!T->lchild)&&(!T->rchild))//如果二叉树左子树和右子树皆为空，说明该二叉树根节点为叶子节点，count加1。
二叉树操作（求节点的个数、求叶子节点个数、求K层节点个数、查找某个值是否存在）
char_m的博客
04-23 2104
二叉树求结点个数遍历思路求解三级目录求结点个数求结点个数 构造二叉树 //定义二叉树 static class Node{ char val; public Node left;// 左孩子的引用，常常代表左孩子为根的整棵左子树 public Node right;// 右孩子的引用，常常代表右孩子为根的整棵右子树 publi...
统计二叉树叶子节点：遍历方法与应用
在本篇文章中，我们将深入探讨如何统计一个二叉树中的叶子节点个数。首先，让我们回顾一下二叉树的基本概念。 二叉树是一种特殊的树形数据结构，其每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值