初阶4 二叉树

已于 2025-01-19 16:52:36 修改
阅读量1k 收藏 18
点赞数 14
CC 4.0 BY-SA版权
分类专栏： 数据结构 文章标签： 数据结构
于 2025-01-19 16:50:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ydm_ymz/article/details/145244284

本章重点

  1. 树概念及结构
  2. 二叉树概念及结构
  3. 二叉树的顺序结构——堆
  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
    一般是从1开始算，书的根节点为1，NULL树为0；
  • 堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
  • 节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
  • 子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
  • 森林：由m（m>0）棵互不相交的树的集合称为森林；

1.3 树的表示

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

表示：左孩子右兄弟表示法

请添加图片描述

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

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

请添加图片描述

2.二叉树概念及结构

2.1 概念

一棵二叉树是结点的一个有限集合，该集合:

  1. 或者为空
  2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

请添加图片描述

从上图可以看出：

二叉树不存在度大于2的结点
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意：对于任意的二叉树都是由以下几种情况复合而成的：
请添加图片描述

2.2 特殊的二叉树

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

请添加图片描述

对于满二叉树：

请添加图片描述

完全二叉树：
前N-1层是满的，最后一层可以不满，但必须从左到右是连续的

请添加图片描述

2.3 二叉树的性质

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

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

  3. 对任何一棵二叉树,如果度为0其叶结点个数为 n 0 n_0 n0​ ,度为2的分支结点个数为 n 2 n_2 n2​,则有 n 0 ＝ n 2 ＋ 1 n_0＝n_2＋1 n0​＝n2​＋1.

  4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度， h = l o g 2 ( n + 1 ) h=log_2(n+1) h=log2​(n+1).

  5. 对于具有n个节点的二叉树,如果按照从上至下的数组顺序对所有节点从0开始编号,则对于序号为i的节点有:

    • 若 i>0 ，i位置节点的双亲序号：(i−1)/2；i=0,i为根节点编号，无双亲节点
    • 若 2i+1<n ，左孩子序号：2i+1， 2i+1>=n否则无左孩子
    • 若 2i+2<n ，右孩子序号：2i+2， 2i+2>=n否则无右孩子

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

  2. 下列数据结构中，不适合采用顺序存储结构的是（ ）
    A 非完全二叉树
    B 堆
    C 队列
    D 栈

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

  4. 一棵完全二叉树的节点数位为531个，那么这棵树的高度为（ ）
    A 11
    B 10
    C 8
    D 12

  5. 一个具有767个节点的完全二叉树，其叶子节点个数为（）
    A 383
    B 384
    C 385
    D 386

答案：
1.B 2.A 3.A 4.B 5.B

3.二叉树的顺序结构——‘堆’

3.1 二叉树的顺序结构

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

3.2 堆的概念及结构

如果有一个关键码的集合 K = { k 0 ， k 1 ， k 2 ， … ， k n − 1 } K =\lbrace k_0，k_1 ，k_2 ，…，k_{n-1}\rbrace K={k0​，k1​，k2​，…，kn−1​} ，把它的所有元素按完全二叉树的顺序存储方式存储 在一个一维数组中，并满足：

$ K_i<=K_{2* i+1} 且 K_i<=K_{2* i+2}(K_i>=K_{2* i+1}且 K_i>=K_{2* i+2})$

则称为小堆(或大堆)。将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

即:
大堆: 树中所有 父节点 都 大于或等于 子节点
小堆: 树中所有 父节点 都 小于或等于 子节点

父节点与子节点有关系：

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

3.3 堆的实现

3.3.1 向下调整算法与向上调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。

我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。

向下调整算法：

  • 小堆：父节点 比 子节点 小，往下换，换孩子中大的那个
  • 大堆：父节点 比 子结点 大，往下换，换孩子中小的那个
    向上调整算法：
  • 小堆：子节点 比 父节点 小，往上换
  • 大堆：子节点 比 父节点 大，往上换

3.3.2 堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。

这里我们插入每插入一个数，就和父节点进行比较，建立一个大堆如下：

请添加图片描述

3.3.3 堆的插入

先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆。

请添加图片描述

3.3.4 建堆的复杂度

因为堆是完全二叉树，而满二叉树也是完全二叉树，此处为了简化使用满二叉树来证明
(时间复杂度本来看的 就是近似值，多几个节点不影响最终结果)

向上调整建堆的时间复杂度为O(N*logN)。

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

所以堆的创建一般选取像下调整建堆

最少为0，
最多为：二叉树的层数H

3.3.5 堆的删除

删除堆是删除堆顶的数据，

堆的删除不能往前挪动覆盖，因为首先数组的挪动覆盖 比较慢，而后，堆的关系会乱。

删最后一个就不会改变堆的关系所以，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法。

请添加图片描述

3.4 堆的代码实现

3.4.1 堆的定义

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;
 
//打印
void HeapPrint(HP* hp);
 
// 堆的初始化
void HeapInit(HP* hp);
 
// 堆的销毁
void HeapDestory(HP* hp);
 
// 堆的插入
void HeapPush(HP* hp, HPDataType x);
 
// 堆的删除
void HeapPop(HP* hp);
 
// 取堆顶的数据
HPDataType HeapTop(HP* hp);
 
// 堆的数据个数
int HeapSize(HP* hp);
 
// 堆的判空
bool HeapEmpty(HP* hp);

//堆的构建（给你一个数组，用给定的数组建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n);

3.4.2 堆的函数实现

  1. 堆的初始化
void HeapInit(HP* hp)
{
	assert(hp);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}
  1. 堆的销毁
void HeapDestory(HP* hp)
{
	assert(hp);
	free(hp->a);
	hp->a = NULL;
	hp->size = hp->capacity = 0;
}
  1. 堆的插入
//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
 
	while (child > 0)
	{
		//这里换为 < 是小堆的创建
		if (a[child] > a[parent])
		{
			//交换
			HPDataType temp = a[child];
			a[child] = a[parent];
			a[parent] = temp;
 
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
// 堆的插入
void HeapPush(HP* hp, HPDataType x)
{
	assert(hp);
	
	//扩容
	if (hp->size == hp->capacity)
	{
		int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(hp->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			exit(-1);
		}
 
		hp->a = tmp;
		hp->capacity = newcapacity;
	}
	hp->a[hp->size] = x;
	hp->size++;
	// 向上调整
	AdjustUp(hp->a, hp->size - 1);
}

先循环判断子节点和父节点的大小，然后做向上调整操作，

  1. 堆的删除
//交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child < n && a[child + 1] > a[child])
		{
			++child;
		}
		//孩子大于父亲，交换,继续调整
		if (a[child] > a[parent])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
// 堆的删除
void HeapPop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
 
	//交换
	swap(&hp->a[0], &hp->a[hp->size - 1]);
 
	hp->size--;
 
	AdjustDown(hp->a, hp->size, 0);
}
  1. 取堆顶的数据
HPDataType HeapTop(HP* hp)
{
	assert(hp);
	assert(hp->size > 0);
	return hp->a[0];
}
  1. 堆的数据个数
int HeapSize(HP* hp)
{
	assert(hp);
	return hp->size;
}
7）堆的判空
bool HeapEmpty(HP* hp)
{
	assert(hp);
	return hp->size == 0;
}
  1. 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
// 堆的构建（给你一个数组，用给定的数组建堆）（不用push建堆）
void HeapCreate(Heap* hp, HPDataType* a, int n)
{
	assert(hp);
	hp->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (hp->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	//把传过来的数组a，拷贝给hp->a,
	memcpy(hp->a, a, sizeof(HPDataType) * n);
	hp->size = hp->capacity = n;
 
	//建堆算法（向下调整）
	for (int i = (n - 1 - 1) / 2;i >= 0;--i)
	{
		AdjustDown(hp->a, n, i);
	}
}

3.5 堆的排序

  • 排升序，建大堆
  • 排降序，建小堆

算法思想：堆排序和堆删除的算法思想一样，都用到了堆的向下调整算法

算法核心：用数组的最后一个元素（size位置）与数组首元素进行交换，并将数组的size–；
使得下次交换时，最后一个位置的元素不受影响

//交换
void swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(HPDataType* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child < n && a[child + 1] > a[child])    //第一处：a[child + 1] > a[child]
		{
			++child;
		}
 
		//孩子大于父亲，交换,继续调整
		if (a[child] > a[parent])    //第二处：a[child] > a[parent]
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
 
    //将第一处和第二处的>换位<则是建小堆
}
//堆排序
void HeapSort(int* a, int size)
{
	// 向下调整建堆 -- O(N)
	// 升序：建大堆
	for (int i = (size - 1 - 1) / 2; i >= 0; --i)
	{
		AdjustDown(a, size, i);
	}
 
	int end = size - 1;//(end表示数组需要与array[0]交换的下标位置)
	while (end > 0)
	{
		swap(&a[0], &a[end]);//交换array[0]和array[end]的位置
		AdjustDown(a, end, 0);//向下调整
		end--;
	}
}
 
 
int main()
{
	int array[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
	HeapSort(array, sizeof(array) / sizeof(int));
 
    //打印
    for (int i = 0; i < sizeof(array) / sizeof(int); ++i)
	{
		printf("%d ", array[i]);
	}
	printf("\n");
	return 0;
}

3.6 TOP-K问题

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

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

对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
  • 前k个最大的元素，则建小堆
  • 前k个最小的元素，则建大堆
  1. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
    比如：N个数找最大的前K个：

方法一（传统方法）：建立一个N个数的大堆，Pop K次，依次取堆顶

  • 时间复杂度：N+logN*K
  • 空间复杂度：O(1)

方法二：建立K个数的小堆，依次遍历数据，比堆顶数据大，就替换堆顶，再向下调整，
最后最大的前K个数，就在小堆里面。

  • 时间复杂度：N+（N-K)* logK -> O(N*logK)
  • 空间复杂度：O(K)

这里给定n个数，求n个数里面最大的k个数（方法二的代码实现）

#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
void swap(int* p1, int* p2)
{
	int temp = *p1;
	*p1 = *p2;
	*p2 = temp;
}
//像下调整（数组、数组大小、父节点下标）
void AdjustDown(int* a, int n, int parent)
{
	//默认认为左孩子大
	int child = parent * 2 + 1;
	//超过数组大小
	while (child < n)
	{
		//确认child指向大的孩子
		if (child + 1 < n && a[child + 1] < a[child])
		{
			++child;
		}
		//孩子大于父亲，交换,继续调整
 
		if (a[child] < a[parent])
		{
			swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
 
void TestHeap5()
{
	// 造数据
	int n, k;	//n为造数据的多少，k为选前几个最大的
	printf("请输入n和k:>");
	scanf("%d%d", &n, &k);
 
	//打开文件
	FILE* fin = fopen("data.txt", "w");
	if (fin == NULL)
	{
		perror("fopen fail");
		return;
	}
 
	//写文件
	srand(time(0));		//为了让rand()实现真随机，用时间戳给他一个种子
	//int randK = k;
	//写n个数据到文件data.txt中
	for (size_t i = 0; i < n; ++i)
	{
		int val = rand() % 100;
		fprintf(fin, "%d\n", val);
	}
 
	fclose(fin);
 
	//-------------------------------------------------------------------------//
 
	// 找topk
 
	//打开文件
	FILE* fout = fopen("data.txt", "r");
	if (fout == NULL)
	{
		perror("fopen fail");
		return;
	}
 
	//对数组扩容
	int* minHeap = (int*)malloc(sizeof(int) * k);
	if (minHeap == NULL)
	{
		perror("malloc fail");
		return;
	}
 
	//先读文件里面前k个数据并放入数组中
	for (int i = 0; i < k; ++i)
	{
		fscanf(fout, "%d", &minHeap[i]);
	}
	// 堆前k个数据建小堆
	for (int i = k - 1 - 1; i >= 0; --i)
	{
		AdjustDown(minHeap, k, i);
	}
 
	//文件的数据读取出来，保存到val值中，并与小堆堆顶的数据作比较
	int val = 0;
	while (fscanf(fout, "%d", &val) != EOF)
	{
		//大于堆顶数据，插入进去，并继续排小堆
		if (val > minHeap[0])
		{
			minHeap[0] = val;
			AdjustDown(minHeap, k, 0);
		}
	}
 
	//打印堆里面的数据
	for (int i = 0; i < k; ++i)
	{
		printf("%d ", minHeap[i]);
	}
	printf("\n");
 
	fclose(fout);
}
 
int main()
{
	TestHeap5();
 
	return 0;
}

4.二叉树的链式结构

4.1 前置说明

此次二叉树链式结构的讲解先不进行增删查改，之后学完c++再进一步学习

事实上，普通二叉树的增删查改没有价值，
学习二叉树的意义是：再其基础上完成对搜索二叉树的学习

搜索二叉树：左孩子比父节点小，右孩子比父节点大

请添加图片描述

4.2 二叉树的遍历

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

四种遍历方法：

  • 先序遍历：根、左子树、右子树
  • 中序遍历：左子树、跟、右子树
  • 后序遍历：左子树、右子树、跟
  • 层序遍历：从第一层开始、每层从左到右，一层一层的走

4.3 二叉树遍历的实现

在实现前，我们先要建立一个树，因为我们暂时不学习二叉树的建立，

所以我们直接手动建立如下图的二叉树

请添加图片描述

4.3.1 二叉树建立

#include<stdio.h>
#include<stdlib.h>
 
typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}BTNode;
 
int main()
{
	BTNode* root;
 
	BTNode* n1 = BuyBTNode(1);
	BTNode* n2 = BuyBTNode(2);
	BTNode* n3 = BuyBTNode(3);
	BTNode* n4 = BuyBTNode(4);
	BTNode* n5 = BuyBTNode(5);
	BTNode* n6 = BuyBTNode(6);
	n1->left = n2;
	n1->right = n4;
	n2->left = n3;
	n4->left = n5;
	n4->right = n6;
 
    return 0；
}

4.3.2 前序遍历、中序遍历、后序遍历

因为他们的代码只是遍历顺序不同，所以就放一起了

//前序遍历
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;
	}
	PrevOrder(root->left);
	printf("%d ", root->data);
	PrevOrder(root->right);
}
//后序遍历
void PostOrder(BTNode* root)
{
	if (root == NULL)
	{
		//printf("NULL ");
		return;
	}
	PrevOrder(root->left);
	PrevOrder(root->right);
	printf("%d ", root->data);
}

4.3.3 层序遍历：

首先，将二叉树的根节点放入一个队列中。

从队列的头部取出一个元素（记为当前元素cur），将cur的左孩子作为新节点放入队列尾部，再将cur的右孩子作为新节点放入队列尾部。因为队列是先进先出的，所以这样处理后，下一次取出来的就是左孩子，再下一次取出来的就是右孩子了。

重复步骤2，直到队列为空为止。

void LevelOrder(BTNode* root) 
{
	if (root == NULL) 
		return;
 
	BTNode* queue[1000];   // 定义队列，最多存放1000个节点
 
	int head = 0, tail = 0;
	queue[tail++] = root;
	while (head < tail) 
	{
		BTNode* curNode = queue[head++];   // 出队
 
		printf("%d ", curNode->data);
 
		if (curNode->left != NULL)
			queue[tail++] = curNode->left;    // 左孩子入队
 
		if (curNode->right != NULL)
			queue[tail++] = curNode->right;   // 右孩子入队
	}
}

4.4 结点个数以及高度的计算

因为二叉树适合用递归的方式来计算，所以不论是上面的遍历二叉树还是其他计算，他们的代码都是用递归来实现的

4.4.1 求二叉树的总节点：

有两种方法：

定义一个全局变量size，在每次计算前都要手动将其置为0
直接用递归来进行计算
方法1：

int size = 0;//定义全局变量
void TreeSize1(BTNode* root)
{
	if (root == NULL)
		return;
 
	size++;
	TreeSize1(root->left);
	TreeSize1(root->right);
}
 
//使用时：
int main()
{
    size = 0;  //size是全局变量，每次使用前都需要手动置0,否则会在之前的基础上再加
	TreeSize1(n1);
	printf("TreeSize1：%d\n", size);
 
	TreeSize1(n1);
	printf("TreeSize1（size未置0）：%d\n", size);
 
	size = 0;
	TreeSize1(n1);
	printf("TreeSize1（重新将size置0）：%d\n", size);
    
    return 0;
}

方法2：直接用递归来求：

int TreeSize2(BTNode* root)
{
	return root == NULL ? 0 : TreeSize2(root->left) + TreeSize2(root->right) + 1;
}
 
//使用
int main()
{
    printf("TreeSize2：%d\n", TreeSize2(n1));
	printf("TreeSize2：%d\n", TreeSize2(n1));
	printf("TreeSize2：%d\n", TreeSize2(n1));
    
    return 0;
}

4.4.2 求叶子节点的个数

int TreeLeafSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}
	return TreeLeafSize(root->left) + TreeLeafSize(root->right);
}

4.4.3 求树的深度/高度

int TreeHeight(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	//保留算出的数据，防止重复计算比较
	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);
 
	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

注意这里写的时候不要像下面那样直接返回，

return TreeLeafSize(root->left) > TreeLeafSize(root->right) ? TreeLeafSize(root->left) + 1 : TreeLeafSize(root->right) + 1;

这种写法十分浪费资源，会有很多重复的计算，导致效率特别低

正确的写法是先将其保存起来，再进行比较和返回递归

4.4.4 求第K层的结点数 k>=1

int TreeKLevelSize(BTNode* root, int k)
{
	if (root == NULL)
		return 0;
 
	if (k == 1)
		return 1;
 
	// k > 1 子树的k-1
	return TreeKLevelSize(root->left, k - 1)+ TreeKLevelSize(root->right, k - 1);
}

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

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL||root->data == x)
		return root;
 
	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;
 
	BTNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;
	// 如果左右子树都没有找到匹配的节点，返回 NULL
    return NULL;
}

或

BTNode* TreeFind(BTNode* root, BTDataType x)
{
	if (root == NULL||root->data == x)
		return root;
 
	BTNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;
 
    return TreeFind(root->right, x);
}

4.5 判断是不是完全二叉树

思路：

  • 和层序遍历的思想一样，利用队列的先进先出进行
  • 如果是完全二叉树，在出队列，出到NULL时，队列后面的元素应全为空
  • 如果不是完全二叉树，在出队列，出到NULL时，队列后面的元素会有不为空的情况
  • 我们可以加入一个flag做个判断标志，在第一次遇到NULL是，将flag变为false
  • 在只会再遇到不为空的元素时，如果flag为false，直接返回false
//判断二叉树是否为完全二叉树：
bool TreeComplete(BTNode* root)
{
    Queue q;
    QueueInit(&q);
    if (root)
    {
        QueuePush(&q, root);
    }
    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front == NULL)
            break;
        else
        {
            QueuePush(&q, front->left);
            QueuePush(&q, front->right);
        }
    }
    while (!QueueEmpty(&q))
    {
        BTNode* front = QueueFront(&q);
        QueuePop(&q);
        if (front)
        {
            QueueDestory(&q);
            return false;
        }
    }
    QueueDestroy(&q);  
    return true;
}

4.6 二叉树的销毁

思路：递归进行销毁，和后序遍历类似

void destroyTree(BTNode* root)
{
	if (root == NULL)
		return;
	destroyTree(root->left);
	destroyTree(root->right);
	free(root);
}

5.二叉树的基础OJ题练习

5.1 单值二叉树

思路：

  • 先判断左子树，左子树不为空的情况下，左子树的值不等于根的值，返回false
  • 在判断右子树，左子树不为空的情况下，左子树的值不等于根的值，返回false
  • 最后如果以上两个条件都不满足，说明左右孩子的值和根的值相同，进行递归调用
  • 返回该函数的左子树与上右子树
bool isUnivalTree(struct TreeNode* root)
{
    if(root==NULL)
        return true;
    if(root->left && root->left->val != root->val)
        return false;
    if(root->right && root->right->val != root->val)
        return false;
    return isUnivalTree(root->left) && isUnivalTree(root->right);
}

5.2 检查两颗树是否相同

思路：

  • p和q都为空，返回true
  • p和q有一个为空，返回flase
  • p和q都不为空，则判断他们的节点值是否相同，不相同返回false
  • 上面都不满足，进行递归左右节点

注意：

  • 第一步和第二步不能互换，
  • 不用去管左子树和右子树是否为空的问题，因为递归下去以后就会帮你去判断
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if(p==NULL && q==NULL)
        return true;
 
    if(p==NULL || q==NULL)
        return false;
 
    if(p->val != q->val)
        return false;
        
    return isSameTree(p->left,q->left) && isSameTree(p->right, q->right);
}

5.3 二叉树的前序遍历

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

void preorder(struct TreeNode* root, int* a, int* pi) {
    if (root == NULL) 
    {
        return;
    }
    a[(*pi)++] = root->val;
    preorder(root->left, a, pi);
    preorder(root->right, a, pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize) 
{
    *returnSize = TreeSize(root);
    int* a = (int*)malloc( *returnSize * sizeof(int));
    int i=0;		//确保始终使用同一个 i 
    preorder(root, a, &i);
    return a;
}

5.4 另一颗树的子树

思路：

  • 这道题主要是用root的子树去和subRoot进行比较
  • 有了上面判断两个树是否相同的经验，我们只需要递归root来与subRoot比较即可
  • 注意递归时使用 || （或），在左子树或右子树有一个与subRoot相同的子树即为true
bool isSameTree(struct TreeNode* p, struct TreeNode* q)
{
    if(p==NULL && q==NULL)
        return true;
 
    if(p==NULL || q==NULL)
        return false;
 
    if(p->val != q->val)
        return false;
        
    return isSameTree(p->left,q->left) && isSameTree(p->right, q->right);
}
bool isSubtree(struct TreeNode* root, struct TreeNode* subRoot)
{
    if(root==NULL)
        return false;
 
    if(isSameTree(root,subRoot))
        return true;
 
    return isSubtree(root->left,subRoot) || isSubtree(root->right,subRoot);
}

5.5 二叉树的结构及遍历

#include <stdio.h>
#include <stdlib.h>
 
struct TreeNode
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};
 
//创建二叉树
struct TreeNode* rebulidTree(char* str, int* i)
{
    //= ‘#’直接返回，并将i++
    if(str[*i]=='#')
    {
        (*i)++;
        return NULL;
    }
    //不为‘#’首先malloc一个新的节点，并让root->val指向数组中对应下标位置的值
    struct TreeNode* root=(struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = str[(*i)++];
    
    //递归左子树和右子树
    root->left = rebulidTree(str, i);
    root->right = rebulidTree(str, i);
 
    return root;
}
 
//中序遍历
void InOrder(struct TreeNode* root)
{
    if(root==NULL)
        return;
    InOrder(root->left);
    printf("%c ",root->val);
    InOrder(root->right);
 
}
 
int main() 
{
    char str[100];
    scanf("%s",str);
 
    int i=0;
    //这里传参一定一定要传地址，因为在递归过程中虽然i++过了，
    //但只是在局部的栈帧中，返回之后栈帧销毁，i还是不会变的
    struct TreeNode* root = rebulidTree(str,&i);
 
    InOrder(root);
 
    return 0;
}

6.补充

DFS(Depth-First Search) : 深度优先遍历(二叉树前序遍历)(一般用递归)
BFS(Breadth-First Search) : 广度优先遍历(二叉树层序遍历)(一般用队列)

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值