【玄说✅数据结构与算法】【初阶】—— 二叉树

玄澈_

于 2022-07-31 15:02:34 发布

阅读量141

点赞数 14

分类专栏： Algorithms and Data Structure 文章标签：数据结构二叉树蓝桥杯算法

本文链接：https://blog.csdn.net/forever_bryant/article/details/125970238

版权

Algorithms and Data Structure 专栏收录该内容

5 篇文章 0 订阅

订阅专栏

目录

💡 树概念及结构

💡 二叉树概念及结构

💡 堆（HEAP）

💡 TOP-K问题

💡 堆排序

💡 二叉树的遍历

💡 oj

树概念及结构

树的概念

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

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

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

树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：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）棵互不相交的树的集合称为森林

树的表示

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

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

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

二叉树概念及结构

概念

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

1. 或者为空

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

从上图可以看出：

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

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

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

现实中的二叉树：

特殊的二叉树

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

所有的叶子结点都在最后一层
所有的分支结点都有两个孩子

TIPS：10个节点的满二叉树是 30 层

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

二叉树的性质

若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 $\small 2^{i-1}$ 个结点.
若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 $\small 2^{h}-1$
对任何一棵二叉树, 如果度为0其叶结点个数为 $\small n_0$ , 度为2的分支结点个数为 $\small n_2$ ,则有 $\small n_0=n_2+1$ （度为0的永远比度为2的多一个）
若规定根节点的层数为1，具有n个结点的满二叉树的深度 $\small h=log_2(n+1)$
(ps：是log以2为底，n+1为对数)`
对于具有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否则无右孩子

二叉树的存储结构

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

顺序存储

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

链式存储

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

堆（HEAP）

如果有一个关键码的集合 $\small K={k_0,k_1,k_2...k_{n-1}}$ ，把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中，并满足： $\small K_i\leq K_{2i+1}$ 且 $\small K\leq K_{2i+2}$ （或反之） $\small i=0,1,2...$

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

堆的性质：

堆中某个节点的值总是不大于或不小于其父节点的值
堆总是一棵完全二叉树。

代码实现

堆的基本结构

初始化函数

销毁函数

插入数据

堆插入数据对其他节点没有影响，只是可能会影响从他到根节点路径上的节点关系

向上调整

打印函数

堆向下调整算法

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

头删删除函数

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

TOP-K问题

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

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

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

将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

void PrintTopK(int* a, int n, int k) 
{ 
	
	HP hp;
	HeapInit(&hp);
	
	// 创建一个k个数的小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp, a[i]);
	}

	// 剩下的 n - k 个数跟堆顶的数据比较，比它大就替换进堆
	for (int i = k; i < n; i++)
	{
		if (a[i] > HeapTop(&hp))
		{
			hp.a[0] = a[i];
			AdjustDown(hp.a, hp.size, 0);
		}
	}

	HeapPrint(&hp);

	HeapDestory(&hp);
}

堆排序

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

1. 建堆

升序：建大堆

降序：建小堆

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

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

第一个数看做堆，后面的数据依次加入堆，然后向上调整，构建堆

向下调整算法的前提：左右子树都是小堆

建堆时间复杂度

堆的价值体现：在它的基础之上再多一些性质

搜索二叉树（最多查找高度次）
Huffman树

代码实现

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

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

void HeapDestory(HP* hp)
{
	assert(hp);
	free(hp->a);
	hp->size = hp->capacity = 0;
}

void AdjustUp(int* a, int child)
{
	assert(a);

	int parent = (child - 1) / 2;
	while (child > 0)
	{
		if (a[child] > a[parent])
		{
			HPDateType tmp = a[child];
			a[child] = a[parent];
			a[parent] = tmp;

			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapPush(HP* hp, HPDateType x)
{
	assert(hp);
	if (hp->size == hp->capacity)
	{
		size_t newCapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPDateType* tmp = realloc(hp->a, sizeof(HPDateType) * newCapacity);
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}

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

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

	AdjustUp(hp->a, hp->size, hp->size - 1);
}

void HeapPrint(HP* hp)
{
	for (int i = 0; i < hp->size; ++i)
	{
		printf("%d ", hp->a[i]);
	}
}

void AdjustDown(int* 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[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else break;
	}
}

void HeapPop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));

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

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

void Swap(HPDateType* px, HPDateType* py)
{
	HPDateType tmp = *px;
	*px = *py;
	*py = tmp;
}

int HeapEmpty(HP* hp)
{
	assert(hp);

	return hp->size == 0;
}



int HeapSize(HP* hp)
{
	return hp->size;
}

HPDateType HeapTop(HP* hp)
{
	assert(hp);
	assert(!HeapEmpty(hp));
	return hp->a[0];
}

void PrintTopK(int* a, int n, int k) 
{ 
	
	HP hp;
	HeapInit(&hp);
	
	// 创建一个k个数的小堆
	for (int i = 0; i < k; i++)
	{
		HeapPush(&hp, a[i]);
	}

	// 剩下的 n - k 个数跟堆顶的数据比较，比它大就替换进堆
	for (int i = k; i < n; i++)
	{
		if (a[i] > HeapTop(&hp))
		{
			hp.a[0] = a[i];
			AdjustDown(hp.a, hp.size, 0);
		}
	}

	HeapPrint(&hp);

	HeapDestory(&hp);
}

void HeapSort(int* a, int n)
{
	 把a构建成堆
	 方法1：
	//for (int i = 0; i < n; i++)
	//{
	//	AdjustUp(a, i);
	//}

	// 方法2：
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}
}

二叉树的遍历

前序、中序以及后序遍历

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

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

1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。根->左子树->右子树

A $\small \Rightarrow$ B $\small \Rightarrow$ D $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ C $\small \Rightarrow$ E $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ F $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL

2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。

左子树->根->右子树

NULL $\small \Rightarrow$ D $\small \Rightarrow$ NULL $\small \Rightarrow$ B $\small \Rightarrow$ NULL $\small \Rightarrow$ A $\small \Rightarrow$ NULL $\small \Rightarrow$ E $\small \Rightarrow$ NULL $\small \Rightarrow$ C $\small \Rightarrow$ NULL $\small \Rightarrow$ F $\small \Rightarrow$ NULL

3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

左子树->右子树->根

NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ D $\small \Rightarrow$ NULL $\small \Rightarrow$ B $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ E $\small \Rightarrow$ NULL $\small \Rightarrow$ NULL $\small \Rightarrow$ F $\small \Rightarrow$ C $\small \Rightarrow$ A

代码实现

基础架构

创建结点

创建二叉树

前序遍历

分治思想：分而治之

中序遍历

后序遍历

计算二叉树大小

求叶子结点的个数

二叉树第k层节点个数

提示：比如求A的第4层，可以转换成求左子树的第3层节点数量 + 右子树的第3层节点数量

二叉树的深度

分治：大问题化解为小问题
当前树的高度/深度 = max{ 左子树的高度，右子树的高度 } + 1

但是上述代码中，由于没有及时存储左子树的深度和右子树的深度，造成了极大的浪费

二叉树查找值为x的节点

代码合集

#define _CRT_SECURE_NO_WARNINGS 1
#include "Heap.h"

typedef char BTDataType;

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


BTNode* BuyNode(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* nodeA = BuyNode('A');
	BTNode* nodeB = BuyNode('B');
	BTNode* nodeC = BuyNode('C');
	BTNode* nodeD = BuyNode('D');
	BTNode* nodeE = BuyNode('E');
	BTNode* nodeF = BuyNode('F');

	nodeA->left = nodeB; 
	nodeA->right = nodeC; 
	nodeB->left = nodeD; 
	nodeC->left = nodeE; 
	nodeC->right = nodeF; 

	return nodeA;
}

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

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

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

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

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

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

void BinaryTreeSize1(BTNode* root, int* pn)
{
	int count = 0;

	++* pn;
	BinaryTreeSize(root->left);
	BinaryTreeSize(root->right);

	return count;
}

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

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

	if (root->left && root == NULL)
	{
		return 1;
	}
	
	return BinaryTreeLeafSize(root->left) + BinaryTreeLeafSize(root->right);
}

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

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

	// root不为空，k!=1,说明root这棵树的第k层在子树里面
	// 转换成求左右子树的k-1层节点数量
	return BinaryTreeLevelKSize(root->left, k - 1)
		+ BinaryTreeLevelKSize(root->right, k - 1);
}

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

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

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

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

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

	BTNode* leftRet = BinaryTreeFind(root->left, x);
	if (leftRet)
	{
		return leftRet;
	}

	BTNode* rightRet = BinaryTreeFind(root->right, x);
	if (rightRet)
	{
		return rightRet;
	}

	return NULL;
}

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

	int n1 = 0;
	BinaryTreeSize(root, &n1);
	
	return 0;
}

oj题

LeetCode965. 单值二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


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);
}

LeetCode144. 二叉树的前序遍历

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
int TreeSize(struct TreeNode* root)
{
    return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;
}

void _preorderTraversal(struct TreeNode* root, int* a, int* pi)
{
    if(root == NULL) return ;

    a[(*pi)] = root->val;
    (*pi)++;
    _preorderTraversal(root->left, a, pi);
    _preorderTraversal(root->right, a, pi);
}

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int size = TreeSize(root);
    int* a = (int*)malloc(sizeof(int) * size);
    int i = 0;
    _preorderTraversal(root, a, &i);
    *returnSize = size;
    return a;
}

LeetCode100. 相同的树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */


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);
}

LeetCode101. 对称二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
bool _isSymmetric(struct TreeNode* root1, struct TreeNode* root2)
{
    if(root1 == NULL && root2 == NULL) return true;

    if(root1 == NULL || root2 == NULL) return false;

    if(root1->val != root2->val) return false;

    return _isSymmetric(root1->left, root2->right) && _isSymmetric(root1->right, root2->left);
}

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

    return _isSymmetric(root->left, root->right);
}

LeetCode572. 另一棵树的子树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */

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);
}

二叉树遍历__牛客网

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

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

struct TreeNode* CreateTree(char* str, int* i)
{
    if(str[*i] == '#')
    {
        (*i) ++;
        return NULL;
    }
    struct TreeNode* root = (struct TreeNode*)malloc(sizeof (struct TreeNode));
    root->val = str[(*i) ++ ];
    root->left = CreateTree(str, i);
    root->right = CreateTree(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[110];
    scanf("%s", str);
    int i = 0;
    struct TreeNode *root = CreateTree(str, &i);
    InOrder(root);
    return 0;
}