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
堂兄弟节点:双亲在同一层的节点互为堂兄弟;如上图:H、I互为兄弟节点
节点的祖先:从根到该节点所经分支上的所有节点;如上图:A是所有节点的祖先
子孙:以某节点为根的子树中任一节点都称为该节点的子孙。如上图:所有节点都是A的子孙
森林:由m(m>0)棵互不相交的树的集合称为森林;
1.3 树的表示
树结构相对线性表就比较复杂了,要存储表示起来就比较麻烦了,既然保存值域,也要保存结点和结点之间 的关系,实际中树有很多种表示方式如:双亲表示法,孩子表示法、孩子双亲表示法以及孩子兄弟表示法 等。我们这里就简单的了解其中最常用的孩子兄弟表示法。
typedef int DataType;
struct Node
{
struct Node* _firstChild1; // 第一个孩子结点
struct Node* _pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据域
};
2.二叉树概念及结构
2.1概念
一棵二叉树是结点的一个有限集合,该集合:
1. 空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成
从上图可以看出:
1. 二叉树不存在度大于2的结点
2. 二叉树的子树有左右之分,次序不能颠倒,因此二叉树是有序树
注意:对于任意的二叉树都是由以下几种情况复合而成的:
2.2特殊的二叉树:
1. 满二叉树:一个二叉树,如果每一个层的结点数都达到最大值,则这个二叉树就是满二叉树。也就是说,如果一个二叉树的层数为K,且结点总数是 ,则它就是满二叉树。
2. 完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K 的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
2.3 二叉树的存储结构
1. 顺序存储
顺序结构存储就是使用数组来存储,一般使用数组只适合表示完全二叉树,因为不是完全二叉树会有空间的浪费。而现实中使用中只有堆才会使用数组来存储,二叉树顺序存储在物理上是一个数组,在逻辑上是一颗二叉树。
2. 链式存储
二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成,数据域和左右指针域,左右指针分别用来给出该结点左孩子和右孩子所 在的链结点的存储地址 。链式结构又分为二叉链和三叉链,当前我们学习中一般都是二叉链,后面课程 学到高阶数据结构如红黑树等会用到三叉链。
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 前序、中序以及后序遍历
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中(间)。
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
//前序遍历(先序遍历)
void PreOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
//中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
//后序遍历
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
3.2 层序遍历
层序遍历:除了先序遍历、中序遍历、后序遍历外,还可以对二叉树进行层序遍历。设二叉树的根节点所在层数为1,层序遍历就是从所在二叉树的根节点出发,首先访问第一层的树根节点,然后从左到右访问第2层上的节点,接着是第三层的节点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。
//层序遍历
//借助队列
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->data);
if (front->left)
QueuePush(&q, front->left);
if (front->right)
QueuePush(&q, front->right);
}
printf("\n");
QueueDestroy(&q);
}
4.二叉树实现完整代码
#include<stdio.h>
#include<assert.h>
#include<stdlib.h>
#include"Queue.h"
#include<stdbool.h>
//定义二叉树链式结构
typedef int BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
BTDataType data;
}BTNode;
//动态开辟新结点
BTNode* BuyBTNode(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* node1 = BuyBTNode(1);
BTNode* node2 = BuyBTNode(2);
BTNode* node3 = BuyBTNode(3);
BTNode* node4 = BuyBTNode(4);
BTNode* node5 = BuyBTNode(5);
BTNode* node6 = BuyBTNode(6);
//BTNode* node7 = BuyBTNode(7); //新增此语句,用来测试判断是否为完全二叉树
node1->left = node2;
node1->right = node4;
node2->left = node3;
//node2->right = node7; //新增此语句,用来测试判断是否为完全二叉树
node4->left = node5;
node4->right = node6;
return node1;
}
//前序遍历(先序遍历)
void PreOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}
//中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
//后序遍历
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}
一、打印二叉树的结点的个数
写法1:count定义成局部变量,这样写,相当于每个栈帧都有一个count,重复计数,不可取!!!
这是在递归,无法加到一个count
(以前序打印为例)
//void BTreeSize(BTNode* root)
//{
// int count = 0;
// if (root == NULL)
// return ;
// ++count;
// BTreeSize(root->left);
// BTreeSize(root->right);
//}
写法2:count定义成静态局部变量,但需要返回值,其类型为int
多次打印会出错,累加打印,不可取
定义成局部变量,想要拿到,必须添加返回值语句,
定义成全局变量,可以直接拿到,无需添加返回值语句
(前序打印)
//int BTreeSize(BTNode* root)
//{
// static int count = 0;
// if (root == NULL)
// return count;
// ++count;
// BTreeSize(root->left);
// BTreeSize(root->right);
//
// return count;
//}
//写法3:count定义成全局变量(可以打印)
//全局变量存储在静态区,而非栈帧,遍历时,当遇到空结点就返回,当不为空,就++
//1.打印二叉树的结点的个数(前序打印)
//int count = 0;
//void BTreeSize(BTNode* root)
//{
// if (root == NULL)
// return;
// ++count;
// BTreeSize(root->left);
// BTreeSize(root->right);
//}
2.打印二叉树的结点的个数(中序打印)
//int count = 0;
//void BTreeSize(BTNode* root)
//{
// if (root == NULL)
// return;
// BTreeSize(root->left);
// ++count;
// BTreeSize(root->right);
//}
3.打印二叉树的结点的个数(后序打印)
//int count = 0;
//void BTreeSize(BTNode* root)
//{
// if (root == NULL)
// return;
// BTreeSize(root->left);
// BTreeSize(root->right);
// ++count;
//}
总结:以上定义成局部变量,静态局部变量都不够好!
1.count定义成静态局部变量,每次调用无法初始化为0,当多次打印会出现累加计数
因此count应采用全局变量或者定义成静态全局变量
2.count定义成全局变量,会涉及到线程安全问题,这涉及到Linux的内容
写法4:将count定义成静态全局变量(可以打印)
//static int count = 0;
//int BTreeSize(BTNode* root)
//{
// if (root == NULL)
// return count;
// BTreeSize(root->left);
// BTreeSize(root->right);
// ++count;
// return count;
//}
写法5:count既不定义成局部变量,也不定义成全局变量
思想:遍历+计数
将一个变量的地址传过去,
前序计数打印为例
//void BTreeSize(BTNode* root, int* pCount)
//{
// if (root == NULL)
// return;
// ++(*pCount);
// BTreeSize(root->left, pCount);
// BTreeSize(root->right, pCount);
//}
//写法6:count既不定义成局部变量,也不定义成全局变量
//分治思想
//前序计数打印为例
int BTreeSize(BTNode* root)
{
return root == NULL ? 0 : BTreeSize(root->left)
+ BTreeSize(root->right)
+ 1;
}
//二、打印二叉树叶子结点的个数
//思路1:遍历+计数
//思路2:分治思想
//分治实现
int BTreeLeafSize(BTNode* root)
{
if (root == NULL)
return 0;
if (root->left == NULL && root->right == NULL)
return 1;
return BTreeLeafSize(root->left) + BTreeLeafSize(root->right);
}
//三、打印二叉树第k层的结点的个数
int BTreeKLevelSize(BTNode* root, int k)
{
assert(k >= 1);
if (root == NULL)
return 0;
if (k == 1)
return 1;
return BTreeKLevelSize(root->left, k - 1)
+ BTreeKLevelSize(root->right, k - 1);
}
//四、打印二叉树的深度(高度)
int BTreeDepth(BTNode* root)
{
if (root == NULL)
return 0;
int leftDepth = BTreeDepth(root->left);
int rightDepth = BTreeDepth(root->right);
return leftDepth > rightDepth ? leftDepth + 1 : rightDepth + 1;
}
//五、二叉树查找值x的结点
//找到了就返回调用处,层层返回,直至首次调用,而不是直接返回打印!
BTNode* BTreeFind(BTNode* root, BTDataType x)
{
//树形结构实现查找
//以前序遍历为例
if (root == NULL)
return NULL;
if (root->data == x)
return root;
//写法1:
//BTNode* ret1 = BTreeFind(root->left, x);
//if (ret1)
// return ret1;
//BTNode* ret2 = BTreeFind(root->right, x);
//if (ret2)
// return ret2;
写法2:使用三目运算符
return (BTreeFind(root->left, x))? BTreeFind(root->left, x):BTreeFind(root->right, x);
//或者
//return (BTreeFind(root->right, x)) ? BTreeFind(root->right, x) : BTreeFind(root->left, x);
//写法3:
//BTNode* ret1 = BTreeFind(root->left, x);
//if (ret1)
// return ret1;
//return (BTreeFind(root->right, x));
/*//虽然可以正确打印,但这样就破坏了二叉树的遍历顺序
不可取
BTNode* ret2 = BTreeFind(root->right, x);
if (ret2)
return ret2;
return (BTreeFind(root->left, x));*/
return NULL;
}
//六、二叉树的销毁
//思想:后序遍历进行销毁
//传一级指针无需置空,置空无用
//传二级指针需要置空
void BTreeDestroy(BTNode* root)
{
if (root == NULL)
return;
BTreeDestroy(root->left);
BTreeDestroy(root->right);
free(root);
//root = NULL; //传一级指针置空不起作用
}
七、层序遍历
借助队列
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->data);
if (front->left)
QueuePush(&q, front->left);
if (front->right)
QueuePush(&q, front->right);
}
printf("\n");
QueueDestroy(&q);
}
//八、判断二叉树是否为完全二叉树
//bool值类型
//return false<==>0<==>假
//return true<==>1<==>真
bool BTreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front == NULL)
break;
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
//遍历到空值,若后面又遍历到非空,那么说明不是完全二叉树
if (front)
{
//判断后需要销毁队列,否则就会造成内存泄漏
QueueDestroy(&q);
printf("此二叉树不是完全二叉树\n");
return false;
}
}
//判断后需要销毁队列,否则就会造成内存泄漏
QueueDestroy(&q);
printf("此二叉树是完全二叉树\n");
return true;
}
int main()
{
BTNode* tree = CreatBinaryTree();
PreOrder(tree); //前序遍历打印
InOrder(tree); //中序遍历打印
PostOrder(tree); //后序遍历打印
//1.结点计数count定义成静态局部变量打印方式
//printf("二叉树结点个数:%d \n", BTreeSize(tree));
//printf("二叉树结点个数:%d \n", BTreeSize(tree));
//printf("二叉树结点个数:%d \n", BTreeSize(tree));
2.结点计数count定义成全局变量打印方式
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
3.结点计数count定义成静态全局变量打印方式
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
//
//count = 0;
//BTreeSize(tree);
//printf("二叉树结点个数:%d \n", count);
//4.结点计数count既不定义成局部变量,也不定义成全局变量打印方式
//思想:遍历+计数
//int count1 = 0;
//BTreeSize(tree, &count1);
//printf("二叉树结点个数:%d \n", count1);
//int count2 = 0;
//BTreeSize(tree, &count2);
//printf("二叉树结点个数:%d \n", count2);
//int count3 = 0;
//BTreeSize(tree, &count3);
//printf("二叉树结点个数:%d \n", count3);
5.结点计数count分治思想打印
printf("二叉树结点个数:%d \n", BTreeSize(tree));
printf("二叉树结点个数:%d \n", BTreeSize(tree));
printf("二叉树结点个数:%d \n", BTreeSize(tree));
//6.二叉树叶子结点个数打印
//分治思想
printf("二叉树叶子结点个数:%d \n", BTreeLeafSize(tree));
//7.二叉树第k层结点数打印
//int level = 1; //打印第1层结点个数
//int level = 2; //打印第2层结点个数
int level = 3; //打印第3层结点个数
BTreeKLevelSize(tree, level);
printf("二叉树第k层结点个数:%d \n", level);
//8.二叉树的深度打印方式
printf("二叉树深度:%d \n", BTreeDepth(tree));
//9.二叉树的值x的查找打印方式
for (int i = 1; i <= 7; ++i)
{
printf("Find:%d,%p\n", i, BTreeFind(tree, i));
}
//查找后修改
//返回结点指针的另一层含义—可修改其值
BTNode* ret = BTreeFind(tree, 5);
if (ret)
{
ret->data = 50;
}
PreOrder(tree);
printf("\n");
//10.层序遍历打印
LevelOrder(tree);
//11.判断是否为完全二叉树打印
//因为使用bool值,0--假 1--真
//0--假(不是完全二叉树)
//1--真(是完全二叉树)
//打印方式1
BTreeComplete(tree);
//打印方式2
//printf("完全二叉树:%d\n", BTreeComplete(tree));
//销毁二叉树
BTreeDestroy(tree);
tree = NULL;
return 0;
}