【数据结构】用C语言带你入手树和二叉树( 含二叉树实现源码 + 经典题目解析)

已于 2023-03-07 20:15:12 修改
阅读量905 收藏 4
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 c++ c语言
于 2023-02-27 21:46:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_myhome/article/details/129250750
版权

文章目录

【数据结构】用C语言带你入手树和二叉树( 含二叉树实现源码 + 经典题目解析)

1. 树概念及结构

1.1 树的概念

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

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

image-20230119160813455

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

image-20230119160748193

1.2 树的相关概念

image-20230119160901207

**节点的度：**一个节点含有的子树的个数称为该节点的度； 如上图：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 树的表示

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

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

image-20230119163736694

image-20230119163815426

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

image-20230119163946483

2. 二叉树概念及结构

2.1 概念

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

1.或者为空

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

image-20230119165638376

从上图可以看出：

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

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

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

image-20230119165751925

2.2 现实中的二叉树

image-20230119165835393

2.3 特殊的二叉树

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

2.完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K 的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。

image-20230119170230300

满二叉树高度为k层，总结点个数为2k-1，第k层有2(k-1)个结点。

完全二叉树高度为k层，最多有2k-1的结点，最少有2(k-1)个结点。

2.4 二叉树的性质

image-20230119171748037

2.5 二叉树的存储结构

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

1.顺序存储：

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

image-20230120095254691

2.链式存储：

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

image-20230120100630988

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 二叉树的顺序结构

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

image-20230120100827948

3.2 堆的概念及结构

大堆：树中所有父节点大于等于子节点 ，小堆：树中所有父节点小于等于子节点。

将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

堆的性质：

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

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

image-20230120101240426

image-20230120101640086

3.3 堆的实现

3.3.1 堆向下调整算法

现在我们给出一个数组，逻辑上看做一颗完全二叉树。我们通过从根节点开始的向下调整算法可以把它调整 成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整。

int array[] = {27,15,19,18,28,34,65,49,25,37};

image-20230122153342637

typedef int HPDataType;

void AdjustDown(HPDataType* a, int n, int parent)//向下调整（大堆）
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确保指向的是最大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])//大堆的调整
		{
			child++;
		}
		//如果父亲小于儿子，进行调整
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		//如果父亲大于儿子，调整结束
		else
		{
			break;
		}
	}
}

//大堆和小堆的向下调整在代码实现上只是改变了大于关系
void AdjustDown(HPDataType* a, int n, int parent)//向下调整（小堆）
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确保指向的是最小的那个孩子
		if (child + 1 < n && a[child + 1] < a[child])//大于关系不同于小堆
		{
			child++;
		}
		//如果父亲大于儿子，进行调整
		if (a[child] < a[parent])//大于关系不同于小堆
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		//如果父亲小于儿子，调整结束
		else
		{
			break;
		}
	}
}
3.3.2 堆的创建

下面我们给出一个数组，这个数组逻辑上可以看做一颗完全二叉树，但是还不是一个堆，现在我们通过算法，把它构建成一个堆。根节点左右子树不是堆，我们怎么调整呢？这里我们从倒数的第一个非叶子节点的子树开始调整，一直调整到根节点的树，就可以调整成堆。

int a[] = {1,5,3,8,7,6};

image-20230123222802642

给定一个数组，可以看成是完全二叉树，树的最底层都只是叶子结点，都可以看作是树，由于向下调整算法要求除根以外成树，因此我们可以从倒数第二层最后一个有子结点的结点也就是最后一个结点的父结点开始进行向下调整，从后往前依次完成倒数第二层的向下调整，至此倒数第二层往下全成为了树，倒数第三层满足了向下调整的条件，可以对倒数第三层进行向下调整，依次调整完成堆的创建。

typedef int HPDataType;

void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确保指向的是大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])//大堆的调整
		{
			child++;
		}
		//如果父亲小于儿子，进行调整
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		//如果父亲大于儿子，调整结束
		else
		{
			break;
		}
	}
}

void HeapCreate(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	memcpy(php->a, a, sizeof(HPDataType) * n);//拷贝数据到数组中
	php->size = php->capacity = n;

	//向下调整建堆
	for (int i = (n-1-1)/2; i>=0; --i)
	{
		AdjustDown(php->a, n, i);
	}
}

堆的创建还有另一种方式就是利用向上调整法

也就是将数组看作完全二叉树，存储一个数据，就对该数据进行向上调整建立堆。

void AdjustUp(HPDataType* a, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])//建立大堆
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapCreate(HP* php, HPDataType* a, int n)
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
    
	memcpy(php->a, a, sizeof(HPDataType) * n);//将数据直接存储在数组中
	php->size = php->capacity = n;

	//向上调整建堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(php->a, i);
	}
}
3.3.3 建堆时间复杂度

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

image-20230125173348772

image-20230125174306004

3.3.4 堆的插入

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

image-20230122153836779

typedef int HPDataType;

void AdjustUp(HPDataType* a, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])//建立大堆
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//大堆和小堆的向上调整在代码实现上只是改变了大于关系
void AdjustUp(HPDataType* a, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] < a[parent])//建立小堆
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}
3.3.5 堆的删除

删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调 整算法。

image-20230122154524169

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);
}
3.3.6 堆的代码实现
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <assert.h>
#include <stdbool.h>

typedef int HPDataType;

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

void HeapPrint(HP* php)//打印堆中数据
{
	assert(php);
	for (int i = 0; i < php->size; i++)
	{
		printf("%d ", php->a[i]);
	}
	printf("\n");
}

void Swap(HPDataType* p1, HPDataType* p2)//两数交换
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustUp(HPDataType* a, int child)//向上调整
{
	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])//建立大堆
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//确保指向的是大的那个孩子
		if (child + 1 < n && a[child + 1] > a[child])//大堆的调整
		{
			child++;
		}
		//如果父亲小于儿子，进行调整
		if (a[child] > a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		//如果父亲大于儿子，调整结束
		else
		{
			break;
		}
	}
}

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 HeapPush(HP* php, HPDataType x)//堆的插入
{
	assert(php);

	if (php->size == php->capacity)//扩容
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->a, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fail");
			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);
}

HPDataType HeapTop(HP* php)//获取堆顶元素
{
	assert(php);
	assert(php->size > 0);

	return php->a[0];
}

int HeapSize(HP* php)//获取堆的大小
{
	assert(php);

	return php->size;
}

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

	return php->size == 0;
}

void HeapCreate(HP* php, HPDataType* a, int n)//堆的创建
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
	if (php->a == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}

	memcpy(php->a, a, sizeof(HPDataType) * n);
	php->size = php->capacity = n;

	向下调整建堆
	//for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	//{
	//	AdjustDown(php->a, n, i);
	//}
	//向上调整建堆
	for (int i = 0; i < n; i++)
	{
		AdjustUp(php->a, i);
	}
}

3.4 堆的应用

3.4.1 堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

  1. 建堆

    • 升序：建大堆

    • 降序：建小堆

  2. 利用堆删除思想来进行排序

    建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

    image-20230125184235632

3.4.2 TOP-K问题

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

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

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

思路1：

建立一个N个数的大堆，POP K次，依次取堆顶元素(N不是很大)

  • 时间复杂度：O(N) = N + log N * K
  • 空间复杂度：O(N) = 1(数组存储在数组内，不需要额外开空间)

思路2：

建立K个数小堆，依次遍历数据，比堆顶数据大，就替换堆顶，再向下调整，最后最大的K个数就在这个小堆里(N很大)

  • 时间复杂度：O(N) = N * log K (N + log K*(N-K) )
  • 空间复杂度：O(N) = O(K) (数据量很大数据存在硬盘上，需要额外开数组空间)
typedef int HPDataType;

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

void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] < a[child])//小堆的调整
		{
			child++;
		}
		if (a[child] < a[parent])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{
			break;
		}
	}
}

void TopK(HP* php, HPDataType* a, int n, int k)//TopK问题
{
	assert(php);

	php->a = (HPDataType*)malloc(sizeof(HPDataType)*k);
	php->size = php->capacity = k;

	for (int i = 0; i < k; i++)
	{
		php->a[i] = a[i];
	}
	AdjustDown(php->a, k, 0);

	for (int i = k; i < n; i++)
	{
		if (php->a[0] < a[i])
		{
			php->a[0] = a[i];
		}
		AdjustDown(php->a, k, 0);
	}
}

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

4.1 二叉树遍历

4.1.1 前序、中序以及后序遍历

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

按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前**(先根，后左子树，再后右子树)**。
  2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）(先左子树，后访根，再后右子树)。
  3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后(先左子树，后访右子树，再后根)。

由于被访问的结点必是某子树的根，**所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为 根、根的左子树和根的右子树。**NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。

image-20230126172213080

image-20230126170616764

前序遍历结果：1 2 3 4 5 6

中序遍历结果：3 2 1 5 4 6

后序遍历结果：3 2 5 6 4 1

4.1.2 层序遍历

层序遍历：除了先序遍历、中序遍历、后序遍历外，还可以对二叉树进行层序遍历。设二叉树的根节点所在 层数为1，层序遍历就是从所在二叉树的根节点出发，首先访问第一层的树根节点，然后从左到右访问第2层 上的节点，接着是第三层的节点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。

image-20230126172313070

4.2 节点个数以及高度等实现

typedef int BTNodeDataType;

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

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

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

// 二叉树叶子节点个数
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);
}

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

	//return (TreeHeight(root->left) > TreeHeight(root->right) ? TreeHeight(root->left) : TreeHeight(root->right)) + 1;
	//由于比较之后未保存数据，导致很多重复计算，造成大量浪费

	int leftHeight = TreeHeight(root->left);
	int rightHeight = TreeHeight(root->right);

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

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

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

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

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

	if (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;

	return NULL;
}

4.3 二叉树基础oj练习

4.3.1 单值二叉树

题目链接：965. 单值二叉树 - 力扣（Leetcode）

题目描述：

image-20230127004140950

image-20230127004203180

题目解析：

将该问题层层分级，首先根结点和左孩子右孩子满足，然后递归判断左子树，右子树，一旦有不满的就判断为否，否则为真。

image-20230128091010251

代码实现：

bool isUnivalTree(struct TreeNode* root){
    if (root == NULL)
    {
        return true;
    }

    if (root->left && root->val != root->left->val)
    {
        return false;
    }

    if (root->right && root->val != root->right->val)
    {
        return false;
    }

    return isUnivalTree(root->left) && isUnivalTree(root->right);
}
4.3.2 相同的树

题目链接：100. 相同的树 - 力扣（Leetcode）

题目描述：

image-20230128092123943

image-20230128092223982

题目分析：

首先比较根的值是否相等，然后再判断左子树，右子树，一旦有不满的就判断为否，否则为真。

代码实现：

bool isSameTree(struct TreeNode* p, struct TreeNode* q){
    if (p == NULL && q == NULL)//如果一直为真，return递归里的真来自这里，而外的判断为真会导致递归中断
    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);
}
4.3.3 另一棵树的子树

题目链接：572. 另一棵树的子树 - 力扣（Leetcode）

题目描述：

image-20230128093031535

image-20230128093040150

题目分析：

首先准备好一个判断树相等的函数，简化代码，层层遍历，一旦有满足的即为真，否则为假。

代码实现：

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递归里的假来自这里，而外的判断为假会导致递归中断
    return false;

    if (isSameTree(root,subRoot))//找到即为真
    return true;

    return isSubtree(root->left, subRoot) || isSubtree(root->right, subRoot);
}
4.3.4 二叉树遍历

题目链接 https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef?tpId=60&&tqId=29483&rp=1&ru=/activity/oj&qru=/ta/tsing-kaoyan/question-ranking

题目描述：

image-20230128100127691

image-20230128100139627

题目分析：

用先序递归创建树，也就是先创建根，后左子树，右子树。

代码实现：

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

struct TreeNode 
{
    char val;
    struct TreeNode* left;
    struct TreeNode* right;
};

struct TreeNode* rebulidTree(char* str, int* pi)
{
    if (str[*pi] == '#')
    {
        (*pi)++;
        return NULL;
    }

    struct TreeNode * root = (struct TreeNode*)malloc(sizeof(struct TreeNode));
    root->val = str[(*pi)++];

    root->left = rebulidTree(str, pi);
    root->right = rebulidTree(str, pi);

    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;
    struct TreeNode* root = rebulidTree(str, &i);
    InOrder(root);
    return 0;
}
数据结构（十四） -- C语言版 -- 树 - 二叉树的叶子节点、深度、拷贝等
青椒*^_^*凤爪爪的博客
05-31 5492
本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
C语言数据结构各种程序源代码
06-13
String，队列，二叉树，赫夫曼数，链队列，十字链表， 顺序表，稀疏矩阵等程序源码。
图书管理系统(含源代码)c语言 数据结构课程设计报告.docx
06-14
图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx图书管理系统(含源代码)c语言 数据结构课程设计报告.docx
C语言版数据结构-课程设计-航空客运订票系统 V2.0 附源码（增加管理员功能）
秋日物语的博客
12-19 5819
航空订票系统（角色分为：管理员和顾客，购票可根据等级购买）
数据结构之二叉树（C语言附详细代码）
m0_68210771的博客
07-23 1万+
关于树的简要概念和二叉树的重点内容，以及二叉树的操作代码，前中后序遍历代码以及层次遍历代码
C语言数据结构图的遍历课程设计（附源码及说明书）
01-15
C语言数据结构 图的遍历课程设计 带源码及实验说明书
C语言数据结构课程设计
11-05
这个是我写的一个C语言数据结构的一个汉夫曼编码的课程设计，是一个简单的课程设计，然后用到了哈夫曼树，哈夫曼编码。
C语言中文网 Go语言二叉树数据结构的应用 源码
06-04
C语言中文网 Go语言二叉树数据结构的应用 源码。一开始以为“btree”是golang的包呢。后来发现不是。又找以为是“https://github.com/google/btree.git”。发现还不是。这才想起来可能是自己写的包。绕了一圈子。 ...
C语言实现二叉树的基本操作源码.zip
最新发布
10-30
在IT领域，二叉树是一种基础且重要的数据结构，它在很多算法和程序设计中扮演着核心角色。本文将深入探讨使用C语言实现二叉树的基本操作，包括创建、插入节点、删除节点、遍历以及查找操作。我们将通过分析标题...
C语言实现最小生成树与二叉树课程设计源码及报告
二叉树可以用于实现二叉搜索树（BST）、堆和哈夫曼树等数据结构。二叉树常见的遍历方式有三种：前序遍历、中序遍历和后序遍历。 接下来，探讨“最小生成树”的概念。最小生成树是指在一个加权无向图中，一个包含...
数据结构课程设计（C语言版）
C语言/数据结构/数学建模/深度学习/生物信息
01-13 4581
数据结构课程设计作业 分为顺序表、链表、顺序栈、循环队列、二叉树、图六个部分 包括基本操作和一些简单应用 所有代码上传至github，大家可以直接下载，记得点点star 链接：DataStructure-Algorithm-Project C语言 数据结构 线性表中的顺序表的基本操作集 C语言 数据结构 线性表的链式表示和实现 C语言 数据结构 栈的顺序表示和实现 C语言 数据结构 循环队列的表示和实现 C语言 数据结构 二叉树的基本操作 C语言 数据结构 图的邻接矩阵存储及基本操作
C语言数据结构二叉排序树完整源码
11-01
这是一个二叉排序树的完整程序 希望有助于大家的理解，更好的学习数据结构和C语言
基于C语言（数据结构）的学生奖金管理系统课程设计和文件的操作（附源码）
秋日物语的博客
10-19 2709
该系统可以作为学生管理系统，也可以最为奖学金评定系统
数据结构与算法（五）图c语言实现（带源码）
一个憨憨写的胡言乱语
02-11 529
数据结构与算法（五）图 邻接矩阵存储实现、深度优先及广度优先遍历 #include <stdio.h> #include <stdlib.h> #include <string.h> #include <malloc.h> #define MAX 100 #define MAXNUM 32767//正无穷 typedef struct { char vexs[MAX];//顶点表 （顶点类型是char） int arcs[MAX][MAX];//邻
数据结构c语言版 严蔚敏 课本源码
热门推荐
xinlongkun的博客
02-28 3万+
第2章  线性表 - 单链表顺序存储结构——《数据结构》-严蔚敏.吴伟民版概述       数据结构的学习当然要从线性表学起，而线性表里首先需要学习单链表，这里从单链表最简单的顺序存储结构（本质就是可变数组存储）开始。解析       单链表强调元素在逻辑上紧密相邻，所以首先想到用数组存储。但是普通数组有着无法克服的容量限制，在不知道输入有多少的情况下，很难确定出一个合适的容量。对此，一个较好的解...
数据结构与算法（一）线性表c语言实现（带源码）
一个憨憨写的胡言乱语
02-05 763
数据结构与算法（一）线性表 #系列开篇 自学数据结构小白一名，根据能力持续更新，单纯学习分享贴。本系列适合刚入门的小白参考，大佬轻喷。开始学习时看了很多的书都没有完整的代码，由于太菜连伪代码也无法实现，如果有和我类似的朋友们可以来看看。话少，必要时有描述，一般直接上代码。 线性表的顺序实现 #include <stdio.h> #include <stdlib.h> #include <malloc.h> typedef struct Arr { int* pBas
C语言数据结构课程设计(可运行)
林夕07
12-11 9251
本文章为课程设计全部内容 目录(根据自己的设计更改页数) 1、 任务设计……………………………………2 2、 代码说明……………………………………3 3、 代码清单……………………………………18 4、 代码测试……………………………………18 5、 课程设计总结……………………………19 一、任务设计 1、 设计题目 题目： 数据结构排序实践 2、 课程设计目的 目的：排序时计算机程序设计中的一...
C语言数据结构：顺序表（附源码）
no_pain_no_gain_的博客
03-28 1615
1.运行界面 2.编程过程过程中的思考 1.不按课本中的思想（从表头开始插入），而是从表中或表尾开始插入数据元素，结果如何，运行如下： 请输入您想进行的操作序号： 1.新建一个空表 2.在指定位置插入一个数据元素 3.删除指定位置的数据元素 4.修改指定位置元素 5.输出表内全部元素 6.查询某位置的数据 7.查询某数据的位置 8.退出 ...
C语言版数据结构- C语言实现串，含详细的源代码
weixin_45509705的博客
10-01 1420
HString.h 头文件 #include <stdio.h> #include <stdlib.h> //定义函数返回的类型 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //定义数据元素的类型为字符型 typedef int Status; typedef char ElemType; //定义单链表的存储结构 ty.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

好想写博客

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

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

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

打赏作者

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

抵扣说明：

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

余额充值