数据结构-第4节-二叉树

随风张幔

已于 2022-05-05 11:47:27 修改

阅读量1.4k

点赞数 4

分类专栏：数据结构初阶文章标签：数据结构

于 2022-04-19 11:56:56 首次发布

本文链接：https://blog.csdn.net/qq_45113223/article/details/124267797

版权

数据结构初阶专栏收录该内容

5 篇文章 1 订阅

订阅专栏

1.4.树在实际中的运用（表示文件系统的目录树结构）

1.树概念及结构

1.1.树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

· 有一个特殊的结点，称为根结点，根节点没有前驱结点

· 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继

· 因此，树是递归定义的（树是由根和子树构成，子树又是由根和子树构成，以此类推，直到叶为止）

注：树形结构中，子树之间不能有交集（不能有回路或不能带环），否则就不是树形结构

1.2.树的相关概念

节点的度 ：一个节点含有的子树的个数称为该节点的度；如上图：A的为6

叶节点 或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点

非终端节点或 分支节点 ：度不为0的节点；如上图：D、E、F、G...等节点为分支节点

双亲节点或 父节点 ：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点

孩子节点或 子节点 ：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点

兄弟节点 ：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点

树的度 ：一棵树中，最大的节点的度称为树的度；如上图：树的度为6

节点的层次 ：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；

树的高度或深度 ：树中节点的最大层次；如上图：树的高度为4

堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为堂兄弟节点

节点的祖先 ：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先

子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙

森林：由m（m>0）棵互不相交的树的集合称为森林

1.3.树的表示

//假设指定树的度
#define N 5
typedef int DataType;
struct TreeNode
{
	DataType data;
	struct TreeNode* subs[N];  // 指针数组
};


//不知道树的度(很复杂)
typedef int DataType;
struct TreeNode
{
	DataType data;
	// 顺序表存孩子的指针
	SeqList _sl;	// SLDateType -> struct TreeNode*
};


//孩子兄弟表示法(最优秀的方法)
typedef int DataType;
struct Node
{
	struct Node* _firstChild1; // 第一个孩子结点
	struct Node* _pNextBrother; // 指向其下一个兄弟结点
	DataType _data; // 结点中的数据域
};

孩子兄弟表示法是最常用也是最优秀的表示方法，具体解释如下：

1.4.树在实际中的运用（表示文件系统的目录树结构）

2.二叉树概念及结构

2.1.概念

二叉树特点：

1. 二叉树不存在度大于2的结点

2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

2.2.特殊的二叉树

1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 $2^{k}-1$ ，则它就是满二叉树。

2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，个结点都与深当且仅当其每一度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。完全二叉树简述就是：如果一个二叉树的层数为K，那么前k-1层都是满的，最后一层不满，但是最后一层从左往右是连续的。

注：完全二叉树 / 满二叉树可以使用数组重组

物理结构：

逻辑结构：

已知父亲下标求左右儿子下标：
已知左(右)儿子下标求父亲下标：

leftchild=parent*2+1

rightchild=parent*2+2
parent=(child-1)/2

2.3.二叉树的性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $2^{i-1}$ 个结点.

2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 $2^{h}-1$

3. 对任何一棵非空二叉树, 如果度为0（叶结点）结点个数为 $n_{0}$ , 度为2的分支结点个数为 $n_{2}$ ,则有 $n_{0}=n_{2}+1$ （度为0的结点比度为2的结点永远多一个）

4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度， $h={log_{2}}^{n+1}$

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：

     1. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点

     2. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子

     3. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

选择题：

-------------------------------------------------------------------------------------------------------------------------

1. 某二叉树共有 399 个结点，其中有 199 个度为 2 的结点，则该二叉树中的叶子结点数为（）

A 不存在这样的二叉树

B 200

C 198

D 199

答案：A

-------------------------------------------------------------------------------------------------------------------------

2.下列数据结构中，不适合采用顺序存储结构的是（）

A 非完全二叉树

B 堆

C 队列

D 栈

-------------------------------------------------------------------------------------------------------------------------

3.在具有 2n 个结点的完全二叉树中，叶子结点个数为（）

A n

B n+1

C n-1

D n/2

答案：A

解析：假设度为0有N0个，度为1有N1个，度为2有N2个

N0+N1+N2=2N -> N0+N1+N0-1=2N -> 2*N0+N1-1=2N

因为完全二叉树中度为1的结点要么为0要么为1，所以N1为0或1，又因为如果N1为0的话N0是一个小数，所以N1只能为1

N0=N

-------------------------------------------------------------------------------------------------------------------------

4.一棵完全二叉树的节点数位为531个，那么这棵树的高度为（）

A 11

B 10

C 8

D 12

答案：B

解析：

假设高度是h，则

结点最多： $2^{h}-1$

结点最少： $2^{h-1}-1+1$

531一定介于最多和最少之间，因此h为10

-------------------------------------------------------------------------------------------------------------------------

5.一个具有767个节点的完全二叉树，其叶子节点个数为（）

A 383

B 384

C 385

D 386

答案：B

解析：

假设度为0有N0个，度为1有N1个，度为2有N2个

N0+N1+N2=767 -> N0+N1+N0-1=767 -> 2*N0+N1-1=767

因为完全二叉树中度为1的结点要么为0要么为1，所以N1为0或1，当N1为1不成立，当N1为0则N0为384

2.4.二叉树的存储结构

二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

1. 顺序存储（存储完全二叉树和满二叉树）

顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树，因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储，关于堆我们后面的章节会专门讲解。二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树

2.链式存储

二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址。链式结构又分为二叉链和三叉链，当前我们学习中一般都是二叉链，后面课程学到高阶数据结构如红黑树等会用到三叉链。
typedef int BTDataType;


// 二叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}



// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}；

3.二叉树的顺序结构及实现

3.1.二叉树的顺序结构

普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储，需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

3.2.堆的概念及结构

大堆/大根堆：树中父亲都大于等于孩子

小堆/小根堆：树中父亲都小于等于孩子

堆的性质：

· 堆中某个节点的值总是不大于或不小于其父节点的值；

· 堆总是一棵完全二叉树。

3.3.堆的实现

Test.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

void TestHeap()
{
	HP hp;
	HeapInit(&hp);
	HeapPush(&hp, 1);
	HeapPush(&hp, 5);
	HeapPush(&hp, 0);
	HeapPush(&hp, 8);
	HeapPush(&hp, 3);
	HeapPush(&hp, 9);
	HeapPrint(&hp);

	HeapPop(&hp);
	HeapPrint(&hp);

	HeapDestroy(&hp);
}



void PrintTopK(int* a, int n, int k)
{
	// 1. 建堆--用a中前k个元素建堆
	int* kminHeap = (int*)malloc(sizeof(int) * k);
	assert(kminHeap);

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

	// 建小堆
	for (int j = (k - 1 - 1) / 2; j >= 0; --j)
	{
		AdjustDown(kminHeap, k, j);
	}

	// 2. 将剩余n-k个元素依次与堆顶元素交换，不满则则替换
	for (int i = k; i < n; ++i)
	{
		if (a[i] > kminHeap[0])
		{
			kminHeap[0] = a[i];
			AdjustDown(kminHeap, k, 0);
		}
	}

	for (int j = 0; j < k; ++j)
	{
		printf("%d ", kminHeap[j]);
	}
	printf("\n");
	free(kminHeap);
}

void TestTopk()
{
	int n = 10000;
	int* a = (int*)malloc(sizeof(int) * n);
	srand(time(0));
	for (size_t i = 0; i < n; ++i)
	{
		a[i] = rand() % 1000000;
	}
	a[5] = 1000000 + 1;
	a[1231] = 1000000 + 2;
	a[531] = 1000000 + 3;
	a[5121] = 1000000 + 4;
	a[115] = 1000000 + 5;
	a[2305] = 1000000 + 6;
	a[99] = 1000000 + 7;
	a[76] = 1000000 + 8;
	a[423] = 1000000 + 9;
	a[0] = 1000000 + 1000;
	PrintTopK(a, n, 10);
}

int main()
{
	TestTopk();

	return 0;
}

Heap.h文件：

#pragma once
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include<stdbool.h>
#include<time.h>


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

void Swap(HPDataType* pa, HPDataType* pb);

//初始化
void HeapInit(HP* php);

//销毁
void HeapDestroy(HP* php);

//打印
void HeapPrint(HP* php);

//向上调整算法
void AdjustUp(HPDataType* a, size_t child);

//向下调整算法
void AdjustDown(HPDataType* a, size_t size, size_t root);

// 插入x，保持插入后依旧是(大/小)堆
void HeapPush(HP* php, HPDataType x);

// 删除堆顶的数据。(最小/最大)
void HeapPop(HP* php);

//判断堆是否为空
bool HeapEmpty(HP* php);

//返回堆的大小
size_t HeapSize(HP* php);

//返回根元素
HPDataType HeapTop(HP* php);

Heap.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

void HeapInit(HP* php)
{
	assert(php);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void HeapDestroy(HP* php)
{
	assert(php);
	free(php->a);
	php->a = NULL;
	php->size = php->capacity = 0;
}

void Swap(HPDataType* pa, HPDataType* pb)
{
	HPDataType tmp = *pa;
	*pa = *pb;
	*pb = tmp;
}

void HeapPrint(HP* php)
{
	assert(php);
	for (size_t i = 0; i < php->size; ++i)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

void AdjustUp(HPDataType* a, size_t child)
{
	size_t parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])
			//if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void AdjustDown(HPDataType* a, size_t size, size_t root)
{
	size_t parent = root;
	size_t child = parent * 2 + 1;
	while (child < size)
	{
		// 1、选出左右孩子中小的那个
		if (child + 1 < size && a[child + 1] < a[child])
		{
			++child;
		}

		// 2、如果孩子小于父亲，则交换，并继续往下调整
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* php, HPDataType x)
{
	assert(php);

	if (php->size == php->capacity)
	{
		size_t newCapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = realloc(php->a, sizeof(HPDataType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc failed\n");
			exit(-1);
		}

		php->a = tmp;
		php->capacity = newCapacity;
	}

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

	// 向上调整，控制保持是一个堆
	AdjustUp(php->a, php->size - 1);
}

void HeapPop(HP* php)
{
	assert(php);
	assert(php->size > 0);

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

	AdjustDown(php->a, php->size, 0);
}

bool HeapEmpty(HP* php)
{
	assert(php);

	return php->size == 0;
}

size_t HeapSize(HP* php)
{
	assert(php);

	return php->size;
}

HPDataType HeapTop(HP* php)
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

注：

1.插入时要用到向上调整算法：插入时，将数据插入到数组最后面，逻辑上也就是本来的完全二叉树最后一个叶后面的位置。要注意这样直接插入后可能不再是一个堆了（因为堆要满足小堆或大堆），如果不再是一个堆了，就需要将他和他的父亲以至于祖先进行比较，进行交换以满足大堆或小堆，也就是进行向上调整算法。本代码是使用小堆，因此本代码中向上调整算法是基于小堆的（child比parent小进行交换，否则不交换），写向上调整算法时算法逻辑思想是二叉树，物理上操作的是数组中的数据

向上调整算法最多交换高度h次，当完全二叉树有N个节点，那么该二叉树对应的满二叉树有 $2^{h}-1$ 个节点，那么该完全二叉树的高度h= $log_{2}^{N+1}$ ，所以向上调整算法时间复杂度为O( $log_{2}^{N}$ )，向上调整算法十分高效

2.删除时要用到向下调整算法：删除时，删除的是数组下标为0的元素，逻辑上也就是删除树根元素，即最小\最大的那个元素。做法是先将根元素和最后一个元素（size-1处的元素）进行交换，然后删除最后一个数据（size--），最后进行向下调整算法：

（1）找出左右孩子中小（大）的那个

（2）跟父亲比较，如果比父亲小（大），交换；否则就结束

（3）再从交换的孩子位置继续往下调整，直到叶结束

当完全二叉树有N个节点，那么该二叉树对应的满二叉树有 $2^{h}-1$ 个节点，那么该完全二叉树的高度h= $log_{2}^{N+1}$ ，所以向下调整算法时间复杂度为O( $log_{2}^{N}$ )。

删除时不能挪动数据覆盖根的位置（下标为1的元素开始后面数据往前移，将下标为0的元素覆盖），因为挪动数据是O(N),并且这样做堆结构被破坏，父子间关系全乱了

3.堆排序：因为向上调整算法和向下调整算法时间复杂度很小，将一组数据生成一个堆很高效，而在堆中每次删除根元素操作又能重新找到剩余数组中最小\最大的元素，在堆中依次删除取根元素就可以进行高效排序，这就是堆排序（小堆对应升序，大堆对应降序）

将一组数生成一个堆，时间复杂度为N* $log_{2}^{N}$ ，再将堆里面的数依次删除每次在根处得到剩余数组最大（最小）值，时间复杂度还为N* $log_{2}^{N}$ ，因此堆排序的时间复杂度为N* $log_{2}^{N}$ ，堆排序代码如下图所示

上面代码虽然时间复杂度低，效率很好，但是将数组传递过来，每Heappush一次都需要再占用一个空间，最后再生成一个hp堆数组，空间复杂度为O(N)，因此上面代码还需要改进，要求时间复杂度控制在O(N*logN)，空间复杂度控制在O(1)，优化方式如下面，先将传过来的原数组本身建堆，然后进行排序

4.数组建堆（将一个数组改变数据前后顺序使其成为一个堆）有两种方式：

方式一：使用向上调整，插入数据的思想建堆

方式二：使用向下调整建堆（向下调整不能直接建堆，因为向下调整有前提要求是根的左子树和右子树都为堆，所以可以从后往前调，又因为叶子节点是不需要调的，因为叶子节点其本身就可以看成是小堆或大堆，所以从倒数第一个非叶子开始调，而倒数第一个非叶子为数组最后一个节点的父亲）

同一个数组，使用向上调整建堆和向下调整建堆得到的堆一般是不一样的，一个数组对应的堆不是唯一的

5.使用向上调整建堆的时间复杂度

第一层（根）：不需要调整

第二层：总共 $2^{1}$ 个节点，每个节点最多需要调1次，因此总共为 $2^{1}$ *1

第三层：总共 $2^{2}$ 个节点，每个节点最多需要调2次，因此总共为 $2^{2}$ *2

第四层：总共 $2^{3}$ 个节点，每个节点最多需要调3次，因此总共为 $2^{3}$ *3

......

第h层：总共 $2^{h-1}$ 个节点，每个节点最多需要调h-1次，因此总共为 $2^{h-1}$ *（h-1）

总共为： $2^{1}$ *1+ $2^{2}$ *2+ $2^{3}$ *3+...+ $2^{h-1}$ *（h-1）

上面二式减一式得到：

又因为 $2^{h}-1$ =N -> h= $log_{2}^{N+1}$ 代入T(h)得

T(h)= $(N+1)\times (log_{2}^{N+1}-2)+2$

因此，向上调整建堆的时间复杂度为O(N* $log_{2}^{N}$ )

6.使用向下调整建堆的时间复杂度

第一层（根）：总共 $2^{0}$ 个节点，每个节点最多需要向下移动h-1层，因此总共为 $2^{0}$ *(h-1)

第二层：总共 $2^{1}$ 个节点，每个节点最多需要向下移动h-2层，因此总共为 $2^{1}$ *(h-2)

第三层：总共 $2^{2}$ 个节点，每个节点最多需要向下移动h-3层，因此总共为 $2^{2}$ *(h-3)

第四层：总共 $2^{3}$ 个节点，每个节点最多需要向下移动h-4层，因此总共为 $2^{3}$ *(h-4)

......

第h-1层：总共 $2^{h-2}$ 个节点，每个节点最多需要向下移动1层，因此总共为 $2^{h-2}$ *1

总共为：

因此，向下调整建堆的时间复杂度为O(N)

其实O(N)与O(N* $log_{2}^{N}$ )差别是不大的，尤其是当N特别大的时候 $log_{2}^{N}$ 与N相比其实是可忽略的，因此向上调整建堆和向下调整建堆差别是不大的

7.建堆后排序

升序建大堆：把最大的数（根的数）与最后一个数交换，这样最大的数排到了最后，然后将最大的数排除在堆之外，此时剩下的数中，根的左子树和右子树依然是大堆，使用向下调整算法后，剩下的数也组成堆，再将最大的数（根的数）与最后一个数交换，以此类推。

降序建小堆：把最小的数（根的数）与最后一个数交换，这样最小的数排到了最后，然后将最小的数排除在堆之外，此时剩下的数中，根的左子树和右子树依然是小堆，使用向下调整算法后，剩下的数也组成堆，再将最小的数（根的数）与最后一个数交换，以此类推。

升序建大堆和降序建小堆代码相同，如下图所示：

升序建大堆和降序建小堆的时间复杂度为：O(N* $log_{2}^{N}$ )

升序建小堆和降序建大堆：以升序建小堆为例，最小的数已经在第一个位置（下标为0的位置）了，然而剩下数的关系全乱了，需要重新建堆，再选出次小的，不断的建堆选数，建堆需要O(N)。如果这样，还不如直接遍历选数（遍历选数一次复杂度也为O(N)），因此升序建小堆可以是可以，但是效率不行，还复杂

这样我们使用先建堆后排序的方法就实现前面注3的优化，其时间复杂度为：O(N)+O(N* $log_{2}^{N}$ )，空间复杂度为：O(1)

8.TOP-K问题

TOP-K问题：N个数中找出最大/最小的前K个，即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

方法1：排序

时间复杂度:O(N* $log_{2}^{N}$ ) 内存中占用空间复杂度：O(N)

方法2：建立N个数的大堆，Pop K次，就可以选出最大的前K个

时间复杂度:O(N+ $log_{2}^{N}\times K$ ) 内存中占用空间复杂度：O(N)

方法3：用前K个数建立一个K个数的小堆，然后剩下的N-K个依次遍历，如果比堆顶的数据大，就替换他进堆并向下调整，最后堆里面的K个数就是最大的K个

时间复杂度:O(N+ $log_{2}^{N}\times K$ ) 内存中占用空间复杂度：O(K)

注：有可能N非常大，远大于K，比如100亿个数里面找出最大的前10个，方法1和方法2就不能使用了，因为内存很有可能会不够（100亿个整数大概需要40个G的空间）（排序和建立堆都是在内存中进行的），方法3只占用了k个节点的内存空间，其余N-K个数都是从磁盘的文件中取的

方法3实现代码：

方法3实现代码运行结果：

4.二叉树的链式结构及实现

4.1.二叉树的链式结构

完全二叉树和满二叉树用数组来存储很方便，但如果不是完全二叉树，使用数组来存储就会有空间浪费，如下图所示

因此如果不是完全或满二叉树，使用链式结构效果更好

二叉链和三叉链结构：
typedef int BTDataType;

// 二叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}

// 三叉链
struct BinaryTreeNode
{
 struct BinTreeNode* _pParent; // 指向当前节点的双亲
 struct BinTreeNode* _pLeft; // 指向当前节点左孩子
 struct BinTreeNode* _pRight; // 指向当前节点右孩子
 BTDataType _data; // 当前节点值域
}；
注：普通二叉树增删查改没有价值，如果是为了单纯存储数据，不如使用线性表。学习普通二叉树，是为了更好能够控制他的结构，为后续学习更复杂的搜索二叉树打基础，并且很多二叉树OJ算法题都出在普通二叉树上

4.2.二叉树的遍历

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。

前序遍历（先根遍历）：根节点左子树右子树

中序遍历（中根遍历）：左子树根节点右子树

后序遍历（后根遍历）：左子树右子树根节点

层序遍历：一层一层的走

前序遍历：

中序遍历：

后序遍历：

层序遍历：

4.3.链式二叉树实现与遍历

Test.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>

#include "Queue.h"

typedef int BTDataType;

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

BTNode* BuyBTNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	node->data = x;
	node->left = node->right = NULL;
	return node;
}

BTNode* CreatBinaryTree()
{
	BTNode* node1 = BuyBTNode(1);
	BTNode* node2 = BuyBTNode(2);
	BTNode* node3 = BuyBTNode(3);
	BTNode* node4 = BuyBTNode(4);
	BTNode* node5 = BuyBTNode(5);
	BTNode* node6 = BuyBTNode(6);
	BTNode* node7 = BuyBTNode(7);
	BTNode* node8 = BuyBTNode(8);

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

	node6->right = node8;

	return node1;
}

void PrevOrder(BTNode* root) {
	if (root == NULL) {
		printf("NULL ");
		return;
	}
	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(BTNode* root) {
	if (root == NULL) {
		printf("NULL ");
		return;
	}
	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void PostOrder(BTNode* root) {
	if (root == NULL) {
		printf("NULL ");
		return;
	}
	PostOrder(root->left);
	PostOrder(root->right);
	printf("%d ", root->data);
}

int BTreeSize(BTNode* root) {
	return root == NULL ? 0 :
		BTreeSize(root->left)
		+ BTreeSize(root->right) + 1;
}

int BTreeLeafSize(BTNode* root)
{
	if (root == NULL)
		return 0;

	if (root->left == NULL && root->right == NULL)
		return 1;

	return BTreeLeafSize(root->left) + BTreeLeafSize(root->right);
}

// 第k层的节点的个数，k >= 1
int BTreeKLevelSize(BTNode* root, int k)
{
	assert(k >= 1);

	if (root == NULL)
		return 0;

	if (k == 1)
		return 1;

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

int BTreeDepth(BTNode* root)
{
	if (root == NULL)
		return 0;

	int leftDepth = BTreeDepth(root->left);
	int rightDepth = BTreeDepth(root->right);

	return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}

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

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

	BTNode* ret1 = BTreeFind(root->left, x);
	if (ret1)
		return ret1;

	BTNode* ret2 = BTreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

// 二叉树销毁
void BTreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

	BTreeDestory(root->left);
	BTreeDestory(root->right);
	free(root);
}

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

	if (root)
	{
		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);
		}
	}

	printf("\n");
	QueueDestory(&q);
}

// 判断二叉树是否是完全二叉树
bool BTreeComplete(BTNode* root)
{
	Queue q;
	QueueInit(&q);

	if (root)
		QueuePush(&q, root);

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

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

	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);
		// 空后面出到非空，那么说明不是完全二叉树
		if (front)
		{
			QueueDestory(&q);
			return false;
		}
	}

	QueueDestory(&q);
	return true;
}

int main()
{
	BTNode* tree = CreatBinaryTree();
	PrevOrder(tree);
	printf("\n");

	InOrder(tree);
	printf("\n");

	printf("size:%d\n", BTreeSize(tree));
	printf("size:%d\n", BTreeSize(tree));
	printf("size:%d\n", BTreeSize(tree));

	printf("Leaf size:%d\n", BTreeLeafSize(tree));

	printf("Depth size:%d\n", BTreeDepth(tree));

	for (int i = 1; i <= 7; ++i)
	{
		printf("Find:%d,%p\n", i, BTreeFind(tree, i));
	}

	BTNode* ret = BTreeFind(tree, 5);
	if (ret)
	{
		ret->data = 50;
	}
	PrevOrder(tree);
	printf("\n");

	LevelOrder(tree);
	printf("完全二叉树:%d\n", BTreeComplete(tree));


	BTreeDestory(tree);
	tree = NULL;

	return 0;
}

Queue.h文件：

#pragma once

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

struct BinaryTreeNode;

typedef struct BinaryTreeNode* QDataType;

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

typedef struct Queue
{
	QNode* head;
	QNode* tail;

}Queue;

void QueueInit(Queue* pq);
void QueueDestory(Queue* pq);
void QueuePush(Queue* pq, QDataType x);
void QueuePop(Queue* pq);
bool QueueEmpty(Queue* pq);
size_t QueueSize(Queue* pq);
QDataType QueueFront(Queue* pq);
QDataType QueueBack(Queue* pq);

Queue.c文件：

#define _CRT_SECURE_NO_WARNINGS 1
#include "Queue.h"

void QueueInit(Queue* pq)
{
	assert(pq);
	pq->head = pq->tail = NULL;
}

void QueueDestory(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	while (cur)
	{
		QNode* next = cur->next;
		free(cur);
		cur = next;
	}

	pq->head = pq->tail = NULL;
}

void QueuePush(Queue* pq, QDataType x)
{
	assert(pq);
	QNode* newnode = (QNode*)malloc(sizeof(QNode));
	assert(newnode);

	newnode->data = x;
	newnode->next = NULL;

	if (pq->tail == NULL)
	{
		assert(pq->head == NULL);
		pq->head = pq->tail = newnode;
	}
	else
	{
		pq->tail->next = newnode;
		pq->tail = newnode;
	}
}

void QueuePop(Queue* pq)
{
	assert(pq);
	assert(pq->head && pq->tail);

	if (pq->head->next == NULL)
	{
		free(pq->head);
		pq->head = pq->tail = NULL;
	}
	else
	{
		QNode* next = pq->head->next;
		free(pq->head);
		pq->head = next;
	}
}

bool QueueEmpty(Queue* pq)
{
	assert(pq);

	//return pq->head == NULL && pq->tail == NULL;
	return pq->head == NULL;
}

size_t QueueSize(Queue* pq)
{
	assert(pq);
	QNode* cur = pq->head;
	size_t size = 0;
	while (cur)
	{
		size++;
		cur = cur->next;
	}

	return size;
}

QDataType QueueFront(Queue* pq)
{
	assert(pq);
	assert(pq->head);

	return pq->head->data;
}

QDataType QueueBack(Queue* pq)
{
	assert(pq);
	assert(pq->tail);

	return pq->tail->data;
}

注：

1. 前序遍历PrevOrder(tree)的递归调用详细过程见下图所示（结合栈帧来理解，调用结束，栈帧就会销毁）

2.中序遍历InOrder(tree)的递归调用根的左子树边详细过程见下图所示，右子树同理

2.计算树的结点个数BTreeSize函数时，++count放置的位置不同就对应着前序、中序、后序计算树结点个数，如下图所示

但是使用这种方法不好，因为如果我们连续调用两次计算结点函数BTreeSize时，第二次输出的节点数就会为12，如果连续调用三次计算结点函数BTreeSize，第二次输出12第三次输出18。出现这种情况的原因是每次调用BTreeSize函数前，count全局变量没有清零

使用局部的静态变量如下图所示，static int count=0代码只有开始第一次会执行一次，后面递归进入后该行代码不再执行，但是这种使用局部的静态变量方法和前面全局变量count方法问题一样，连续调用两次计算结点函数BTreeSize时，第二次输出的节点数就会为12，连续调用三次计算结点函数BTreeSize，第二次输出12第三次输出18，同样不会清零

解决：

方法1.使用遍历+计数的思想，使用全局变量count的方法可以每次调用BTreeSize前将count置零即可解决该问题，如下图所示，而使用局部的静态变量方法无法置零，问题无法解决，因此我们使用全局变量count的方法，该方法有线程安全问题（以后linux会学）

方法2：使用遍历+计数的思想，传一个局部变量的地址，每次计数用都用一个局部变量来计，该方法为最优解，如下图所示

方法3：使用分治的思想，利用递归方法进行计数（该方法使用了分治的思想，即把复杂问题，分成更小规模的子问题，子问题再分成更小规模的子问题...直到子问题不可再分割直接能出结果），代码如下图所示，下面代码的计数遍历思路与后序遍历一致

3.计算树的叶子个数BTreeLeafSize函数，有两种思路：1.遍历+计数 2.分治。遍历+计数的思路很简单加一个条件判断即可，下面我们用分治的思路来实现，代码如下图所示

4.计算树的第k层结点个数BTreeKLevelSize函数，这里使用遍历+计数的思想就不好实现了，需要使用分治的思想，具体思想和代码如下所示

思想：

1.空树，返回0

2.非空，且k=1，返回1

3.非空，且k>1，转换成左子树k-1层节点个数+右子树k-1层节点个数

代码：

5.计算树的深度BTreeDepth函数，使用分治的思想，具体代码如下图所示

6.二叉树查找值为x的节点BTreeFind函数，使用分治的思想，具体代码如下图所示

7.深度优先遍历(DFS)：前序、中序、后序

广度优先遍历(BFS)：层序

层序遍历LevelOrder函数的实现：借助于队列，首先将根存进队列，后面每出一个结点就将该节点的孩子结点（孩子结点不为空）插入队列中，最后当队列为空就结束了

层序遍历代码：

写层序遍历代码，我们有以下注意点：

注意点一：

这里面我们要用到队列代码，以前我们写好过队列，我们通过以下步骤将队列代码加入到本项目中：

1.找到队列代码的.h和.c文件进行复制

2.头文件右键添加现有项，将刚刚复制的.c和.h文件粘贴到弹出的现有项目录中，然后将.c文件从头文件分类拖到源文件分类中

3.在代码中包含刚刚添加的.h头文件即可使用队列了

注意点二：

入队列时不能入结点的值，因为如果只入值的话是无法找到其孩子结点的，所以入队列时应该入结点或结点的指针(入结点的指针更合适，因为其占用内存更小)。所以将Queue.h文件的队列中原本的数据类型int应改为BTNode*，入下面左图应改成右图

注意点三：

文件中包含头文件，编译的时候其实是将头文件中的内容拷贝过来，Test.c包含的头文件Queue.h中使用了类型重定义将BTNode*重新定义成了QDataType（注意点二中右图），如下面左图所示，而BTNode是包含头文件代码后面定义的，所以会出错。并且在Queue.c中包含了Queue.h头文件，而头文件中没有BTNode的定义(BTNode的定义只在Test.c中有)，因此出错。

解决方法是将Queue.h头文件中的对BTNode*类型重定义（下面第二行左图）改成对原生类型struct BinaryTreeNode*类型重定义（下面第二行右图），然后在Queue.h头文件对原生类型struct BinaryTreeNode*类型重定义的前面加一个原生类型的前置声明，如第三行图所示

8.判断二叉树是否是完全二叉树BinaryTreeCompete函数，思路：

1.与层序遍历类似，只不过空结点也进队列

2.出到空结点以后，出队列中所有数据，如果全是空，就是完全二叉树，如果有非空，就不是

BinaryTreeCompete函数代码：

4.4.二叉树基础OJ练习

练习一：

题目描述：

题目链接：965. 单值二叉树 - 力扣（LeetCode） (leetcode-cn.com)

代码：

练习二：

题目描述：

题目链接：100. 相同的树 - 力扣（LeetCode） (leetcode-cn.com)

代码：

练习三：

题目描述：

题目链接：101. 对称二叉树 - 力扣（LeetCode） (leetcode-cn.com)

代码：

练习四：

题目描述：

题目链接： 144. 二叉树的前序遍历 - 力扣（LeetCode） (leetcode-cn.com)

代码：

注：

1.下面代码有两个问题

第一个问题：在最开始的栈帧中i=0，i++后i等于1，再往下递归会创建新的栈帧，在新的栈帧中i++并不会影响最开始栈帧中i的值。我们需要一个i，而不是到处拷贝的i，此时我们考虑到使用静态变量i，但是在这种OJ题中不要使用静态变量，因为这种OJ题都会有多组测试用例，第一个测试用例使用静态变量后，第二个测试用例该变量无法再初始化（全局变量也不能使用，原因和静态变量相同），这里的解决方法是将i的地址进行传递，这样解引用就控制到了同一个i

第二个问题：形参中有一个指针变量returnSize，该指针变量其实是一个输出型参数，正常的输入性参数给你是让你来使用的，这种输出型参数是将外面变量的地址传给你，你要解引用给他赋值，这里要将size变量大小赋值给*returnSize

练习五：

题目描述：

题目链接：572. 另一棵树的子树 - 力扣（LeetCode） (leetcode-cn.com)

思路：比较两个树是否相同的isSameTree函数前面已有，遍历root树的每个结点，将每个结点作为根的子树都和subRoot树比较一下即可

代码：

练习六：

题目描述：

题目链接：二叉树遍历_牛客题霸_牛客网 (nowcoder.com)

代码：

注：

1.先序遍历输入为：

树的形状为：

2.创建树CreateTree函数的递归部分流程图如下图所示

随风张幔

关注

4
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
4
评论
数据结构-第4节-二叉树

1.树概念及结构 1.1.树的概念树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 ·有一个特殊的结点，称为根结点，根节点没有前驱结点 ·除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继 ·因此，树是...
复制链接

扫一扫