树（二叉树）

最新推荐文章于 2024-06-19 16:41:31 发布
最新推荐文章于 2024-06-19 16:41:31 发布
阅读量329 收藏
点赞数
文章标签： 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44024891/article/details/106851670
版权

树应该是数据结构中最难的吧， 复习到这块做二叉树的练习题， 不是很好做， 大部分都是递归题， 树的考点也很多。

首先要区分树和森林， 其次树又分为二叉树和非二叉树。
我们主要以二叉树为主复习， 因为往年考点较高是二叉树。

一、树的存储分为两种，一种是线性存储， 一种是非线性存储。
1、线性存储我们在heap这章提及过， 它的实现很简单， 需要注意的是父结点、孩子结点、最后一个非叶子结点之间运算关系。 这块不作为重点讨论。
2、非线性存储， 也就是链式存储， 每个结点中间至少包含（值、左孩子指针、右孩子指针等）这些信息， 在逻辑上，左孩子指针指向左孩子结点地址， 有孩子指针指向右孩子结点。 这样一次类推， 形成一种逻辑上有树规律，但物理上没有树规律的结构。
在这里插入图片描述
二、如何构建一个树呢
如何构建一颗树，这是一个刚开始接触二叉树就必须要考虑的问题。
我这块不卖关子。 我第一次构建是看别人写的模板写的。
一般来说，构建一棵树， 我们会把构建的内容存放在一个数组中。 然后通过递归来构建。 听起来可能难， 其实看代码品一会就懂得了。我直接放代码。

这是给我们数组：
char a[] = { ‘1’, ‘5’, ‘#’, ‘#’, ‘3’, ‘#’, ‘#’ };
调用方式：
int pi = 0;
BTNodeInit(a, &pi);
在这里插入图片描述
最后BTNodeInit接口的返回值就是构建树的头结点head。

三、树的遍历方式
分别是: 先序遍历、中序遍历、后序遍历、层序遍历。
在这里插入图片描述
先序遍历， 口诀就是根左右； 中序遍历左根右； 后序遍历左右根。
层序遍历就是每一层一层的遍历。
一般来说对于先序、中序、后续序遍历的设计有两种方式。
1、递归实现。
2、非递归实现（需要借助栈）

层序遍历采用队列去实现。
（这些我在面试题总结会写实现过程）

面试当中一般常考给我们先序遍历，中序遍历，后序遍历当中的两个序列，
让我们判断给哪两个序列可以画出二叉树的问题？
如果想要通过两个序列去画二叉树， 这两个序列中一定要包含中序遍历， 如果只有先序、后序遍历画不出二叉树的。

四、二叉树的分类
1、满二叉树
在这里插入图片描述
其实我们发现树是分一层一层的， 而每一层最多的结点个数为2^(n-1)， n为层数。
在这里如果每一层的结点个数都是最大个数2^(n-1)， 则这个二叉树就是满二叉树。

2、完全二叉树
在这里插入图片描述
在满二叉树的基础上做一些区分， 就是在最后一层， 最后一层可以不用满足2^(n-1)个数， 但是有个条件，最后一层结点从左右往数都是连续存放的，不可能说两个之间有一个空结点。

下面这个就不满足条件（最后一层1和7之间有空结点）， 不是完全二叉树。
在这里插入图片描述

二叉树还有一个有意思的，那就是排序二叉树。
所谓排序二叉树是按一定规律存放的树。
如果每个结点的值大于左孩子结点值， 但是小于右孩子结点值。
或者每个结点的值小于左孩子结点值， 大于右孩子结点值。
这种结构的树就是排序二叉树。
在这里插入图片描述
这种排序二叉树在中序遍历会得到有序的序列。
上图左边中序遍历后：1, 2, 4, 5, 6, 9从小到大的序列。
同理右边的是从大到小的序列。
并且排序二叉树的查找效率很高logn。 决定效率取决于高度n
这也是后面平衡二叉树、 红黑树诞生的起源。

下面是模拟写出来的树
BTNodeTree.h

#pragma once

/*
	project: 模拟实现二叉树
	date:	 2020-6-19
	name:	 HMW
*/

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

typedef char BTNDataType;

typedef struct BTNode
{
	BTNDataType val;				//数据域
	struct BTNode* _lchild;			//左孩子节点
	struct BTNode* _rchild;			//右孩子节点
}BTNode;

//初始化创建树
BTNode* BTNodeInit(BTNDataType* a, int* pi);
//树的销毁
void BTNodeDestroy(BTNode** root);
//先序遍历
void BinaryTreePrevOrder(BTNode* root);
//中序遍历
void BinaryTreeInOrder(BTNode* root);
//后序遍历
void BinaryTreePostOrder(BTNode* root);
//镜像转化
void MirrorRecursively(BTNode* root);
//判断是否为对称二叉树
int isSameTree(BTNode* root);
// 判断二叉树是否是完全二叉树 
int BinaryTreeComplete(BTNode* root);
//树的节点个数
int BinaryTreeSize(BTNode* root); 
//树的叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
//第k层节点的个数
int BinaryTreeLevelKSize(BTNode* root, int k);
//第k层节点的叶子个数
int BinaryTreeLevelKLeafSize(BTNode* root, int k);
//返回查找的节点的值
BTNode* BinaryTreeFind(BTNode* root, BTNDataType x);
//层序遍历
void BinaryTreeLevelOrder(BTNode* root);
//非递归实现的先序遍历
void BinaryTreePrevOrderNonR(BTNode* root);
//非递归实现的中序遍历
void BinaryTreeInOrderNonR(BTNode* root);
//非递归实现的后序遍历
void BinaryTreePostOrderNonR(BTNode* root);

BTNodeTree.c

//#include"BTNodeTree.h"
#include"Stack.h"
#include"Queue.h"

//初始化创建树  
BTNode* BTNodeInit(char* a, int* pi)
{	
	//a是传入构建数组首元素的地址， pi是一个全局的下标，用它来取构建的元素。
	if (!a)
		return NULL;	

	//'#' -- 代表着这个值为空

	if (a[*pi] != '#')										//这个元素不为空
	{
		BTNode* root = (BTNode*)malloc(sizeof(BTNode));		//创建一个结点
		root->val = a[*pi];									//把数组中的值赋给结点
		++(*pi);											//下标偏移

		root->_lchild = BTNodeInit(a, pi);					//结点左孩子指针 = 递归的返回值
		++(*pi);											//下标偏移
		root->_rchild = BTNodeInit(a, pi);

		return root;										//返回构建的结点
	}
	else
	{
		return NULL;										//这个元素为空，返回null指针
	}									
}

//树的销毁
void BTNodeDestroy(BTNode** root)
{
	//树的销毁采用后序遍历的方式释放， 采用二级指针来释放。
	if (*root)
	{
		BTNodeDestroy(&(*root)->_lchild);
		BTNodeDestroy(&(*root)->_rchild);
		free(*root);
		*root = NULL;
	}
	else
		return;
}

//先序遍历
void BinaryTreePrevOrder(BTNode* root)
{
	if (root)
	{
		printf("%c ", root->val);
		BinaryTreePrevOrder(root->_lchild);
		BinaryTreePrevOrder(root->_rchild);
	}
	else
		return;
}
//中序遍历
void BinaryTreeInOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreeInOrder(root->_lchild);
		printf("%c ", root->val);
		BinaryTreeInOrder(root->_rchild);
	}
}

 //后序遍历
void BinaryTreePostOrder(BTNode* root)
{
	if (root)
	{
		BinaryTreePostOrder(root->_lchild);
		BinaryTreePostOrder(root->_rchild);
		printf("%c ", root->val);
	}
}

//非递归实现的先序遍历
void BinaryTreePrevOrderNonR(BTNode* root)
{
	if (!root)
		return;
	//需要栈实现.
	Stack st;
	StackInit(&st);
	BTNode* cur = root;

	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			printf("%c ", cur->val);
			StackPush(&st, cur);
			cur = cur->_lchild;
		}
		//出来就是cur == NULL，  左到底

		BTNode* Top = StackTop(&st);
		StackPop(&st);

		if (Top->_rchild)
			cur = Top->_rchild;
	}

	StackDestroy(&st);
}

//非递归实现的中序遍历
void BinaryTreeInOrderNonR(BTNode* root)
{
	if (!root)
		return;

	Stack st;
	StackInit(&st);
	BTNode* cur = root;

	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			StackPush(&st, cur);
			cur = cur->_lchild;
		}

		BTNode* Top = StackTop(&st);
		printf("%c ", Top->val);
		StackPop(&st);

		if (Top->_rchild)
			cur = Top->_rchild;
	}

}

//非递归实现的后序遍历
void BinaryTreePostOrderNonR(BTNode* root)
{
	if (!root)
		return;

	Stack st;
	StackInit(&st);
	BTNode* cur = root;
	BTNode* prev = NULL;

	while (cur || !StackEmpty(&st))
	{
		while (cur)
		{
			StackPush(&st, cur);
			cur = cur->_lchild;
		}

		BTNode* Top = StackTop(&st);
		if (!Top->_rchild || Top->_rchild == prev)
		{
			printf("%c ", Top->val);
			StackPop(&st);
			prev = Top;
		}
		else
			cur = Top->_rchild;
	}
}

//层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
	if (!root)
		return;

	Queue q;
	QueueInit(&q);
	
	QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		printf("%c ", front->val);

		if (front->_lchild)
			QueuePush(&q, front->_lchild);
		if (front->_rchild)
			QueuePush(&q, front->_rchild);
	}
	QueueDestroy(&q);
}

// 判断二叉树是否是完全二叉树 
int BinaryTreeComplete(BTNode* root)
{
	//0代表不是完全二叉树的情况， 1代表是完全二叉树的情况
	if (!root)
		return 0;

	Queue q;
	QueueInit(&q);

	QueuePush(&q, root);

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
			break;
		else
		{
			QueuePush(&q, front->_lchild);
			QueuePush(&q, front->_rchild);
		}
	}

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

	return 1;
}

//树的节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root)
	{
		return BinaryTreeSize(root->_lchild) + BinaryTreeSize(root->_rchild)
			+ 1;
	}
	else
		return 0;
}

//树的叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
	if (!root)
		return 0;
	if (root->_lchild == NULL && root->_rchild == NULL)
		return 1;
	return BinaryTreeLeafSize(root->_lchild) + BinaryTreeLeafSize(root->_rchild);
}

//第k层节点的个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL || k <= 0)
		return 0;

	if (root && k == 1)
	{
		return 1;
	}
	return BinaryTreeLevelKSize(root->_lchild, k - 1) + BinaryTreeLevelKSize(root->_rchild, k - 1);
}

//第k层节点的叶子个数
int BinaryTreeLevelKLeafSize(BTNode* root, int k)
{
	if (!root || k <= 0)
		return 0;

	if (root && k == 1)
	{
		if (root->_lchild == NULL && root->_rchild == NULL)
			return 1;
		return 0;
	}

	return BinaryTreeLevelKLeafSize(root->_lchild, k - 1) +
		BinaryTreeLevelKLeafSize(root->_rchild, k - 1);
}

//返回查找的节点的值
BTNode* BinaryTreeFind(BTNode* root, BTNDataType x)
{
	if (!root)
		return NULL;
	if (root->val == x)
		return root;
	else
	{
		return BinaryTreeFind(root->_lchild, x);
		return BinaryTreeFind(root->_rchild, x);
	}
}

//镜像转化
void MirrorRecursively(BTNode* root)
{
	if (!root)
		return;
	if (root->_lchild == NULL && root->_rchild == NULL)	//可有效提高效率
		return;

	BTNode* tmp = root->_lchild;
	root->_lchild = root->_rchild;
	root->_rchild = tmp;

	if(root->_lchild)
		MirrorRecursively(root->_lchild);
	if(root->_rchild)
		MirrorRecursively(root->_rchild);
}


// -- two
int Judge_Same(BTNode* root1, BTNode* root2)
{
	if (root1 == NULL && root2 == NULL)
		return 1;
	else if (root1 != NULL && root2 == NULL)
		return 0;
	else if (root1 == NULL && root2 != NULL)
		return 0;

	if (root1->val == root2->val)
	{
		return Judge_Same(root1->_lchild, root2->_rchild)
			&& Judge_Same(root1->_rchild, root2->_lchild);
	}
	else
		return 0;
}

//判断一个数是否是另一棵树的子树。 - one
int isSameTree(BTNode* root)
{
	if (!root)
		return 0;	//0代表失败
	if (root->_lchild != NULL && root->_rchild != NULL)
	{
		return Judge_Same(root->_lchild, root->_rchild);
	}
	else if (root->_lchild == NULL && root->_rchild == NULL)
		return 1;
	else
		return 0;
}

test.c

#include"BTNodeTree.h"
#include"Stack.h"
#include"Queue.h"

void test_BTNodeTree()
{
	char str[] = { '8', '6', '5', '#', '4', '#', '#', '7', '#', '#', '6', '7',
				'#', '#', '9', '#', '#' };

	//char str[] = { '1', '5', '#', '#', '3', '#', '#' };
	//char str[] = { '1', '#', '#' };
	
	int pi = 0;

	BTNode* root = BTNodeInit(str, &pi);

	puts("先序遍历");
	BinaryTreePrevOrder(root);
	puts("\n中序遍历");
	BinaryTreeInOrder(root);
	puts("\n后序遍历");
	BinaryTreePostOrder(root);
	puts("\n层序遍历");
	BinaryTreeLevelOrder(root);

	puts("\n非递归实现的先序遍历");
	BinaryTreePrevOrderNonR(root);
	puts("\n非递归实现的中序遍历");
	BinaryTreeInOrderNonR(root);
	puts("\n非递归实现的后序遍历");
	BinaryTreePostOrderNonR(root);


	if (BinaryTreeComplete(root))
	{
		puts("\n完全二叉树");
	}
	else
		puts("\n非完全二叉树！");

	printf("二叉树节点的个数为%d\n", BinaryTreeSize(root));
	printf("二叉树叶子节点的个数为:%d\n", BinaryTreeLeafSize(root));

	printf("第k层的节点个数为:%d\n", BinaryTreeLevelKSize(root, 3));
	printf("第k层的节点叶子个数为:%d\n", BinaryTreeLevelKLeafSize(root, 3));
	
	BTNode* p = BinaryTreeFind(root, '3');
	if (p)
		printf("返回的值为:%c\n", p->val);
	else
		puts("没有这个值的节点");
	
	
	puts("");
	BTNodeDestroy(&root);
	if (root == NULL)
		puts("清空");
	else
		puts("内存泄漏！");
}

int main()
{
	test_BTNodeTree();

	//test_Swordoffer();
	system("pause");
	return 0;
}

测试结果：
在这里插入图片描述

那个， 这是以前还没有学习c++写的， 所以关于栈、队列没有使用STL标准库， 自己的接口， 这两个接口我就不在这里发了， 我在github上传， 有兴趣的朋友自己弄着玩。
https://github.com/haomengwudaydayup/learn_c_language/tree/master/PORT

GlorygloryGlory
关注
简洁明了的二叉树分类
dxvnlshdlkvhsl的博客
05-25 774
一：常见二叉树 有满二叉树、完全二叉树、二叉搜索树、平衡二叉树、红黑树 1.满二叉树 在不增加树的层数的前提下，无法在多添加一个节点的二叉树就是满二叉树。 2.完全二叉树 如果只是删除了满二叉树最底层最右边的连续若干个节点，这样形成的二叉树就是完全二叉树。 3.二叉搜索(排序、查找)树(binary search tree) 定义：若它的左子树不空，则左子树上的所有结点的值均小于(注意：不是小于等于)根节点的值；若它的右子...
第6章 树二叉树.ppt
03-20
一、树的基本概念 二、二叉树 三、二叉树的遍历 三、线索二叉树 四、树和森林 六、哈夫曼树 定义：是一种常非线性结构树是n（n≥0）个结点的有限集合。若n=0，则称为空树；否则，有且仅有一个特定的结点被称为...
数据结构难点总结
victorika的博客
05-14 3275
红黑树： 红黑树的5个特性:   性质1. 节点是红色或黑色。 性质2. 根是黑色。 性质3. 所有叶子都是黑色（叶子是NULL节点）。 性质4. 每个红色节点的两个子节点都是黑色。(从每个叶子到根的所有路径上不能有两个连续的红色节点) 性质5. 从任一节点到其每个叶子的所有简单路径 都包含相同数目的黑色节点。 插入的情况： 若是根节点直接插入． 若父亲是黑色那么直接插入． ...
一文搞懂什么是二叉树（二叉树的种类、遍历方式、定义）
最新发布
2401_85117728的博客
06-19 1007
因为我们在刷leetcode的时候，节点的定义默认都定义好了，真到面试的时候，需要自己写节点定义的时候，有时候会一脸懵逼！四.总结=====二叉树是一种基础数据结构，在算法面试中都是常客，也是众多数据结构的基石。本篇我们介绍了二叉树的种类、存储方式、遍历方式以及定义，比较全面的介绍了二叉树各个方面的重点，帮助大家扫一遍基础。
二叉树的分类
weixin_34232363的博客
03-06 208
满二叉树 　　通过名字就可以看出来是一个满的二叉树，意思也就是二叉树上每一层的结点数都达到了最大。看上去就像上个三角形。 　　满二叉树必须满足： 　　　　1.总的结点个数2k-1个结点; 如上图是一个3层的二叉树，总的结点个数为23-1=7个点节 　　　...
【二叉树的分类】
尘归尘 码归码
03-09 869
什么是二叉树？ 二叉树(Binary tree)是N个有限元素的集合，是一种树中节点的度不大于2的有序树（只能是0 1 2） 1根下有2 3 ，2根下有4 5 只能小于等于2个子节点 1 2 3 4 5 6 7 什么是满二叉树？ 如果二叉树中最后一层无任务子节点，且其他每一层上的所有节点都有两个子节点，即每个节点的度都为2，则此二叉树可以称为满二叉树。 1 2 3 4 5 6 7 什么是完全二叉树？ 如果二叉树中除了最后一层外，其他各层的节点都达到最大个数2个，且最后一层的所有节点依次从
数据结构C语言树二叉树详细举例介绍PPT学习教案.pptx
10-05
"数据结构C语言树二叉树详细举例介绍" 本文档为数据结构C语言树二叉树的详细介绍，包括树的类型定义、二叉树的类型定义、二叉树的存储结构、二叉树的遍历、线索二叉树、树和森林的表示方法、树和森林的遍历、哈夫曼...
树 二叉树的遍历PPT学习教案.pptx
10-03
树 二叉树的遍历PPT学习教案.pptx
数据结构之树二叉树必看
10-10
在深入探讨之前，我们先理解一下二叉树的基本定义：二叉树是一种特殊的树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。这种结构使得二叉树在处理分叉决策或层次关系时非常有效。 二叉树...
数据结构 树 二叉树
11-29
### 数据结构：树与二叉树 #### 一、知识点概览 1. **二叉树的基本概念**：包括二叉树的定义、特点及分类（如完全二叉树、满二叉树等）。 2. **二叉树的性质**：涉及到节点数量与结构之间的关系，比如叶子节点的...
二叉树分类
qq_41907471的博客
11-16 1053
#二叉树分类 满二叉树： 对于国内的满二叉树： 从图形形态上看，满二叉树外观上是一个三角形。 从数学上看，满二叉树的各个层的结点数形成一个首项为1，公比为2的等比数列。 对于国外的满二叉树 满二叉树的结点要么是叶子结点，度为0，要么是度为2的结点，不存在度为1的结点。 完全二叉树：设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第 h 层所有的结点都连续集...
透彻认识红黑树
weixin_34357887的博客
07-02 90
红黑树是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。它是在1972年由Rudolf Bayer发明的，他称之为"对称二叉B树"，它现代的名字是在 Leo J. Guibas 和 Robert Sedgewick 于1978年写的一篇论文中获得的。它是复杂的，但它的操作有着良好的最坏情况运行时间，并且在实践中是高效的： 它可以在O...
二叉树的分类以及树的分类
eastlin
11-18 1257
二叉树的分类 1.一般树 2.只有左（右)孩子的树:（可改造的单链表） 3.哈夫曼树-应用:哈夫曼编码-权值和最小 4.平衡二叉树 4.1完全二叉树 4.1.1堆 小根堆：根<左，右 大根堆：根>左，右 4.1.2满二叉树 5.二叉排序树（搜索，查找树） 有第一个结点决定树如何形状，左<根<右 6.线索二叉树（充分利用空指针的结果） 为了方便找前驱，解决二叉树不能回溯的问题 二...
数据结构——常见二叉树的分类（完全二叉树、满二叉树、平衡二叉树、二叉搜索树、红黑树）
weixin_45338443的博客
06-25 3464
二叉树的定义、特点和常见分类
二叉树的分类以及性质
qq_38158479的博客
11-14 372
一：分类 (1)斜树，包括左斜树和右斜树 (2)满二叉树 满二叉树的特点： (3)完全二叉树(编号有序) 特点： 说明：满二叉树一定是一棵完全二叉树，但完全二叉树不一定是满的。 二：二叉树的性质 (重点是每一层的节点个数上) (重点在于树的全部节点个数上) 则，n0=n2+1. ...
二叉树的各种分类
peachzy的博客
05-08 7349
一、满二叉树 除了最后一层的节点没有任何子节点外，每层上的所有节点都有两个节点的二叉树 二、完全二叉树 一颗二叉树的深度为h，除了第h层外，其他各层的节点都有两个子节点，且第h层的所有节点都集中在最左边 （满二叉树一定是完全二叉树，但是完全二叉树不一定是满二叉树） 三、平衡二叉树 左右两个子树的高度差绝对值不超过1，且左右两个子树都是平衡二叉树 四、二叉搜索树 左子树的所有节点的值均小于它的根节点的值 右子树的所有节点的值均大于它的根节点的值 它的左右子树也分别为二叉搜索树 五、红黑树 一种平衡的二叉搜索树
二叉树的分类和比较
小汤圆
02-13 281
二叉树的分类和比较
决策树二叉树和多叉树
05-20
决策树、二叉树和多叉树都是树形结构。 决策树是一种分类算法，它通过树形结构对样本进行分类，每个内部节点表示一个属性，每个分支表示该属性的一个取值，每个叶子节点表示一个类别。根据样本的属性特征不同，递归...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值