目录
一.树的概念
1.树
树一种非线性的数据结构，由各个节点构成的一个类似树型的图像，树的一种应用就是用来管理操作系统的文件，下面是树的各种概念。
节点的度 ：一个节点含有的子树的个数称为该节点的度； 如上图： 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 ）棵互不相交的树的集合称为森
注意： 树的子树之间是不能相连的，否则就不是树！（比如A的子树B和G之间不能相连）
2.二叉树
二叉树就是度<=2的树，下面是二叉树的基础概念。
左右子树：二叉树中任意一个节点所指向的左右节点所代表的树是左右子树（一个节点也可以称为树）
深度：二叉树从根节点那一层往下的层数就叫二叉树的深度，根节点层数可以是0也可以是1（也是树的深度）
满二叉树：二叉树每一层的节点数都是满的，比如一颗深度为4（根节点深度为1）的二叉树有2^4-1个节点，那么这棵树就是满二叉树（如下图）
完全二叉树：二叉树除最后一层之外的层数节点数都是满的，最后一层的节点从左到右是连续的（如下图）
注意：满二叉树是一种特殊的完全二叉树！
二.树的表示方法
1.链式结构
树的节点用来存放数据，对于二叉树来说，一个节点是用一个结构体来表示，里面存放数据，以及两个指针指向两个子节点，也可以叫子树，如果没有节点就是空指针，这种方法叫二叉链。（三叉链就是在二叉链的基础上再加上一个指向父节点的指针）
typedef int BTDataType;
//二叉链的节点写法
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
//三叉链的节点写法
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _parent;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;2.顺序结构
顺序结构其实就是用数组来充当二叉树，其实现原理如下。（一般用来表示完全二叉树或者满二叉树）
3.左孩子右兄弟结构
这种方法适合表示树，因为只需要两个指针就能表示出每个节点度数不确定的树。
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _child;
struct BinaryTreeNode* _brother;
}BTNode;三.二叉树的性质
1. 若规定根节点的层数为 1 ，则一棵非空二叉树的 第 i 层上最多有2^(i-1)个结点2. 若规定根节点的层数为 1 ，则 深度为 h 的二叉树的最大结点数是2^h-13. 对任何一棵二叉树 , 如果度为 0 其叶结点个数为 N0 , 度为 2 的分支结点个数为N2 , 则有N0＝ N2＋ 14. 若规定根节点的层数为 1 ，具有 n 个结点的满二叉树的深度 ， h=log2(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. 前序遍历 (Preorder Traversal 亦称先序遍历 )—— 访问根结点的操作发生在遍历其左右子树之前。2. 中序遍历 (Inorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之中（间）。3. 后序遍历 (Postorder Traversal)—— 访问根结点的操作发生在遍历其左右子树之后。
对于上面这颗二叉树，前中后序访问的结果如下：
前序：8 9 5 2 6 10 7 1
中序：2 5 9 6 8 7 10 1
后序：2 5 6 9 7 1 10 8
还有一种层序遍历，就是从深度低到高，每一层从左向右的遍历
层序：8 9 10 5 6 7 1 2
注意：前序遍历属于深度优先（dfs），层序遍历属于广度优先（bfs）！
五.二叉树的代码实现
下面是一颗二叉树的实现，拥有一些基础的功能。
BinaryTree.h
#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType _data;
struct BinaryTreeNode* _left;
struct BinaryTreeNode* _right;
}BTNode;
// 通过前序遍历的数组构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi);//pi是传入的数组
// 二叉树销毁
void BinaryTreeDestory(BTNode** root);
// 二叉树节点个数
int BinaryTreeSize(BTNode* root);
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root);
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k);
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x);
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root);
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root);
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root);
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root);
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root);BinaryTree.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"BinaryTree.h"
//以下是队列的实现
// 链式结构：表示队列
typedef BTNode* QDataType;
typedef struct QListNode
{
struct QListNode* _next;
QDataType _data;
}QNode;
// 队列的结构
typedef struct Queue
{
QNode* _front;
QNode* _rear;
}Queue;
QNode* BuyQnode(QDataType x);
// 初始化队列
void QueueInit(Queue* q);
// 队尾入队列
void QueuePush(Queue* q, QDataType data);
// 队头出队列
void QueuePop(Queue* q);
// 获取队列头部元素
QDataType QueueFront(Queue* q);
// 获取队列队尾元素
QDataType QueueBack(Queue* q);
// 获取队列中有效元素个数
int QueueSize(Queue* q);
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q);
// 销毁队列
void QueueDestroy(Queue* q);
// 初始化队列
void QueueInit(Queue* q)
{
q->_front = NULL;
q->_rear = NULL;
}
QNode* BuyQnode(QDataType x)
{
QNode* newnode = (QNode*)malloc(sizeof(QNode));
if (newnode == NULL)
{
printf("malloc fail\n");
exit(1);
}
newnode->_next = NULL;
newnode->_data = x;
return newnode;
}
// 队尾入队列
void QueuePush(Queue* q, QDataType data)
{
assert(q);
QNode* newnode = BuyQnode(data);
if (q->_front == NULL)
{
q->_front = newnode;
q->_rear = newnode;
return;
}
q->_rear->_next = newnode;
q->_rear = newnode;
}
// 队头出队列
void QueuePop(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
QNode* tmp = q->_front;
if (q->_front == q->_rear)
{
q->_rear = NULL;
}
q->_front = tmp->_next;
}
// 获取队列头部元素
QDataType QueueFront(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->_front->_data;
}
// 获取队列队尾元素
QDataType QueueBack(Queue* q)
{
assert(q);
assert(!QueueEmpty(q));
return q->_rear->_data;
}
// 获取队列中有效元素个数
int QueueSize(Queue* q)
{
assert(q);
if (q->_front == NULL)
return 0;
int size = 0;
QNode* cur = q->_front;
while (cur)
{
size++;
cur = cur->_next;
}
return size;
}
// 检测队列是否为空，如果为空返回非零结果，如果非空返回0
int QueueEmpty(Queue* q)
{
assert(q);
return !QueueSize(q);
}
// 销毁队列
void QueueDestroy(Queue* q)
{
assert(q);
QNode* cur = q->_front;
QNode* tmp = NULL;
while (cur)
{
tmp = cur;
cur = cur->_next;
free(tmp);
}
}
//
//以下是二叉树的实现
// 通过前序遍历的数组构建二叉树
BTNode* BinaryTreeCreate(BTDataType* a, int n, int* pi)
{
if (a[*pi] == '#')//#为空
{
(*pi)++;
return NULL;
}
BTNode* TreeNode = (BTNode*)malloc(sizeof(BTNode));
TreeNode->_data = a[(*pi)++];
TreeNode->_left = BinaryTreeCreate(a, n, pi);
TreeNode->_right = BinaryTreeCreate(a, n, pi);
return TreeNode;
}
// 二叉树销毁
void BinaryTreeDestory(BTNode** root)//后序遍历删除节点
{
if (*root == NULL)
{
return;
}
BinaryTreeDestory(&(*root)->_left);
BinaryTreeDestory(&(*root)->_right);
free(*root);
}
// 二叉树节点个数
int BinaryTreeSize(BTNode* root)
{
if (root == NULL)//遇到空就返回0个节点
return 0;
return BinaryTreeSize(root->_left) + BinaryTreeSize(root->_right) + 1;//返回左右子树节点的个数+1（当前节点）
}
// 二叉树叶子节点个数
int BinaryTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->_left == NULL && root->_right == NULL)//遇到叶子结点就返回1
return 1;
return BinaryTreeLeafSize(root->_left) + BinaryTreeLeafSize(root->_right);//返回左右子树的叶子结点个数
}
// 二叉树第k层节点个数
int BinaryTreeLevelKSize(BTNode* root, int k)
{
if (root == NULL)
return 0;
if (k == 1)//当k==1时，说明已经到了第K层，可以开始计数（如果感觉有点蒙的可以画画图）
return 1;
return BinaryTreeLevelKSize(root->_left, k - 1) + BinaryTreeLevelKSize(root->_right, k - 1);
}
// 二叉树查找值为x的节点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
return NULL;
if (root->_data == x)
return root;
BTNode* left = BinaryTreeFind(root->_left, x);//如果访问左右子树返回空指针说明没找到
BTNode* right = BinaryTreeFind(root->_right, x);
return left == NULL ? right : left;//无论left和right谁找到了（找到的那个不会是空指针）都会返回找到的那个，如果都没有就会返回空指针
}
// 二叉树前序遍历
void BinaryTreePrevOrder(BTNode* root)
{
if (root == NULL)
return;
printf("%c ", root->_data);//这一步是遍历节点，然后再访问左子树右子树
BinaryTreePrevOrder(root->_left);
BinaryTreePrevOrder(root->_right);
}
// 二叉树中序遍历
void BinaryTreeInOrder(BTNode* root)
{
if (root == NULL)
return;
BinaryTreeInOrder(root->_left);//先访问左子树再访问节点再访问右子树
printf("%c ", root->_data);
BinaryTreeInOrder(root->_right);
}
// 二叉树后序遍历
void BinaryTreePostOrder(BTNode* root)
{
if (root == NULL)
return;
BinaryTreePostOrder(root->_left);//先访问左子树再访问右子树，最后访问节点
BinaryTreePostOrder(root->_right);
printf("%c ", root->_data);
}
// 层序遍历
void BinaryTreeLevelOrder(BTNode* root)
{
if (root == NULL)
return;
Queue q;//借助队列实现层序遍历
QueueInit(&q);
QueuePush(&q, root);//存入根节点的地址
while (!QueueEmpty(&q))//如果队列为空就说明遍历结束
{
BTNode* TreeNode = QueueFront(&q);//取出队列中存储的节点
printf("%c ", TreeNode->_data);//访问节点的数据
QueuePop(&q);//在队列里删除这个节点
if (TreeNode->_left)//把左右节点的地址存入队列中
QueuePush(&q, TreeNode->_left);
if (TreeNode->_right)
QueuePush(&q, TreeNode->_right);
}
QueueDestroy(&q);
}
// 判断二叉树是否是完全二叉树
int BinaryTreeComplete(BTNode* root)
{
if (root == NULL)
return;
Queue q;
QueueInit(&q);
QueuePush(&q, root);//存入根节点的地址
int flag = 1;//flag说明是否遍历过度<2的节点，1为否（当遇到度<2的节点时，队列后面所有的节点的度都应为0，否则就不是完全二叉树）
while (!QueueEmpty(&q))
{
BTNode* TreeNode = QueueFront(&q);
QueuePop(&q);
if (TreeNode->_right != NULL && TreeNode->_left == NULL)//完全二叉树不存在左子树为空右子树存在的情况
return 0;
if (flag && (TreeNode->_right == NULL || TreeNode->_left == NULL))
{
flag = 0;//遍历到了度<2的节点，就把flag置为0
continue;
}
if (TreeNode->_left != NULL && flag == 0)
return 0;//之前遇到了度<2的节点并且又遇到了度不为0的点
else if (TreeNode->_left)
QueuePush(&q, TreeNode->_left);
if (TreeNode->_right != NULL && flag == 0)
return 0;//之前遇到了度<2的节点并且又遇到了度不为0的点
else if (TreeNode->_right)
QueuePush(&q, TreeNode->_right);
}
QueueDestroy(&q);
return 1;
}test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include"BinaryTree.h"
int main()
{
char str[] = "ABD##E#H##CF##G##";//这是前序遍历的结果，空指针为'#'
int pi = 0;
BTNode* Tree;
Tree = BinaryTreeCreate(str, 0, &pi);//通过str数组创建一个二叉树
printf("树的节点个数：%d\n", BinaryTreeSize(Tree));
printf("树的叶子节点个数：%d\n", BinaryTreeLeafSize(Tree));
printf("树的第4层的节点个数：%d\n", BinaryTreeLevelKSize(Tree, 4));
printf("想要找的值的节点地址：%p\n", BinaryTreeFind(Tree, 'H'));
printf("前序遍历：");
BinaryTreePrevOrder(Tree);
printf("\n中序遍历：");
BinaryTreeInOrder(Tree);
printf("\n后序遍历：");
BinaryTreePostOrder(Tree);
printf("\n层序遍历：");
BinaryTreeLevelOrder(Tree);
printf("\n");
printf("是否为完全二叉树：%d\n", BinaryTreeComplete(Tree));
BinaryTreeDestory(&Tree);
return 0;
}
以上就是二叉树的介绍和实现了，二叉树的应用还有堆，适用于堆排序和Top-K问题，这些都在我的排序算法篇中有讲解。
如有不懂或者发现博客中存在的错误也可以在评论区留言给我。
6万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
