数据结构——树

目录

1. 树的概念与结构

①树的相关概念

Ⅰ. 什么是树

Ⅱ. 树中的相关概念

②树的表示法

③树的应用

2. 二叉树的概念与结构

①二叉树的概念

②特殊二叉树

③二叉树性质及证明

④二叉树性质相关习题 

3. 堆

①堆的概念及结构

②堆的实现

⑴堆的向上调整法

⑵堆的向下调整法

⑶堆的插入与删除

⑷堆的创建

⑸堆的接口与实现 

③堆的应用

⑴堆排序

⑵Top-K问题

4. 二叉树的链式结构

①二叉树的遍历

⑴前序遍历

⑵中序遍历

⑶后序遍历

⑷层序遍历

②求节点个数以及高度等

⑴二叉树节点个数

⑵二叉树的高度

⑶二叉树第k层节点个数

⑷二叉树查找值为x的节点


1. 树的概念与结构

①树的相关概念

Ⅰ. 什么是树

树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合。之所以称之为树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的。
1. 有一个 特殊的结点,称为根结点 ,根节点没有前驱结点
2. 除根节点外,其余结点被分成 M(M>0) 个互不相交的集合 T1 T2 …… Tm ,其中每一个集合 Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱,可以有 0 个或多个后继
3. 因此, 树是递归定义 的。

随便举例一棵树,如

数据结构——树_第1张图片

 注:树形结构中,子树之间不能有交集,否则就不是树形结构

Ⅱ. 树中的相关概念

我们以下面这个树为例

数据结构——树_第2张图片

节点的度 :一个节点含有的子树的个数称为该节点的度;
如上图: A 的为 6
叶节点或终端节点(*) :度为 0 的节点称为叶节点;
如上图: B C H I... 等节点为叶节点
非终端节点或分支节点 :度不为 0 的节点;
如上图: D E F G... 等节点为分支节点
双亲节点或父节点(*):若一个节点含有子节点,则这个节点称为其子节点的父节点;
如上图: A B 的父节点
孩子节点或子节点(*):一个节点含有的子树的根节点称为该节点的子节点;
如上图: B A 的孩子节点
兄弟节点 :具有相同父节点的节点互称为兄弟节点;
如上图: B C 是兄弟节点
树的度 :一棵树中,最大的节点的度称为树的度;
如上图:树的度为 6
节点的层次 :从根开始定义起,根为第 1 层,根的子节点为第 2 层,以此类推;
如上图:树共有4层
树的高度或深度(*):树中节点的最大层次;
如上图:树的高度为 4
堂兄弟节点 :双亲在同一层的节点互为堂兄弟;
如上图: H I 互为兄弟节点
节点的祖先(*):从根到该节点所经分支上的所有节点;
如上图: A 是所有节点的祖先
子孙(*):以某节点为根的子树中任一节点都称为该节点的子孙。
如上图:所有节点都是 A 的子孙
森林 :由 m m>0 )棵互不相交的树的集合称为森林;  

②树的表示法

树结构相对线性表比较复杂了,要存储表示起来比较麻烦, 既然保存值域,也要保存结点和结点之间 的关系 ,实际中树有很多种表示方式如:双亲表示法,孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。我们这里就简单的了解其中最常用的孩子兄弟表示法

表示方法如下

typedef int DataType;
struct Node
{
	struct Node* _firstChild1;  // 第一个孩子结点
	struct Node* _pNextBrother; // 指向其下一个兄弟结点
	DataType _data;             // 结点中的数据域
};

 我们以如下一棵树为例

数据结构——树_第3张图片

左孩子右兄弟表示为

数据结构——树_第4张图片

③树的应用

表示文件系统的目录树结构

数据结构——树_第5张图片

windos中的文件也是以树的形式储存的

数据结构——树_第6张图片

2. 二叉树的概念与结构

①二叉树的概念

二叉树是一种树形结构,每个节点最多只能有两个子节点,并且左右子节点的顺序是确定的。一个二叉树可以为空,或者由一个根节点和左右两个子二叉树组成。其中左子树和右子树也分别是二叉树。

数据结构——树_第7张图片

从上图中我们不难看出: 

1. 二叉树不存在度大于 2 的结点
2. 二叉树的子树有左右之分,次序不能颠倒,因此二叉树是有序树

因此,对于任意的二叉树都是由以下几种情况复合而成的

数据结构——树_第8张图片

②特殊二叉树

1. 满二叉树 :一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K ,且结点总数是,则它就是满二叉树。
2. 完全二叉树 :完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为 K的,有n 个结点的二叉树,当且仅当其每一个结点都与深度为 K 的满二叉树中编号从 1 n 的结点一一对应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

数据结构——树_第9张图片

③二叉树性质及证明

1. 若规定根节点的层数为 1 ,则一棵非空二叉树的 第h 层上最多有 2^(h - 1) 个结点.
数据结构——树_第10张图片
2. 若规定根节点的层数为 1 ,则 深度为 h 的二叉树的最大结点数是 2^h - 1.
数据结构——树_第11张图片
3. 对任何一棵二叉树 , 如果度为 0 其叶结点个数为N0 , 度为 2 的分支结点个数为N2 , 则有 N0 = N2+ 1

假设对于任意一棵具有 k + 1 个节点的二叉树,都满足N0​=N2​+1。

对于一颗具有 k+1 个节点的二叉树,我们可以将其分为根节点和左右两棵子树。设左子树有 n1​ 个节点,右子树有 n2​ 个节点。

那么该二叉树的 N0​ 就是左子树的 N0​ 与右子树的 N0​ 之和,即 N0​=N01​+N02​。

同理 N2​ 也可以拆分为左右两个子树,即 N2​=N21​+N22​。

根据二叉树的性质,除了根节点,每个节点的度数最多为 2。我们将 N0​ 表示为叶节点数目,那么左子树和右子树的 n0​ 和 n2​ 就可以表示为:

左子树:n01​=N01​+1,n21​=N01​

右子树:n02​=N02​+1,n22​=N02​

总结起来,我们得到以下三式:

N0​=n01​+n02​=N01​+N02​+2

N2​=n21​+n22​=N01​+N02​

代入 N0​=N2​+1,得到

N01​+N02​+2=N01​+N02​+1

因此,对于任意一颗具有 k+1 个节点的二叉树都成立。

4. 若规定根节点的层数为 1 ,具有 n 个结点的满二叉树的深度 h= log(n + 1). (ps:是log 2为底,n+1 为对数 )
数据结构——树_第12张图片
5. 对于具有 n 个结点的完全二叉树,如果按照从上至下从左至右的数组顺序对所有节点从 0 开始编号,则对于序号为i 的结点有:
1. i>0 i 位置节点的双亲序号: (i-1)/2 i=0 i 为根节点编号,无双亲节点
2. 2i+1 ,左孩子序号: 2i+1 2i+1>=n 否则无左孩子
3. 2i+2 ,右孩子序号: 2i+2 2i+2>=n 否则无右孩子

图示如下 

数据结构——树_第13张图片

证明

1. 若 i>0,则 i 位置结点的双亲序号为 (i−1)/2。

首先我们可以根据完全二叉树的定义,得出父节点编号一定小于当前节点编号,且父节点在当前节点的上一级。又因为当前节点是从上至下从左至右编号的完全二叉树中的第 i 个节点。那么它的父节点肯定是处于序号为 (i−1)/2 的位置,这就证明了该结论。

2. 若 2i+1

由完全二叉树的定义,一个节点的左子节点编号为 2i+1,右子节点编号为 2i+2。

证明:

当 2i+1

3. 若 2i+2

与第二个结论的证明类似,当 2i+2

综上所述,我们证明了对于具有 n 个结点的完全二叉树,编号为 i 的节点满足的三个性质,即若 i>0,则它的双亲节点序号为 (i−1)/2;若 2i+1

④二叉树性质相关习题 

1. 某二叉树共有 399 个结点,其中有 199 个度为 2 的结点,则该二叉树中的叶子结点数为( )
A 不存在这样的二叉树
B 200
C 198
D 199

解:

∵N0 = N2 + 1

∴N0 = 200,因此答案选B 

2. 在具有 2n 个结点的完全二叉树中,叶子结点个数为( )
A n
B n+1
C n-1
D n/2

解:叶子结点即度为0的结点,将其转化为计算N0大小即可

∵2*n = N0 + N1 + N2, N0 = N2 + 1,又∵在完全二叉树中度为1的节点取值仅有0/1,

∴当N1 = 0时,2*n = 2*N0+1有N0=(2*n-1)/2,无匹配选项;当N1=1时,2*n=2*N0+2有N0=n-1,因此答案选C

3. 一棵完全二叉树的节点数位为 531 个,那么这棵树的高度为( )
A 11
B 10
C 8
D 12

解:

∵2^10 = 1024,又∵一棵满二叉树的结点数为2^h - 1,

∴一棵高度为10的满二叉树的节点数为1023,而一棵高度为9的满二叉树的节点数为511

∵531∈[512,1023]

∴这是一棵高度为10的树

4. 一个具有 767 个节点的完全二叉树,其叶子节点个数为()
A 383
B 384
C 385
D 386

解:

∵767 = N0 + N1 + N2,N0 = N2 + 1

∴766 = 2*N0 + N1,又∵N0不能是小数,∴N1=0

∴N0=383,因此选A

3. 堆

①堆的概念及结构

堆是一种特殊的树状数据结构,具有以下两个特点:

  • 堆是一棵完全二叉树。
  • 堆中任何一个节点的值都必须大于等于(或小于等于)其子树中每个节点的值。

这个定义中提到的"大于等于"或"小于等于",就是指堆的排序方式。如果父节点的值大于等于子节点的值,就称为"大根堆",反之则是"小根堆"。

如下图所示

数据结构——树_第14张图片

②堆的实现

根据上面的结我们可以定义堆的自定义类型如下

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}Heap;

⑴堆的向上调整法

在知道了堆的结构后,当我们需要向堆中插入元素时,应该选择的是尾插,但是尾插之后不能保证此时依旧满足堆的性质,(以大根堆为例)如

数据结构——树_第15张图片

此时受到影响的可能是最后一个节点的所有祖先,即

数据结构——树_第16张图片

代码如下

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

//大根堆
void AdjustUp(HPDataType* a, int child)
{
	//当前节点为child
	//通过child找到parent
	int parent = (child - 1) / 2;

	//用parent作判断条件不够严谨,因为如果child为0时,
	//parent=(0-1)/2=-0.5(C语言向下取整,因此parent=0,while的判断条件没有改变)
	//while (parent >= 0)
	//当child=0时,已经没有必要再向上调整,循环结束
	while(child > 0)
	{
		//因为是大根堆,因此当孩子大于父亲时,需要交换父子位置
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

⑵堆的向下调整法

那当我们从堆中取出或删除元素时,应该做到的是取出(删除)堆顶元素(即首元素),但是如果我们直接将该位置元素直接删除,那么就会导致1. 原来的父子关系被打乱;2. 依次挪动数据导致效率低下。如图所示

数据结构——树_第17张图片

因此,我们在此最好的选择是将堆顶元素和最后一个元素交换,这样既解决了效率又保持了相对的父子关系,唯一需要进行调整的就是大根堆性质的所决定的父子关系

代码如下

void AdjustDown(HPDataType* a, int parent, int n)
{
	// 通过父节点找到左右子节点
	int lchild = 2 * parent + 1;
	int rchild = 2 * parent + 2;

	// 如果左孩子所处位置已经不在堆中就结束循环
	// 表示当前父节点为叶子结点,无需向下调整
	while (lchild < n)
	{		
		// 假设左孩子为较大的孩子
		int mchild = lchild;
		// 当右孩子存在时,如果右孩子比左孩子大,就将右孩子改为较大的孩子
		if (rchild < n && a[mchild] < a[rchild])
		{
			mchild = rchild;
		}

		// 不断向下调整
		if (a[parent] < a[mchild])
		{
			Swap(&a[parent], &a[mchild]);
			parent = mchild;
			lchild = 2 * parent + 1;
			rchild = 2 * parent + 2;
		}
		else
		{
			break;
		}
	}
}

⑶堆的插入与删除

由于堆是由数组模拟实现的,因此在堆中插入数据一般选择尾插(选择尾插有两个好处:1. 不会破坏原来的父子关系; 2. 效率高),它的代码实现如下

// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);

	// 检测数组是否需要进行扩容
	if (hp->size == hp->capacity)
	{
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * hp->capacity * 2);
		if (tmp == NULL)
		{
			perror("malloc fail");
			return;
		}

		hp->a = tmp;
		hp->capacity *= 2;
	}

	hp->a[hp->size] = x;
	hp->size++;

	// 传入的是最后一个有效元素的下标,即size-1
	AdjustUp(hp->a, hp->size - 1);
}

类似的,堆数据的取出(删除)一般选择将首元素与尾元素交换并将size-1表示有效元素的减少,

它的代码实现如下

// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);

	return hp->size == 0;
}

// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
    // 若堆为空就不应该再被允许删除数据
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	// 需要传入堆有效数据个数
	AdjustDown(hp->a, 0, hp->size - 1);
}

⑷堆的创建

堆的创建有两种形式:

第一种是创建一个空堆,不断向其中插入数据构成一个堆,其代码实现如下

// 堆的创建(一)
void HeapInit(Heap* hp)
{
	assert(hp);

	HPDataType* a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (a == NULL)
	{
		perror("malloc fail");
		return;
	}

	hp->a = a;
	hp->size = 0;
	hp->capacity = 4;
}

第二种是对一个已经存在的数组建堆,这里有两种建堆方式,

一种是向上调整法建堆,代码实现如下

void HeapCreatUp(Heap* hp, HPDataType* a, int n)
{
	assert(hp);

	// 向上调整法建堆 -- 时间复杂度: O(N*logN)
	// 从头开始向后(下)遍历,将每个元素都向上调整一次
	for (int i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}

}

此建堆方式的时间复杂度为O(N*logN),证明如下

数据结构——树_第18张图片

另一种是向下调整法建堆,代码实现如下

void HeapCreatDown(Heap* hp, HPDataType* a, int n)
{
	assert(hp);

	// 向下调整法建堆 -- 时间复杂度: O(N)
	// 第一个n-1是为了找到数组最后一个元素的下标
	// 第二个-1是为了找到该元素父亲
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, i, n);
	}

}

此建堆方式的时间复杂度为O(N),证明如下 

数据结构——树_第19张图片

⑸堆的接口与实现 

接口如下

// 堆的创建
void HeapCreat(Heap* hp, HPDataType* a, int n);

// 堆的初始化
void HeapInit(Heap* hp);

// 堆的销毁
void HeapDestory(Heap* hp);

// 堆的插入
void HeapPush(Heap* hp, HPDataType x);

// 堆的删除
void HeapPop(Heap* hp);

// 取堆顶的数据
HPDataType HeapTop(Heap* hp);

// 堆的数据个数
int HeapSize(Heap* hp);

// 堆的判空
int HeapEmpty(Heap* hp);

实现如下

// 堆的创建
void HeapCreat(Heap* hp, HPDataType* a, int n)
{
	assert(hp);

	// 向上调整法建堆 -- 时间复杂度: O(N*logN)
	// 从头开始向后(下)遍历,将每个元素都向上调整一次
	for (int i = 0; i < n; i++)
	{
		AdjustUp(a, i);
	}

	// 向下调整法建堆 -- 时间复杂度: O(N)
	// 第一个n-1是为了找到数组最后一个元素的下标
	// 第二个-1是为了找到该元素父亲
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, i, n);
	}
}
// 堆的初始化
void HeapInit(Heap* hp)
{
	assert(hp);

	HPDataType* a = (HPDataType*)malloc(sizeof(HPDataType) * 4);
	if (a == NULL)
	{
		perror("malloc fail");
		return;
	}

	hp->a = a;
	hp->size = 0;
	hp->capacity = 4;
}
// 堆的销毁
void HeapDestory(Heap* hp)
{
	assert(hp);

	free(hp->a);
	free(hp);
}
// 堆的插入
void HeapPush(Heap* hp, HPDataType x)
{
	assert(hp);

	// 检测数组是否需要进行扩容
	if (hp->size == hp->capacity)
	{
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * hp->capacity * 2);
		if (tmp == NULL)
		{
			perror("malloc fail");
			return;
		}

		hp->a = tmp;
		hp->capacity *= 2;
	}

	hp->a[hp->size] = x;
	hp->size++;

	// 传入的是最后一个有效元素的下标,即size-1
	AdjustUp(hp->a, hp->size - 1);
}
// 堆的判空
int HeapEmpty(Heap* hp)
{
	assert(hp);

	return hp->size == 0;
}
// 堆的删除
void HeapPop(Heap* hp)
{
	assert(hp);
	// 若堆为空就不应该再被允许删除数据
	assert(!HeapEmpty(hp));

	Swap(&hp->a[0], &hp->a[hp->size - 1]);
	hp->size--;

	// 需要传入堆有效数据个数
	AdjustDown(hp->a, 0, hp->size - 1);
}
// 取堆顶的数据
HPDataType HeapTop(Heap* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

	return hp->a[0];
}
// 堆的数据个数
int HeapSize(Heap* hp)
{
	assert(hp);

	return hp->size;
}

③堆的应用

在发明了堆的结构后,它也被大量投入到其他应用中

⑴堆排序

详见堆排序

⑵Top-K问题

Top-k问题是一类需要找出前k个最大(最小)元素的问题,其中k通常是一个小于总数的正整数。

分析:

对于Top-K问题,能想到的最简单直接的方式就是排序,但是:如果数据量非常大,排序就不太可取了(可能数据都无法全部加载到内存中)。
而最佳的方式就是用堆来解决,基本思路如下:
1. 用数据集合中前K个元素来建堆
求前k个最大(小)的元素,建小(大)堆
2. 用剩余的N-K个元素依次与堆顶元素来比较,不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后,堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
通俗来讲,即为了求k个最大(小)的树,先设定一个k个大小的小堆,将之后的每个元素与小堆的堆顶元素相比较,如果大于堆顶元素就替换其进堆,这样到最后就能保证堆里的元素始终大于堆顶,而堆顶又始终大于堆外的数据,即找到了最大的K个元素

 代码实现

// TopK问题:找出N个数里面最大/最小的前K个问题。

void Swap(int* p1, int* p2)
{
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(int* a, int parent, int n)
{
	// 通过父节点找到左右子节点
	int lchild = 2 * parent + 1;
	int rchild = 2 * parent + 2;

	// 如果左孩子所处位置已经不在堆中就结束循环
	// 表示当前父节点为叶子结点,无需向下调整
	while (lchild < n)
	{
		// 假设左孩子为较大的孩子
		int mchild = lchild;
		// 当右孩子存在时,如果右孩子比左孩子大,就将右孩子改为较大的孩子
		if (rchild < n && a[mchild] > a[rchild])
		{
			mchild = rchild;
		}

		// 不断向下调整
		if (a[parent] > a[mchild])
		{
			Swap(&a[parent], &a[mchild]);
			parent = mchild;
			lchild = 2 * parent + 1;
			rchild = 2 * parent + 2;
		}
		else
		{
			break;
		}
	}
}

// 堆的创建
void HeapCreat(int* a, int n)
{
	// 向下调整法建堆 -- 时间复杂度: O(N)
	// 第一个n-1是为了找到数组最后一个元素的下标
	// 第二个-1是为了找到该元素父亲
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, i, n);
	}
}


// 此处假设寻找K个最大数据
void TestTopk(int* a, int n, int k)
{
	// 1.建一个有k个数据的小堆
	int* tmp = (int*)malloc(sizeof(int) * k);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	int i = 0;
	for (i = 0; i < k; i++)
	{
		tmp[i] = a[i];
	}

	HeapCreat(tmp, k);

	// 2.将这之后的n-k个数据都与堆顶元素比较
	while (i != n)
	{
		if (a[i] > tmp[0])
		{
			Swap(&a[i], &tmp[0]);
			AdjustDown(tmp, 0, k);
		}

		i++;
	}

	for (i = 0; i < k; i++)
	{
		printf("%d ", tmp[i]);
	}
}

测试如下

数据结构——树_第20张图片

4. 二叉树的链式结构

①二叉树的遍历

二叉树遍历(Traversal)是按照某种特定的规则,依次对二叉树中的节点进行相应的操作,并且每个节点只操作一次。遍历是二叉树上最重要的运算之一,也是二叉树上进行其它运算的基础。
二叉树的遍历又分为递归结构和非递归结构
1. 递归结构:前序/中序/后序遍历
2. 非递归结构:层序遍历

注:

深度优先遍历(DFS):如二叉树的前序遍历等,一般用递归实现

广度优先遍历(BFS):如二叉树的层序遍历,一般用队列实现 

在这里,我们使用如下一颗二叉树来举例

数据结构——树_第21张图片

模拟实现它的代码如下

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

BTNode* BuyNode(BTDataType n)
{
	BTNode* a = (BTNode*)malloc(sizeof(BTNode));
	if (a == NULL)
	{
		perror("malloc fail");
		return NULL;
	}

	a->data = n;
	a->left = NULL;
	a->right = NULL;

}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyNode(1);
	BTNode* node2 = BuyNode(2);
	BTNode* node3 = BuyNode(3);
	BTNode* node4 = BuyNode(4);
	BTNode* node5 = BuyNode(5);
	BTNode* node6 = BuyNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

⑴前序遍历

前序遍历的形式是:根 左子树 右子树

对上面那棵树前序遍历有

数据结构——树_第22张图片

从1处开始遍历,先访问根1,再访问{左子树2,此时将2视作新的根,先访问根2[再访问左子树3,然后(3先访问左子树NULL,再访问右子树NULL),再访问右子树NULL],再访问右子树4,然后4[访问左子树5,5先(访问左子树NULL,再访问右子树NULL),再访问右子树6,6先(访问左子树NULL,再访问右子树NULL)]}

代码实现

// 二叉树前序遍历
void PreOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	printf("%d ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

运行和原图验证有

数据结构——树_第23张图片

⑵中序遍历

前序遍历的形式是:左子树 根 右子树

对上面那棵树前序遍历有

数据结构——树_第24张图片

在遍历时,记住“遇到根不能访问,先访问它的左子树”即可 

代码实现

// 二叉树中序遍历
void InOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

验证有

数据结构——树_第25张图片

⑶后序遍历

前序遍历的形式是:左子树 右子树 根

对上面那棵树前序遍历有

数据结构——树_第26张图片

 在遍历时,记住“遇到根和右子树都不能访问,先访问它的左子树,访问完左子树先访问右子树,再访问根”即可 

代码实现

// 二叉树后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		printf("NULL ");
		return;
	}

	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

验证有

数据结构——树_第27张图片

⑷层序遍历

层序遍历的形式为:从根节点开始向下的每一层从左到右依次遍历

对上面那棵树层序遍历有

数据结构——树_第28张图片

在实现层序遍历时,我们通常需要使用队列这一数据结构,将根节点入队列中,这之后每次遍历到根节点后,使其出队列,并将其左右子节点入队列,其示意图如下 

数据结构——树_第29张图片

代码实现(在这里使用队列,将其typedef的内容改为struct BinaryTreeNode*)

// 层序遍历
void LevelOrder(BTNode* root)
{
	Queue q;
	QueueInit(&q);

	QueuePush(&q, root);

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

		if (front->left)
			QueuePush(&q, front->left);
		if (front->right)
			QueuePush(&q, front->right);
	}

	QueueDestroy(&q);
}

int main()
{
	BTNode* root = CreatBinaryTree();
	LevelOrder(root);

	return 0;
}

运行如下

数据结构——树_第30张图片

②求节点个数以及高度等

在此依旧使用上述二叉树,即

数据结构——树_第31张图片

⑴二叉树节点个数

// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	return BinaryTreeSize(root->left) + BinaryTreeSize(root->right) + 1;
}

验证有

数据结构——树_第32张图片

⑵二叉树的高度

// 二叉树的高度
int BinaryHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}

	// 记录左右的高度防止重复访问
	int leftHeight = BinaryHeight(root->left) + 1;
	int rightHeight = BinaryHeight(root->right) + 1;

	return leftHeight > rightHeight ? leftHeight : rightHeight;
}

验证有

数据结构——树_第33张图片

⑶二叉树第k层节点个数

// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
	if (root == NULL)
	{
		return 0;
	}

	if (k == 1)
	{
		if (root)
			return 1;
	}

	return BinaryTreeLevelKSize(root->left, k-1) 
		+ BinaryTreeLevelKSize(root->right, k-1);
}

验证有

数据结构——树_第34张图片

⑷二叉树查找值为x的节点

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

	if (root->data == x)
		return root;

	BTNode* lval = BinaryTreeFind(root->left, x);
	if (lval)
		return lval;

	BTNode* rval = BinaryTreeFind(root->right, x);
	if (rval)
		return rval;

	return NULL;
}

验证有

数据结构——树_第35张图片

你可能感兴趣的:(数据结构,数据结构)