二叉树详解（C++）

最新推荐文章于 2024-03-10 15:20:09 发布
最新推荐文章于 2024-03-10 15:20:09 发布
阅读量9.1k 收藏 106
点赞数 12
分类专栏： C/C++ 数据结构存储 文章标签： 数据结构 c++ 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_54169998/article/details/121108627
版权

目录

 1.树的基础知识概述

2.二叉树 原理精讲

2.1二叉树

2.2常见二叉树 分类

3.二叉搜索树的算法实现

3.1二叉搜索树插入结点

3.2二叉书搜索树删除结点

3.3二叉搜索树查找   

3.4二叉搜索树遍历结点

3.4.1前序遍历

3.4.2中序遍历

3.4.3后序遍历

4.二叉搜索树完整代码

 1.树的基础知识概述

树状图是一种数据结构，它是由 n（n>=1）个有限结点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：
每个结点有零个或多个子结点；没有父结点的结点称为根结点；每一个非根结点有且只有一个父结点；除了根结点外，每个子结点可以分为多个不相交的子树；

专业术语中 文描 述
Root根节点一棵树的顶点
Child孩子节点一个结点含有的子树的根结点称为该结点的子结点
Leaf叶子节点没有孩子的节点（度为0）
Degree度一个节点包含的子树的数量
Edge边一个节点与另外一个节点的连接
Depth深度根节点到这个节点经过的边的数量
Height节点高度从当前节点到叶子节点形成路径中边的数量
Level层级节点到根节点最长路径的边的总和
Path路径一个节点和另一个节点之间经过的边和 Node 的序列

如图所示：

2.二叉树 原理精讲

2.1二叉树

 二叉树是一个每个结点最多只能有两个分支的树，左边的分支称之为左子树，右边的分支称之为右子树~

（1）在风控二叉树，第i-1层的结点总数不超过2^{i-1}，i>=1；

（2）深度为h-1的二叉树最多有2^h-1个结点（h>=1），最少有h个结点

（3）对于任意一棵二叉树，如果叶节点为N0，而度数为2 的结点总数为N2，则N0=N2+1；

        每个度为1的结点有1条边，度为2的结点有两条边。所以总边数为1*n1+2*n2，总边数等于结点数减1，即  N-1 = 1*n1+2*n2。其中总结点数又等于度为1、度为2、度为0的结点数和，即 N = n1 + n2 + n0；联立可得N0=N2+1。

2.2常见二叉树 分类

 1）完全二叉树 ——若设二叉树的高度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层有叶子节点，并且叶子结点都是从左到右依次排布，这就是完全二叉树（堆就是完全二叉树）。

2）满二叉树 ——除了叶结点外每一个结点都有左右子节点且叶子结点都处在最底层的二叉树。 

 3）平衡二叉树 ——又被称为 AVL 树，它是一颗空树或左右两个子树的高度差的绝对值不超过 1，并且左右两个子树都是一棵平衡二叉树。

4）二叉搜索树 ——又称二叉查找树、二叉排序树（Binary Sort Tree）。它是一颗空树或是满足下列性质的二叉树：（右边>=根>=左边）
        1）若左子树不空，则左子树上所有节点的值均小于或等于它的根节点的值；
        2）若右子树不空，则右子树上所有节点的值均大于或等于它的根节点的值；
        3）左、右子树也分别为二叉排序树。 

5）红黑树 ——是每个节点都带有颜色属性（颜色为红色或黑色）的自平衡二叉查找树，满足下列性质：
        1）节点是红色或黑色；
        2）根节点是黑色；
        3）所有叶子节点都是黑色；
        4）每个红色节点必须有两个黑色的子节点。(从每个叶子到根的所有路径上不能有两个

                连续为红色的结点）；
        5）从任一节点到其每个叶子的所有简单路径都包含相同数目的黑色节点。 （没有度为

                1的结点）。

        以上规则可以保证左右子树结点数差距不超过两倍~

3.二叉搜索树的算法实现

 比如有以下数据：

当我们想保证查找效率时，可以用顺序表存储，当我们想保证插入和删除效率时，我们可以用链式表存储，有没有一种存储方法可以同时兼顾顺序表和链式表的优点？

使用二叉树，便可兼顾查找效率和插入删除效率~

二叉树一般采用链式存储方式：每个结点包含两个指针域，指向两个孩子结点，还包含一个数据域，存储结点信息。 

结点结构体定义：

typedef struct _BNode {
	int data;
	struct _BNode *lchild, *rchild;
}Bnode,*Btree;

3.1二叉搜索树插入结点


//二叉树插入结点
/*将插入结点e，与结点root结点进行比较，若小于则去到左子树，否则
去右子树进行比较，重复以上操作直到找到一个空位置放置该结点
*/
bool InsertBtree(Btree* root, Bnode* node) {
	Bnode* temp = NULL;
	Bnode* parent = NULL;
	if (!node) {			//如果插入结点为空，返回false
		return false;
	}else {					//清空插入结点的左右子树
		node->lchild = NULL;
		node->rchild = NULL;
	}

	if (!(*root)) {			//如果根节点不存在，将插入结点作为根节点
		*root = node;
		return true;
	}else {					
		temp = *root;
	}

	while (temp != NULL) {
		parent = temp;
		if (temp->data>node->data) {    //小于，继续向左
			temp = temp->lchild;
		}
		else {							//大于，继续向右（不可以有相同的值）
			temp=temp->rchild;
		}  
		//while循环结束，parent所处位置即为要插入结点的父结点
	}
	if (node->data < parent->data) {
		parent->lchild = node;
	}
	else {
		parent->rchild = node;
	}
	return true;
}

3.2二叉书搜索树删除结点

 将要删除的节点的值，与节点 root 节点进行比较，若小于则去到左子树进行比较，若大于则去到右子树进行比较，重复以上操作直到找到一个节点的值等于删除的值，则将此节点删除。删除时有 4 中情况须分别处理：

 1.删除节点不存在左右子节点，即为叶子节点，直接删除

2.删除节点存在左子节点，不存在右子节点，直接把左子节点替代删除节点

 

 3.删除节点存在右子节点，不存在左子节点，直接把右子节点替代删除节点

 4.删除节点存在左右子节点，则取左子树上的最大节点或右子树上的最小节点替换删除节点。

代码实现：

//查找左子树最大值
int findLeftMax(Btree* root) {
	/*采用递归方式查找
	* if (root->rchild == NULL)
		return root->data;
	return findMax(root->rchild);
	*/
	//采用循环查找
	Btree indexNode = *root;
	while (indexNode->rchild)
		indexNode = indexNode->rchild;
	return indexNode->data;
}


//采用递归的方式删除结点
/*
	这种递归方式，是将要修改的结点的一层一层的返回
*/
Btree deleteNode(Btree* root, int value) {
	Btree compareNode = *root;		
	//节点为空（递归找不到value/根节点为空），直接返回
	if (!compareNode)return compareNode;			
	//大于
	if (compareNode->data > value) {
		//左子树重新被赋值
		compareNode->lchild = deleteNode(&(compareNode->lchild), value);		
		return compareNode;																
	}
	//小于
	else if (compareNode->data < value) {		
		//右子树重新被赋值
		compareNode->rchild = deleteNode(&(compareNode->rchild), value);		
		return compareNode;
	}
	else {//等于											
		Btree temp = NULL;
		//无左右子节点，直接返回NULL
		if (compareNode->lchild == NULL && compareNode->rchild == NULL) {		
			delete compareNode;
		}
		//有左子树，返回左子树
		else if (compareNode->lchild && compareNode->rchild == NULL) {			
			temp = compareNode->lchild;
			delete compareNode;
		}
		//有右子树，返回右子树
		else if (compareNode->rchild && compareNode->lchild == NULL) {			
			temp = compareNode->rchild;
			delete compareNode;
		}
		else {											
			//这里采用左子树最大值替换				
			int leftMax = findLeftMax(&(compareNode->lchild));				
			//最大值替换删除结点的值
			compareNode->data = leftMax;										
			//将最大值从树中删除
			compareNode->lchild = deleteNode(&(compareNode->lchild), leftMax);
			temp= compareNode;
		}
		return temp;
	}
}

3.3二叉搜索树查找   

// 采用递归方式查找结点
/*
Bnode* queryByRec(Btree root, int value) {
	if (root == NULL || root->data==value ){
		return root;
	}
	else if (root->data < value) {
		return queryByRec(root->lchild, value);
	}
	else {
		return queryByRec(root->rchild, value);
	}
}*/

// 使用非递归方式查找结点

Bnode* queryByLoop(Btree root, int value) {
	while (root != NULL && root->data!=value) {
		if (root->data>value) {
			root = root->lchild;
		}
		else {
			root = root->rchild;
		}
	}
	return root;
}

3.4二叉搜索树遍历结点

3.4.1前序遍历

 前序遍历 - 先访问根节点，然后前序遍历左子树，再前序遍历右子树

 上图前序遍历结果： 19 7 5 11 15 25 21 61

void PreOrderRec(Btree* root) {
	Btree indexNode = *root;
	if (indexNode == NULL)return;
	printf("—%d", indexNode->data);
	PreOrderRec(&indexNode->lchild);
	PreOrderRec(&indexNode->rchild);
}

或者使用栈

具体过程：
1.首先申请一个新的栈，记为 stack；
2.将头结点 head 压入 stack 中；
3.每次从 stack 中弹出栈顶节点，记为 cur，然后打印 cur 值，如果 cur 右孩子不为空，则将 右孩子压入栈中；如果 cur 的左孩子不为空，将其压入 stack 中；
重复步骤 3，直到 stack 为空。

关于栈的代码将会放在文章末尾~

3.4.2中序遍历

中序遍历 - 先访问根节点的左子树，然后访问根节点，最后遍历右子树 

 中序遍历结果： 5 7 11 15 19 21 25 61

3.4.3后序遍历

后序遍历 - 从左到右，先叶子后节点的方式遍历访问左右子树，最后访问根节点 

 后序遍历结果： 5 15 11 7 21 61 25 19

4.二叉搜索树完整代码

#include<iostream>
#include <stdlib.h>    
using namespace std;


typedef struct _BNode {
	int data;
	struct _BNode *lchild, *rchild;
}Bnode,* Btree;


//二叉树插入结点
/*将插入结点e，与结点root结点进行比较，若小于则去到左子树，否则
去右子树进行比较，重复以上操作直到找到一个空位置放置该结点
*/

bool InsertBtree(Btree* root, Bnode* node) {
	Bnode* temp = NULL;
	Bnode* parent = NULL;
	if (!node) {			//如果插入结点为空，返回false
		return false;
	}else {					//清空插入结点的左右子树
		node->lchild = NULL;
		node->rchild = NULL;
	}

	if (!(*root)) {			//如果根节点不存在，将插入结点作为根节点
		*root = node;
		return true;
	}else {					
		temp = *root;
	}

	while (temp != NULL) {
		parent = temp;
		if (temp->data>node->data) {    //小于，继续向左
			temp = temp->lchild;
		}
		else {							//大于，继续向右（不可以有相同的值）
			temp=temp->rchild;
		}  
		//while循环结束，parent所处位置即为要插入结点的父结点
	}
	if (node->data < parent->data) {
		parent->lchild = node;
	}
	else {
		parent->rchild = node;
	}
	return true;
}
//二叉搜索树删除结点
//1.删除叶节点，直接删除
//2.删除结点存在左子树，不存在右子树，直接把左子节点替代删除结点
//3.删除结点存在有子节点，不存在左子节点，直接把右子节点代替删除结点
//4.删除结点存在左右子节点，则取左子树最大结点或右子树最小系欸DNA替换删除
//结点



int findLeftMax(Btree* root) {
	/*采用递归方式查找
	* if (root->rchild == NULL)
		return root->data;
	return findMax(root->rchild);
	*/
	//采用循环查找
	Btree indexNode = *root;
	while (indexNode->rchild)
		indexNode = indexNode->rchild;
	return indexNode->data;
}


//采用递归的方式删除结点
/*
	这种递归方式，是将要修改的结点的一层一层的返回
*/
Btree deleteNode(Btree* root, int value) {
	Btree compareNode = *root;		
	//节点为空（递归找不到value/根节点为空），直接返回
	if (!compareNode)return compareNode;			
	//大于
	if (compareNode->data > value) {
		//左子树重新被赋值
		compareNode->lchild = deleteNode(&(compareNode->lchild), value);		
		return compareNode;																
	}
	//小于
	else if (compareNode->data < value) {		
		//右子树重新被赋值
		compareNode->rchild = deleteNode(&(compareNode->rchild), value);		
		return compareNode;
	}
	else {//等于											
		Btree temp = NULL;
		//无左右子节点，直接返回NULL
		if (compareNode->lchild == NULL && compareNode->rchild == NULL) {		
			delete compareNode;
		}
		//有左子树，返回左子树
		else if (compareNode->lchild && compareNode->rchild == NULL) {			
			temp = compareNode->lchild;
			delete compareNode;
		}
		//有右子树，返回右子树
		else if (compareNode->rchild && compareNode->lchild == NULL) {			
			temp = compareNode->rchild;
			delete compareNode;
		}
		else {											
			//这里采用左子树最大值替换				
			int leftMax = findLeftMax(&(compareNode->lchild));				
			//最大值替换删除结点的值
			compareNode->data = leftMax;										
			//将最大值从树中删除
			compareNode->lchild = deleteNode(&(compareNode->lchild), leftMax);
			temp= compareNode;
		}
		return temp;
	}
}


// 采用递归方式查找结点
/*
Bnode* queryByRec(Btree root, int value) {
	if (root == NULL || root->data==value ){
		return root;
	}
	else if (root->data < value) {
		return queryByRec(root->lchild, value);
	}
	else {
		return queryByRec(root->rchild, value);
	}
}*/

// 使用非递归方式查找结点

Bnode* queryByLoop(Btree root, int value) {
	while (root != NULL && root->data!=value) {
		if (root->data>value) {
			root = root->lchild;
		}
		else {
			root = root->rchild;
		}
	}
	return root;
}

void PreOrderRec(Btree* root) {
	Btree indexNode = *root;
	if (indexNode == NULL)return;
	printf("—%d", indexNode->data);
	PreOrderRec(&indexNode->lchild);
	PreOrderRec(&indexNode->rchild);
}

int main() {
	//_CrtSetBreakAlloc(86);
	int test[] = { 19,7,25,5,11,15,21,61 ,4};
	Btree root = NULL;
	Btree node = NULL;
	node = new Bnode;
	node->data = test[0];
	InsertBtree(&root, node);
	for (int i = 1; i < sizeof(test) / sizeof(int); i++) {
		node = new Bnode;
		node->data = test[i];
		InsertBtree(&root, node);
	}
	printf("前序遍历\n");
	PreOrderRec(&root);

	root= deleteNode(&root, 19);
	printf("\n");
	printf("删除19后的前序遍历\n");
	PreOrderRec(&root);
	printf("\n");
	Btree temp;
	printf("查找数据为61\n");
	temp = queryByLoop(root, 61);
	cout << temp->data << endl;

	system("pause"); 
	return 0;
}

运行结果：

  stack代码实现：

#pragma once
#include<stdio.h>
#include<stdlib.h>
#define MaxSize 128 //预先分配空间，这个数值根据实际需要预估确定
typedef struct _SqStack {
	Bnode* base; //栈底指针
	Bnode* top; //栈顶指针
}SqStack;
bool InitStack(SqStack& S) //构造一个空栈 S
{
	S.base = new Bnode[MaxSize];//为顺序栈分配一个最大容量为 Maxsize 的空间
		if (!S.base) //空间分配失败
			return false;
	S.top = S.base; //top 初始为 base，空栈
	return true;
}
bool PushStack(SqStack& S, Bnode e) // 插入元素 e 为新的栈顶元素
{
	if (S.top - S.base == MaxSize) //栈满
		return false;
	*(S.top++) = e; //元素 e 压入栈顶，然后栈顶指针加 1，等价于*S.top=e;
	S.top++;
	return true;
}
bool PopStack(SqStack& S, Bnode& e) //删除 S 的栈顶元素，暂存在变量 e中
{
	if (S.base == S.top) { //栈空
		return false;
	}
		e = *(--S.top); //栈顶指针减 1，将栈顶元素赋给 e
	return true;
}
Bnode* GetTop(SqStack& S) //返回 S 的栈顶元素，栈顶指针不变
{
	if (S.top != S.base) { //栈非空
		return S.top - 1; //返回栈顶元素的值，栈顶指针不变
	}
	else {
		return NULL;
	}
}
int GetSize(SqStack& S) {//返回栈中元素个数
	return (S.top - S.base);
}
bool IsEmpty(SqStack& S) {//判断栈是否为空
	if (S.top == S.base) {
		return true;
	}
	else {
		return false;
	}
}
void DestroyStack(SqStack& S) {//销毁栈
	if (S.base) {
		free(S.base);
		S.base = NULL;
		S.top = NULL;
	}
}
霸道小明
关注
  • 12
    点赞
  • 踩
  • 106
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ 遍历二叉树实例详解
08-30
主要介绍了C++ 遍历二叉树实例详解的相关资料,需要的朋友可以参考下
c++二叉树详解（附基本操作代码版）
Yoyo的博客
07-10 4150
二叉树可以说是树形数据结构中最基础的，且在多种领域都有应用（比如语法树，二值决策树），熟悉其各种操作是必须的。char data;}BT;// 根据输入二点中序表达式和前序表达式创建一颗二叉树// 展示一颗二叉树，以A(B, C(D, E))这样加了括号的前序遍历来实现// 销毁二叉树// 判断这颗树是不是完全二叉树// 计算树的高度// 计算叶子的数量// 计算树的宽度// 层次遍历// 前序遍历// 中序遍历// 后序遍历。
C++实现二叉树
最新发布
qq_45285738的博客
03-10 539
接下来，你将看到，输出先序、层序遍历结果等内容，如下：（注：中序后序，操作类似于前序遍历，没有实现）1.2 实现二叉树的访问 --- 先中后序访问、层序访问。1.3 计算树的深度、节点数、复制树。2.1 首先创建出一棵二叉树。1.1 实现二叉树的创建。
C++实现二叉树基本操作详解
08-28
主要为大家详细介绍了C++实现二叉树基本操作，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
c++先序二叉树的构建详解
08-26
在本篇文章里小编给大家分享了关于c++先序二叉树的构建的相关知识点，需要的朋友们跟着学习下。
c++数据结构-树（详细总结附代码，一看就懂）
我的博客
01-19 5207
一棵树是由n（n>0）个元素组成的有限集合，其中：（1）每个元素称为结点（node）（2）有一个特定的结点，称为根结点或树根（root）（3）除根节点外，其余节点能分成m（m>=0）个互不相交的有限集合 T(0)-T(m-1)。其中的每一个子集都是一个树，这些集合被称为这棵树的子树。
c++的二叉树
客舟中
01-01 1万+
目录 二叉树的定义 二叉树的分类 1. 完全二叉树 2. 满二叉树 3. 斜树 4. 二叉搜索树 5. 平衡二叉树 二叉树的存储方式 1. 数组存储 2. 链表存储 二叉树的遍历方式 1. 前序遍历 2. 中序遍历 3. 后序遍历 4. 层序遍历 二叉树的代码实现 总结 技术参考 二叉树的定义 二叉树是每个节点最多只有两个子树的数结构，两个子树称为左子树和右子树。 二叉树的分类 1. 完全二叉树 假设其深度为 d（d>1）。除了第 d 层外....
数据结构之二叉树（c++）
qq_57541265的博客
03-19 8263
本文章主要介绍二叉树的概念，二叉树的存储结构，二叉树的插入，删除，查找，遍历，等操作
c++ || 详解二叉树
LQEmptycity的博客
08-17 1068
树
C++实现树 - 02 二叉树
Newin2020的博客
05-04 4984
写在前面： 这一讲我们来看看二叉树的实现，还不清楚树的结构的小伙伴建议先看看上面一讲关于树的定义。 二叉树的定义 二叉树是每个结点最多有两个子树的树结构。也就是说二叉树不允许存在度大于2的树。它有五种最基本的形态：二叉树可以是空集。根可以有空的左自树或者右子树；或者左右子树都是空。其中只有左子树或者右子树的叫做斜树。 二叉树的主要性质 性质 结论 性质一 在二叉树的 i 层上至多有 2 ^ ( i - 1 ) 个结点（ i >= 1 ） 性质二 深度为 k 的二叉树至多有 2.
C++数据结构---二叉树
Rookie_Ws的博客
04-22 3194
树 树的概念 树是一种能分层存储数据的数据结构，树中的每个元素被称为树的节点，每个节点有若干个指针指向子节点 从节点的角度来看，树是由唯一的起始结点引出的节点集合，这个起始结点被称为根(root)， 树中节点的子树数目称为节点的度 树的度指其中节点的度最大值。比如1号节点的孩子是2、3、4，则1号节点的度数是3，且1号节点的度是最大的，故该树的度为3。 二叉树 二叉树是指对于树中的每个节点而言，最多由两个子节点，即任意节点的度小于等于2 层数：从根节点到某个节点的路径长度，根节点为0层 高度：最大层数+
[c++]二叉排序树(Binary Sort Tree)详解
EQUINOX1的博客
07-24 554
二叉树是一种很基础的数据结构，而二叉排序树则是一种插入，删除，查找效率都不错的一种数据结构。二叉排序树的特性就是左子树键值小于根，右子树键值大于根，所以二叉排序树就天然的具有查找功能，有时二叉排序树又叫二叉搜索树或者二叉查找树。
《数据结构C语言版》——二叉树详解(图文并茂)
青春无问西东 岁月自成芳华
05-20 1万+
C语言版本的数据结构详解，讲解树、二叉树及其对应的定义、建立、性质
数据结构——二叉树、哈夫曼树、堆、二叉排序树等树状结构的详细讲解与C++的实现和应用（即使没学栈和队列也可以看）
m0_70379664的博客
08-14 704
数据结构——二叉树、哈夫曼树、堆、二叉排序树等树状结构的详细讲解与C++的实现和应用（即使没学栈和队列也可以看）
C++数据结构——二叉树
caijiandl的博客
07-31 3260
二叉树 项目 项目 项目 项目1 项目2 项目3 计划任务 完成任务 二叉搜索树 二叉搜索树是二叉树的一种特殊形式。 二叉搜索树具有以下性质：每个节点中的值必须大于（或等于）其左侧子树中的任何值，但小于（或等于）其右侧子树中的任何值。 我们将在本章中更详细地介绍二叉搜索树的定义，并提供一些与二叉搜索树相关的习题。 完成本卡片后，你将： 理解二叉搜索树的特性 熟悉在二叉搜索树中的基本操作 理解高度平衡二叉搜索树的概念 二叉搜索树的定义 **二叉搜索树（BST）**是二叉树的一种
c++二叉树详解
Yoyo的博客
06-03 337
现在，有N个结点的二叉树，这些节点放在biTree数组中，每个结点的左右指针为其左右孩子节点的下标，下标从从1到N。⑤结点的层次：从根结点开始，假设根结点为第1层，根结点的子节点为第2层，依此类推，如果某一个结点位于第L层，则其子节点位于第L+1层。满二叉树：如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。②结点的度：一个结点拥有子树的数目称为结点的度，二叉树的结点度最少是0，最多是2。③叶子结点：也称为终端结点，没有子树的结点或者度为零的结点。
二叉树的基本操作(C++实现)
热门推荐
qq_52109814的博客
08-09 2万+
基本概念 二叉树由结点的有限集合构成。 这个有限集合要么是空集，要么是一个根节点及两棵互不相交、分别称为这个跟的左子树和右子树的二叉树组成的集合。 二叉树的特点 每个结点最多有两棵子树，所以二叉树中不存在度大于2的结点。 左子树和右子树是有顺序的，次序不能随意颠倒。 及时树中某结点只有一颗子树，也要区分它是左子树还是右子树。 二叉树的五种基本形态 空二叉树 只有一个根节点 根节点只有左子树 根节点只有右子树 根节点既有左子树，又有右子树 相关概念 边（edge）：两个结点（node）的有序对（ord
C++数据结构：二叉树
weixin_44404541的博客
04-13 415
每个结点最多只有二棵子树，也就是二叉树中没有度大于2的结点。二叉树的子树有左右之分，严格区分左孩子、右孩子，其次序不能颠倒二叉树五种基本形态。
二叉树的详细实现 (C++)
dielu7895的博客
05-13 2202
二叉树的定义 以递归形式给出的：一棵二叉树是结点的一个有限集合，该集合或者为空，或者是由一个根结点加上两棵分别称为左子树和右子树的、互不相交的二叉树组成。二又树的特点是每个结点最多有两个子女，分别称为该结点的左子女和右子女。在二又树中不存在度大于2的结点，并且二又树的子树有左、右之分，其子树的次序不能颠倒。二又树是分支数最大不超过2的有根有序树。它可能有5种不同的形态。 ...
二叉树:完全二叉树判断c++
05-29
判断一棵二叉树是否为完全二叉树可以通过遍历节点并进行判断，以下是一个基于BFS（广度优先搜索）的C++代码实现： ```C++ #include <iostream> #include <queue> using namespace std; struct Node { int data; Node* left; Node* right; Node(int d) : data(d), left(nullptr), right(nullptr) {} }; bool isCompleteBT(Node* root) { if (root == nullptr) return true; queue<Node*> q; q.push(root); bool flag = false; // 标识是否出现过NULL节点 while (!q.empty()) { Node* cur = q.front(); q.pop(); if (cur == nullptr) { flag = true; } else { if (flag) return false; q.push(cur->left); q.push(cur->right); } } return true; } int main() { Node* root = new Node(1); root->left = new Node(2); root->right = new Node(3); root->left->left = new Node(4); root->left->right = new Node(5); root->right->left = new Node(6); root->right->right = new Node(7); if (isCompleteBT(root)) { cout << "This is a complete binary tree" << endl; } else { cout << "This is not a complete binary tree" << endl; } return 0; } ``` 在上述代码中，我们使用了一个队列来存储待遍历的节点，遍历过程中，如果遇到了一个NULL节点，则将标识flag设为true，如果之后还遇到了非NULL节点，就说明这棵树不是完全二叉树，直接返回false即可。如果遍历完成后仍然没有返回false，则说明这棵树是完全二叉树，返回true即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值