一文带你搞懂二叉树

已于 2023-11-11 17:24:25 修改
阅读量707 收藏 26
点赞数 25
分类专栏： 数据结构学习之路 文章标签： 数据结构
于 2023-10-05 11:29:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_73708736/article/details/133561299
版权

目录

一、什么是二叉树

二、创建二叉树

1）二叉树的结构：

2）创建二叉树：

三、二叉树的遍历方式

1）前序遍历：

2）中序遍历：

3）后序遍历：

4）还原二叉树 ：

5）层序遍历：

 四、二叉树的基本操作：

1）二叉树节点个数：

2）二叉树叶子节点个数：

3）二叉树第K层节点个数：

4）二叉树查值：

5）判断是否为完全二叉树：

 

 

一、什么是二叉树

        二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分。

        二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点————百度百科cb73167a34a149f68c44feccdad90f3a.png

二叉树的最上层也就是第一层（也可以认为是第0层）为根节点(root)，二叉树如其名，每个节点都有对应的左孩子和右孩子，只不过有些孩子为NULL ，也就是说每个节点最多有两个孩子的树为二叉树(Binary Tree)。

        二叉树还可以再细分，其中有两种常见结构，一种是满二叉树(Full Binary Tree)，一种是完全二叉树(Compelete Binary Tree)。

满二叉树：

        除最后一层无任何子节点外，每一层上的所有结点都有两个子结点的二叉树。一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的深度为K，且结点总数是(2^k) -1 ，则它就是满二叉树。

完全二叉树：

        一棵深度为k的有n个结点的二叉树，对树中的结点按从上至下、从左到右的顺序进行编号，如果编号为i（1≤i≤n）的结点与满二叉树中编号为i的结点在二叉树中的位置相同，则这棵二叉树称为完全二叉树。

以下则为几种不同的二叉树结构实例： 

911c4ca9c83a4714a37209afbbba0a6a.png接下来，我们学习以下如何创建一颗二叉树。

 

二、创建二叉树

1）二叉树的结构：

        二叉树的一个个孩子其实就是节点，这个节点存放着左孩子和右孩子的信息，以及节点所存放的数据。知道以上信息我们就可以定义出二叉树的结构了：

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;//每个节点所存储的信息
	struct BinaryTreeNode* left;//左孩子
	struct BinaryTreeNode* right;//右孩子
}BTNode;

        其实我们前面学习的链表也可以看作二叉树，只不过是一个特殊的二叉树，每个节点最多只有一个子孩子不为NULL的二叉树，所以结构上看着与前面的链表相似。 

2）创建二叉树：

        二叉树的创建与前面学习的链表与顺序表都不同，当然你可以采用手动连接成一颗二叉树，但是今天我们要介绍的是递归式生成二叉树。

        首先，假设有这样一颗二叉树：             b6d581dbe7c74ae7a50e935380bf3e7a.png

这里'#'代表NULL，其他字符就代表节点的数据，那么构建的方式就是用二叉树最常用的构建方式（root——left——right）方式来递归构建，这种方式为前序遍历，我们稍后会提到。

下面为递归创建二叉树的代码：

BTNode* BinaryTreeCreate(BTDataType* a, int* pi)//传入的数组保存着节点的数据，指针pi用来索引数组的下标
{
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));//创建二叉树的当前节点
	root->left = root->right = NULL;//将左右子树置空
	if (a[(*pi)] == '#')//'#'代表NULL指针，遇到空指针直接返回NULL
	{
		(*pi)++;
		return NULL;
	}
	root->data = a[(*pi)++];//存储二叉树节点的数据
    //由 根--左--右 的递归方式构建二叉树
	root->left = BinaryTreeCreate(a, pi);//左孩子接收左子树返回值
	root->right = BinaryTreeCreate(a, pi);//右孩子接收右孩子返回值
	return root;//返回上一节点
}

在这里我们有必要理解递归构建二叉树的过程：778d03dc8a13416d9a562e81d2c77928.png        下面我来讲解一下如何进行递归的，最好边看图边理解递归：

        根据上面的代码，首先生成节点A，对A（右子树还未递归）进行左路递归，进入到下一层左孩子不为空构建B（右子树还未递归）。

        B向左孩子递归，左孩子不为空构建D，D在进行递归，递归到左孩子为NULL，则继续进行右路递归，发现右孩子也为NULL,这时候这个节点已经递归完毕，返回上一个节点B。

        此时B的左路递归结束，进行右路递归，右路递归不为NULL，生成节点E。

        E节点继续左路递归发现左路为NULL,则左路结束进行右路递归，右子树不为空，生成节点H,节点H向左递归左路为NULL,进行右路递归，右路为NULL，递归结束，返回到节点E。

        此时节点E也递归结束，返回到节点B，节点B的右路递归也结束，返回到根节点A的左子树部分，此时A的左子树部分递归完毕，向右子树递归，右子树的递归和前面相同方式就不多说了。

 

三、二叉树的遍历方式

        我们已经了解了二叉树的几种结构了，但是请来思考一下这种数据结构，二叉树是用来存储数据的，我们该怎样拿到对应的数据呢？怎样知道自己数据存储是不是对的呢？既然要存储数据，那么遍历一定是少不了的，二叉树的遍历方式与顺序表，链表其实是不同的，接下来我们来学习一下二叉树的遍历方式。

        首先，二叉树的遍历方式是使用递归来完成的，我们前面提到了前序遍历，没错，前序遍历就是一种遍历二叉树的方法，除此以外，遍历二叉树的常用方法还有：中序遍历，后序遍历，层序遍历（也叫广度优先遍历Breadth First Search，简称BFS）。

        中序遍历和后序遍历与前序遍历相似这里就不在展示了，顾名思义，层序遍历而其中层序遍历需要用到栈的数据结构，每次需要根节点的左右子节点依次入栈，这里并不是递归的过程，直到全部入栈，最后输出就为层序遍历的结果。73aea5fc0b224e5fbec2b8e0ca8478c7.png

1）前序遍历：

void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
		return;
	printf("%c ", root->data);//前序按照根左右方式遍历，这里的根就是直接打印出来
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
	return;
}

2）中序遍历：

void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeInOrder(root->left);
	printf("%c ", root->data);//中序遍历就是左根右方式遍历
	BinaryTreeInOrder(root->right);
	return;
}

3）后序遍历：

void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->data);//后序就是左右根
}

4）还原二叉树 ：

三序遍历结果如下：

08540ba55a304cd5af823f6317992fe9.png

        前中后序遍历的结果也只是一串数字，那么怎么判断这几串数是不是二叉树呢？其实很简单，前序遍历的结果一定是符合根左右的，那么根节点一定是第一个数据，知道了根节点的位置，那么中序遍历就可以从节点分成左子树和右子树，很容易就还原出二叉树。174d7edc9c814be480457531df8dcae5.png

5）层序遍历：

BTNode* stack[MAX_OP];//开辟一个数组表示栈，MAX_OP为20
void BinaryTreeLevelOrder(BTNode* root)
{
	int head, tail;
	head = tail = 0;//这里使用头尾指针进行二叉树元素的索引
	stack[tail++] = root;//首先将根节点入栈，此时将tail+1
	while (head < tail)当头小于尾的时候表示没有全部入栈
	{
		BTNode* node = stack[head++];//把当前节点保存
		if (node->left)//左孩子存在入左孩子
		{
			stack[tail++] = node->left;//入栈
			printf("\t%c -> %c(left)\n", node->data, node->left->data);//将左孩子标注打印
		}
		if (node->right)//右孩子存在入右孩子
		{
			stack[tail++] = node->right;
			printf("\t%c -> %c(right)\n", node->data, node->right->data);//将右孩子标注打印
		}
	}
	return;
}

 

 四、二叉树的基本操作：

        除了二叉树的前中后序遍历和层序遍历外，以下几种二叉树常见用法也给大家来分析一下，以便于更好理解二叉树的递归。

1）二叉树节点个数：

        二叉树的节点个数统计是比较简单的，如果当前点不为空就进行左右递归，每次递归都会记录一个节点，最后返回的值就为节点总数，可以结合着下面的递归展开图来看（红色为向下递的过程，蓝色为往回归的过程）f0804a7f3550443ab12c14eb172de094.png

int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;//当前点不为空就进行左右递归，每次递归都会记录一个节点，最后返回的值就为节点总数
}

2）二叉树叶子节点个数：

        二叉树求叶子节点个数就是上面的变形，只需要加上边界条件（左右孩子都为空才为叶子节点）就行了 ，如果还是不太懂就学我上面画出递归展开图，我已经举例了尝试着自己画吧。

int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (!root->left && !root->right)//左右孩子都为空才是叶子节点，则返回1
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

3）二叉树第K层节点个数：

        求二叉树的第k层节点，其实也很简单，每次向下递归就-1，直到k为1的时候，表示已经到了该层，就像坐电梯一样会显示你的当前层数，无论你的k为几，你的终点站都是1楼，那么实现起来就简单了，如果还是不太懂，老样子，画出递归展开图就懂了：

int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(root);
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

4）二叉树查值：

        这个比较简单，遍历二叉树就行了，不需要多说。

BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	if (!root) return NULL;
	if (root->data == x) return root;

	//单边查找:先左后右
	if (BinaryTreeFind(root->left, x))//如果左边为空则向右查找
		return BinaryTreeFind(root->left, x); //不为空则向下递归查找
	else
		return BinaryTreeFind(root->right, x);
}

5）判断是否为完全二叉树：

        想要判断一棵树是否为完全二叉树，那么首先就得了解完全二叉树的结构，思考一下以什么样的方式可以证明一棵树是完全二叉树？完全二叉树由定义可知，最后一层以上的节点都是满的，而且最后一层节点都是有序的。

        那么只需要这个二叉树全部有序，遍历的过程中间没有空节点，直到遍历到最后一个节点，之后都是空即可，如果中间出现了缺少节点的情况，那么中间一定会出现空节点，空节点后面一定还会有没遍历的节点。

        基于此，使用数据结构中的队列可以完美解决这个问题，先将根节点入队，然后再循环内将左右节点入队，在将根节点出队，当遇到空节点就会停止循环，如果这棵树不是完全二叉树，那么队列中下一个数据就一定不为空，基于此代码如下：

bool BinaryTreeComplete(BTNode* root, int len)
{
	assert(root);
	Que q;
	InitNewQueue(&q);//初始化队列 

	if (root)
	{
		QueuePush(&q, root);//root不为空的话进行入队 
	}

	while (!QueueEmpty(&q))//队列不为空的时候进行入队操作 
	{
		BTNode* front = QueueFront(&q);//队头结点 
		if (front == NULL)
		{
			break;
		}
		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
		QueuePop(&q);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;//层序遍历后为连续节点为直接返回true 
}

 

五、二叉树测试 

1）队列信息：

        这里采用的为链式队列：

typedef struct BinaryTreeNode* QDataType;

typedef struct QueueNode {
	struct QueueNode* next;
	QDataType data;
}QNode;

typedef struct Queue {
	QNode* head;
	QNode* tail;
	int size;
}Que;

//初始化队列  
void InitNewQueue(Que* q)
{
	assert(q);

	q->head = q->tail = NULL;
	q->size = 0;
	return;
}

//入队操作
void QueuePush(Que* q, QDataType x)
{
	assert(q);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	if (newnode == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	newnode->data = x;
	newnode->next = NULL;
	if (q->tail == NULL)
	{
		q->head = q->tail = newnode;
	}
	else
	{
		q->tail->next = newnode;
		q->tail = newnode;
	}

	q->size++;
	return;
}

//出队操作 
void QueuePop(Que* q)
{
	assert(q);
	if (q->head->next == NULL)
	{
		free(q->head);
		q->head = q->tail = NULL;
	}
	else
	{
		QNode* next = q->head->next;
		free(q->head);
		q->head = next;
	}

	q->size -= 1;
	return;
}

//队列判空操作 
bool QueueEmpty(Que* q)
{
	assert(q);
	return q->head == NULL;
}

//取队头元素 
QDataType QueueFront(Que* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->head->data;
}

//取队尾元素 
QDataType QueueBack(Que* q)
{
	assert(q);
	assert(!QueueEmpty(q));

	return q->tail->data;
}

//队列销毁 
void QueueDestroy(Que* q)
{
	assert(q);
	while (q->head)
	{
		QNode* tmp = q->head->next;
		free(q->head);
		q->head = tmp;
	}
	q->head = q->tail = NULL;
	q->size = 0;
	return;
}

2）二叉树操作：

#define MAX_OP 20

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;

// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树	000
BTNode* BinaryTreeCreate(BTDataType* a, int* pi)
{
	BTNode* root = (BTNode*)malloc(sizeof(BTNode));
	root->left = root->right = NULL;
	if (a[(*pi)] == '#')
	{
		(*pi)++;
		return NULL;
	}
	root->data = a[(*pi)++];
	root->left = BinaryTreeCreate(a, pi);
	root->right = BinaryTreeCreate(a, pi);
	return root;
}

// 二叉树销毁	000
void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeDestory(root->left);
	BinaryTreeDestory(root->right);
	free(root);
	return;
}

// 二叉树节点个数	000
int BinaryTreeSize(BTNode* root)
{
	return root == NULL ? 0 : BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

// 二叉树叶子节点个数	000
int BinaryTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;
	if (!root->left && !root->right)
		return 1;
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

// 二叉树第k层节点个数	000
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	assert(root);
	if (k == 1)
		return 1;
	return BinaryTreeLevelKSize(root->left, k - 1) + BinaryTreeLevelKSize(root->right, k - 1);
}

// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
	//assert(root);
	if (!root) return NULL;
	if (root->data == x) return root;

	//单边查找:先左后右
	if (BinaryTreeFind(root->left, x))//如果左边为空则向右查找
		return BinaryTreeFind(root->left, x); //不为空则向下递归查找
	else
		return BinaryTreeFind(root->right, x);
}

// 二叉树前序遍历 	000
void BinaryTreePrevOrder(BTNode* root)
{
	if (root == NULL)
		return;
	printf("%c ", root->data);
	BinaryTreePrevOrder(root->left);
	BinaryTreePrevOrder(root->right);
	return;
}

// 二叉树中序遍历	000
void BinaryTreeInOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreeInOrder(root->left);
	printf("%c ", root->data);
	BinaryTreeInOrder(root->right);
	return;
}

// 二叉树后序遍历	000
void BinaryTreePostOrder(BTNode* root)
{
	if (root == NULL)
		return;
	BinaryTreePostOrder(root->left);
	BinaryTreePostOrder(root->right);
	printf("%c ", root->data);
}

// 层序遍历（DFS）	000
BTNode* stack[MAX_OP];
void BinaryTreeLevelOrder(BTNode* root)
{
	int head, tail;
	head = tail = 0;
	stack[tail++] = root;
	while (head < tail)
	{
		BTNode* node = stack[head++];
		if (node->left)
		{
			stack[tail++] = node->left;
			printf("\t%c -> %c(left)\n", node->data, node->left->data);
		}
		if (node->right)
		{
			stack[tail++] = node->right;
			printf("\t%c -> %c(right)\n", node->data, node->right->data);
		}
	}
	return;
}

// 判断二叉树是否是完全二叉树
//ABD##E#H##CF##G##
bool BinaryTreeComplete(BTNode* root, int len)
{
	assert(root);
	Que q;
	InitNewQueue(&q);//初始化队列 

	if (root)
	{
		QueuePush(&q, root);//root不为空的话进行入队 
	}

	while (!QueueEmpty(&q))//队列不为空的时候进行入队操作
	{
		BTNode* front = QueueFront(&q);//队头结点
		if (front == NULL)
		{
			break;
		}
		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
		QueuePop(&q);
	}

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		if (front != NULL)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;//层序遍历后为连续节点为直接返回true 
}

3）测试用例：

void Test()
{
	int i = 0;
	//二叉树插入顺序：ABD##E#H##CF##G##
	char a[] = { 'A', 'B', 'D', '#', '#', 'E', '#', 'H', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#', '\0' };
	BTNode* root = BinaryTreeCreate(a, &i);

	BTNode* p = BinaryTreeFind(root, 'B');
	if (p)
	{
		printf("Search: %c is exist\n", p->data);
	}

	BinaryTreePrevOrder(root);	printf(":prevorder\n");
	BinaryTreeInOrder(root);	printf(":inorder\n");
	BinaryTreePostOrder(root);	printf(":postorder\n");

	int len = BinaryTreeSize(root);
	printf("TreeSize :%d\n", len);

	int len2 = BinaryTreeLeafSize(root);
	printf("TreeLeaf :%d\n", len2);

	int len3 = BinaryTreeLevelKSize(root, 2);
	printf("TreeLeve :%d\n", len3);

	BinaryTreeLevelOrder(root);

	return;
}

void TestCompeleteBinaryTree()
{
	int i = 0;
	char a[] = { 'A', 'B', 'D', '#', '#', 'E', '#', 'H', '#', '#', 'C', 'F', '#', '#', 'G', '#', '#', '\0' };

	BTNode* root = BinaryTreeCreate(a, &i);
	int len = BinaryTreeSize(root);

	if (BinaryTreeComplete(root, len))
	{
		printf("It's a complete binary tree.\n");
	}
	else
	{
		printf("It's not a complete binary tree.\n");
	}

	return;
}

int main()
{
	Test();//测试二叉树的其他功能 
	TestCompeleteBinaryTree();//测试是否为完全二叉树 
	return 0;
}

结果为：b4d583d7ee944937976d958d4bb2660b.png 

如果这篇文章对各位有用的话，还望各位看官多多三连呐~~11d6bb23f14842a6b8df6e3c201f47f7.jpeg 

 

 

阿熊不会编程
关注
  • 25
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 24
    评论
专栏目录
图形化编程 scratch 递归 二叉树（带叶子）.sb3
09-19
通过自制积木实现递归画出一颗树，每次画的效果都不一样。
二叉树_二叉树遍历_
10-04
1.二叉树的基本操作实现【问题描述】建立一棵二叉树，用递归方法实现二叉树的如下基本操作：（1）按先序序列构造一棵二叉链表表示的二叉树T；（2）对这棵二叉树进行遍历：先序、中序、后序以及层次遍历，分别输出...
二叉树判定树结构是否相同，值是否相同
zhangnana200的博客
07-13 1485
树定义： public class TreeNode {   int val;    TreeNode left;    TreeNode right;    TreeNode(int x) { val = x; }  } 方法： public class Mytest03 { public static void main(String args[]){
数据结构二叉树的基础操作（ 1.创建二叉树2.先序遍历3.中序排序4.后序遍历 5.层序遍历6. 统计节点的数目 7.交换左右子树 8.计算并输出该二叉树的深度）
学习笔记，相关教程 分享
11-26 8514
一、实验目的 完整代码链接 ：完整代码链接 掌握二叉树的定义和性质。 理解二叉树的各种存储结构的表示方法。 掌握二叉树的先序、中序、后序及按层遍历方法和相应算法。 掌握二叉树的其他基本操作，体会算法的递归性。 二、预备知识 阅读课程教材P121~125页内容，理解二叉树的逻辑定义，掌握其重要性质。 阅读课程教材P126~131页内容，熟悉二叉树的存储结构，掌握二叉链表存储结构下二叉树各种遍历方式及其它操作的实现算法，体会递归算法的设计思路。 体会二叉树的按层遍历算法中队列的应用。 ··········
二叉树的四种遍历算法（结构体数组）
m0_65129892的博客
01-06 1628
二叉树的遍历，使用结构体数组
实验八 查找算法的实现
m0_51308557的博客
12-23 4120
（1）验证并设计顺序表的查找（顺序查找、折半查找）算法 （2）验证二叉排序树上的查找（创建、查找、插入）算法 （3）验证Hash表查找（Hash函数定义、建立，查找，插入）算法
“二叉树遍历“详解 以及 二叉树的实现
zhang_si_hang的博客
04-10 4246
目录 一.二叉树的遍历 1.二叉树的遍历的解释： 2.二叉树的遍历有三种递归结构 (1) 实现先序遍历： (2)实现中序遍历： (3)实现后序遍历： 一.二叉树的遍历 1.二叉树的遍历的解释： 二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历 是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。 2.二叉树的遍历有三种递归结构 1. 前序遍历(Preorder.
将满二叉树转化为求和二叉树_二叉树_
09-30
在IT领域，特别是数据结构和算法的学习中，二叉树是一种重要的抽象数据类型。满二叉树是一种特殊的二叉树，其中每一层都是完全填充的，除了可能的最后一层，且最后一层的所有节点都尽可能地向左靠拢。而将满二叉树...
二叉树_二叉树_
09-29
二叉树是一种特殊的树结构，每个节点最多只有两个子节点，通常称为左子节点和右子节点。在计算机科学中，二叉树是数据结构的基础，广泛应用于算法设计和问题解决。以下是对二叉树相关知识点的详细阐述： 1. **...
二叉树_二叉树遍历_二叉树_
10-04
二叉树是计算机科学中数据结构的一个重要概念，它是一种特殊的树形结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。在实际应用中，二叉树常用于实现查找、排序和表达式求解等多种算法。本节我们将深入...
数据结构初阶之二叉树（5）
zhangsankuangtu的博客
01-25 89
之前学习过二叉树的遍历，其实遍历的思路还可以用作二叉树的创建，假设我们有以下的二叉树前序遍历的结果"abd##eh##i##cf##g##"，把这个字符串还原为一个二叉树。二叉树的销毁需要依次销毁节点，所以根节点应当是最后销毁的，所以最符合的是后续遍历的顺序（左节点--->右节点--->根节点）。完全二叉树只有最后一层才会出现空，且空后不会出现数据，所以判断完全二叉树，最好的方法是使用层序遍历，判断空后是否出现元素。层序遍历是按照二叉树每一层进行遍历，进行层序遍历需要使用队列，利用队列先进先出的特性。
二叉树的各种创建方法
热门推荐
lingling_nice的博客
07-08 7万+
1.前序创建#include&lt;stdio.h&gt; #include&lt;string.h&gt; #include&lt;stdlib.h&gt; #include&lt;malloc.h&gt; #include&lt;iostream&gt; #include&lt;stack&gt; #include&lt;queue&gt; using namespace std; typed
【二叉树】二叉树基本操作
weixin_45800034的博客
10-22 934
Q1 实现二叉树的基本操作：建立、遍历、计算深度、结点数、叶子数等。 输入C，先序创建二叉树，#表示空节点； 输入H：计算二叉树的高度； 输入L：计算二叉树的叶子个数； 输入N：计算二叉树节点总个数； 输入1：先序遍历二叉树； 输入2：中序遍历二叉树； 输入3：后续遍历二叉树； 输入F：查找值=x的节点的个数； 输入P：以缩格文本形式输出所有节点。 输入 C ABC##DE#G##F### H L N 1 2 3 F A P 输出 Created success! Height=5.
井号法（#）创建二叉树（利用前序遍历来建树）C++实现
CSDN 精品推荐
11-26 2114
利用#号法来创建二叉树 输入： ABD##E##C#F## 对应该输入的二叉树应为这样 解题思路： 用vector数组存储输入的节点数据 用前序遍历的顺序去建树 如果是#，则表明该节点为空 否则先创建左子树，然后右子树 递归调用 代码： /** *作者：魏宝航 *2020年11月26日,下午23:55 */ #include<iostream> #include<vector> using namespace std; class Node { public:
满二叉树、完全二叉树、最优二叉树（赫夫曼树）、二叉排序树、二叉判定树
hehainan_86的专栏
09-10 1万+
1、满二叉树 定义：除最后一层的结点外，每一层的所有结点都有两个子结点。 另外一个定义：深度为k且有2^k-1个结点的二叉树。   满二叉树是一颗树深度为h，最大层数为k，且深度与最大层数相同，即k=h; 它的叶子数是： 2^(h-1) 第k层的结点数是： 2^(k-1) 总结点数是： 2^k-1 (2的k次方减一) 总节点数一定是奇数。   2、完全二叉树   如上图
详细设计（判定树）
zq9725的博客
06-16 3827
判定树能清晰的表示复杂的条件组合与应做的动作之间的关系，它不需要任何的说明，一眼就可以看出其中的含义，因此易于掌控和使用。 常用到软件设计中的详细设计中。 ...
生成一个二叉树
赵阿
03-10 2061
想看更多 二叉树的简介 二叉树本身的意义不重要，只学二叉树的话会觉得没什么用，因为他不像栈那样为复杂循环提供了行之有效的解决办法。学习二叉树的目的其实是为了后面的排序树、平衡树、堆等知识做准备。 生成一颗二叉树 生成二叉树的方式大概有两种 第一种是用某种序列+#号（用来代表空指针） 第二种是用中序序列 + 任意一个其他序序列 （前序、后序、层次 ，这种方法不需要用符号去代表空指针）生...
LeetCode(力扣)题目中二叉树的如何生成？根据给定顺序列表生成二叉树（python）
baoxin1100的博客
08-16 3719
在刷 leetcode 二叉树相关的题目时，经常有这样给定的例子,例如: 检查平衡性 实现一个函数，检查二叉树是否平衡。在这个问题中，平衡树的定义如下：任意一个节点，其两棵子树的高度差不超过 1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。 示例 2: 给定二叉树 [1,2,2,3,3,null,null,4,4] 1 / \ 2 2 / \
生成二叉树----c
wangshuai33的博客
03-23 993
用c语言中最简单的方法生成一个二叉树，有注释，解释都在代码中 #include<stdio.h> #include<stdlib.h>//因为会用到NULL typedef struct node{ int val; struct node* left; struct node* right; }Node;//定义一个树的结构体 void p...
创建带空结点的二叉树的创建函数
最新发布
05-14
因此，创建带空结点的二叉树需要在创建结点时判断左右子结点是否为空，如果为空，则将对应子结点指针指向空结点。 下面是一个示例代码，创建一个带空结点的二叉树： ```c++ #include using namespace std; // ...
评论 24
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿熊不会编程

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值