详解二叉树_概念性质和功能实现（遍历/计算节点/判断二叉树）

概念与性质

概念

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

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

---

特殊的二叉树

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

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

所以有

通俗来说，完全二叉树 就是k-1层节点全满，最后一层（k层）从左到右的节点当遇到空，那么后面全是空。

---

性质

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

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

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

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

5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
   a. 若i>0，i位置节点的双亲序号：(i-1)/2；i=0，i为根节点编号，无双亲节点
   b. 若2i+1<n，左孩子序号：2i+1，2i+1>=n否则无左孩子
   c. 若2i+2<n，右孩子序号：2i+2，2i+2>=n否则无右孩子

---

二叉树的实现

头文件

头文件简单进行声明函数功能

#pragma once

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

typedef char BTDataType;

typedef struct BinaryTreeNode
{
	struct BinaryTreeNode* left;//指向左子树
	struct BinaryTreeNode* right;//指向右子树
	BTDataType data;
}BTNode;


void PreOrder(BTNode* root);
void InOrder(BTNode* root);
void PostOrder(BTNode* root);

//创建节点
BTNode* BuyNode(BTDataType x);

//创建树
BTNode* CreatBinaryTree();

//前序遍历
void PreOrder(BTNode* root);

//中序遍历
void InOrder(BTNode* root);

//后序遍历
void PostOrder(BTNode* root);

//层序遍历
void BinaryTreeLevelOrder(BTNode* root);

//计算节点个数
int BinaryNodeSize(BTNode* root);

//计算叶子节点个数
int BinaryLeafNodeSize(BTNode* root);

//计算第k层的节点个数
int BinaryTreeLevelKsize(BTNode* root, int k);

//计算二叉树深度
int BinaryTreeDepth(BTNode* root);

//查找二叉树为x的元素(任意返回)
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);

//判断一个树是不是完全二叉树
bool IsCompleteBinaryTree(BTNode* root);

//二叉树销毁
void BinaryTreeDestory(BTNode* root);

---

创建节点

链式二叉树由一个个节点组成，再创建树时需要先创建节点；

基础的功能实现。

BTNode* BuyNode(BTDataType x)
{
	BTNode* node = (BTNode*)malloc(sizeof(BTNode));
	if (node == NULL)
	{
		perror("malloc fail\n");
		exit(-1);
	}
	node->data = x;
	node->left = node->right = NULL;
}

---

创建树

建立二叉树可以选择传值，通过传入的参数创建节点，这里简单创建节点并构造链接关系（这里创建如图所示的二叉树）

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 = nodeF;
	nodeC->right = nodeE;

	//返回头节点
	return nodeA;
}

---

遍历

遍历在一些树的算法中都有应用，waiting… …

前序遍历

• 根 左 右

void PreOrder(BTNode* root)
{
	//如果遇到空返回
	if (root == NULL)
	{
		//选择性打印
		printf("NULL ");
		return;
	}
	//先打印此时节点值然后继续先遍历左后遍历右
	printf("%c ", root->data);
	PreOrder(root->left);
	PreOrder(root->right);
}

前序遍历结果：A->B->D->NULL->NULL->NULL->C->E->NULL->NULL->F->NULL->NULL

中序遍历

• 左 根 右

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

中序遍历结果：D -> B -> A -> E -> C -> F

后序遍历

• 左 右 根

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

后序遍历结果：D -> B -> E -> F -> C -> A

层序遍历

代码实现思路：

1. 首先判断根节点是否为空，如果为空则直接返回。
2. 创建一个队列，将根节点插入队列中。
3. 循环遍历队列，直到队列为空。
4. 在每一次循环中，取出队列中的队首元素，即当前层的第一个节点。
5. 输出当前节点的数据。
6. 将当前节点的左右子树插入队列中，如果不为空。
7. 继续循环，直到队列为空。
8. 最后释放队列空间。

void BinaryTreeLevelOrder(BTNode* root)
{
	//如果根为空，直接返回
	if (root == NULL)
	{
		return;
	}

	Queue q;
	QueueInit(&q);
	QueuePush(&q, root);//把根插入队列
	//根不为空继续
	while (!QueueEmpty(&q))
	{
		BTNode* front = QueueFront(&q);
		QueuePop(&q);

		printf("%c ", front->data);

		//如果左/右子树不为空插入队列
		if (front->left)
			QueuePush(&q, front->left);

		if (front->right)
			QueuePush(&q, front->right);
	}
	printf("\n");
	QueueDestroy(&q);
}

---

计算

计算节点个数

利用递归思想当该节点为空时返回，反之递归左节点和右节点

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

计算叶子节点个数

叶子节点即左右子树均为空的节点

同样利用递归，遍历根的左右子树，如果该节点为空返回0，遇到叶子节点则返回1

//计算叶子节点个数
int BinaryLeafNodeSize(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	if (root->left == NULL && root->right == NULL)
	{
		return 1;
	}

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

计算第k层节点个数

第k层的节点个数等于k-1层的左子树节点和右子树节点个数之和

//计算第k层的节点个数 - 等于k-1层的左子树和右子树之和
int BinaryTreeLevelKsize(BTNode* root, int k)
{
	assert(k >= 1);

	if (root == NULL)
	{
		return 0;
	}
	if (k == 1)
	{
		return 1;
	}
	return BinaryLeafNodeSize(root->left, k - 1) + BinaryLeafNodeSize(root->right, k - 1);
}

计算二叉树深度

二叉树深度（层数）等于左右子树中较深子树+1，由此利用递归，返回左右子树中更大的+1；

//计算二叉树深度
int BinaryTreeDepth(BTNode* root)
{
	if (root == NULL)
	{
		return 0;
	}
	
	//二叉树的深度等于左右子树中深度更大的+1
	//return BinaryTreeDepth(root->left) > BinaryTreeDepth(root->right) ? BinaryTreeDepth(root->left) + 1 : BinaryTreeDepth(root->right) + 1;

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

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

其余操作

查找二叉树中为x的元素

对每个节点进行左右子树的递归查找，如果节点为空返回此次递归，如果找到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;
}

二叉树销毁

利用递归思想，递归每个节点的左右子树，最后free掉root

void BinaryTreeDestory(BTNode* root)
{
	if (root == NULL)
	{
		return;
	}

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

判断一个树是不是完全二叉树

1. 首先定义一个队列q，并将根节点指针root插入队列中。
2. 进入循环，只要队列不为空，就进行以下操作：
   a. 取出队列的队首元素front，并弹出队列。
   b. 如果front为空，说明遇到了二叉树的空节点，此时跳出循环。
   c. 如果front不为空，将front的左右子节点指针分别插入队列中。
3. 循环结束后，如果队列中还存在元素，则说明二叉树不是完全二叉树，直接返回false。如果队列中已经没有元素了，说明二叉树是完全二叉树，返回true。

注意操作过程中并没有进行二叉树内节点的删改，只是把根节点front指针改动

bool IsCompleteBinaryTree(BTNode* root)
{
	Queue q;
	QueueInit(&q);
	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;
		}
	}
	QueueDestory(&q);
	return true;
}