目录
一、树概念及结构
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; // 结点中的数据域
};
二、二叉树概念及结构
1.二叉树的概念
一个二叉树是节点的有限集合:
①该集合为空
②根节点加上两颗别称为左子树和右子树的二叉树组成。
从上图可以看出:
1.二叉树节点的度均<=2
2.二叉树的左子树与右子树次序之分不能颠倒,所以二叉树是有序树。
注意:对于任意的二叉树都是由以下几种情况复合而成的:
2.特殊的二叉树
满二叉树:除了叶子节点外的每个节点都有两个子节点。如果满二叉树的层数为h,则总节点数为2^h-1,同理反过来也可以证明是二叉树。
完全二叉树:完全二叉树是效率很高的数据结构,完全二叉树是由满二叉树而引出来的。对于深度为K 的,有n个结点的二叉树,当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对 应时称之为完全二叉树。 要注意的是满二叉树是一种特殊的完全二叉树。
3.二叉树的性质
1. 若规定根结点的层数为1,则一棵非空二叉树的第i层上最多有2^(i-1) 个结点。
2. 若规定根结点的层数为1,则深度为h的二叉树的最大结点数是2^h-1个结点。
3.对任何一棵二叉树, 如果度为0其叶结点个数为 n , 度为2的分支结点个数为m ,则有n=m+1
4.若规定根结点的层数为1,具有n个结点的满二叉树的深度,h= . (ps:是log以2 为底,n+1为对数)
4.二叉树的存储结构
二叉树的存储结构分为顺序存储结构和链式存储结构。
1.顺序存储
顺序存储结构就是用数组来存储,一般来说是顺序存储只用于完全二叉树的存储,不是完全二叉树使用顺序存储会存在浪费空间。二叉树在物理上是数组,在逻辑上是一颗二叉树。
2.链式存储
二叉树的链式存储结构是指,用链表来表示一棵二叉树,即用链来指示元素的逻辑关系。 二叉树的链式存储是通过使用节点(Node)来表示树的结构。每个节点都包含一个数据元素和指向其左子树和右子树的指针。
三、二叉树的顺序结构及实现
1.顺序存储
普通的二叉树一般不使用顺序存储,因为这会浪费大量空间,但是完全二叉树却适合使用数组来表示,现实生活中我们把堆用顺序存储来实现。需要注意的是这里的堆和操作系统 虚拟进程地址空间中的堆是两回事,一个是数据结构,一个是操作系统中管理内存的一块区域分段。
2. 堆的概念及结构
2.1堆的概念
堆是一种特殊的二叉树,它满足以下的性质:
1.堆是一种完全二叉树;
2.堆中每个节点的值都满足堆的性质,堆分为大堆和小堆。
大堆:堆中的每个节点的值总是大于或等于其子节点的值,大堆不是降序。
小堆:堆中的每个节点的值总是小于或等于其父节点的值,小堆不是升序。
2.2堆的结构
堆的实现通常使用数组来存储数据,因为完全二叉树可以使用数组的索引来表示。
1.对于节点i,其左子节点的索引为2i+1,右子节点的索引为2i+2,父节点的索引为(i-1)/2。
2.每个节点的左右子树也必须是一个堆。
3.堆的实现
3.1堆的向上调整算法
堆的向上调整算法经常用于插入新的元素后,确保新插入的元素符合堆的性质。
算法方法:
1.将新插入的元素放在数组的最后一位。
2.将新插入的元素与父节点的值进行对比。
3.如果建大堆:新插入元素比父节点的值大则交换
如果建小堆:新插入元素比父节点的值小则交换
4.继续向上对比和交换,直到满足堆的性质或达到堆的根节点。
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.2堆向下调整算法
我们可以创建一个数组,看作一个完全二叉树,然后用下调整算法可以把它调成一个大堆或小堆。
下调整算法有一个前提是:左右子树必须是堆。
1.从堆顶元素开始,与子节点中较大或较小的元素进行比较
2.
如果建大堆:父节点值比子节点的值小则交换
如果建小堆:父节点值比子节点的值大则交换
3.继续向下对比和交换,直到满足堆的性质或达到堆的末尾。
void AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
//假设法子节点的左节点小
int child= parent * 2 + 1;
while(child+1<n&&child<n)
{
if (a[child] > a[child + 1])
{
child++;
}
if (a[parent] > a[child])
{
swap(&a[parent],&a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
3.3堆的创建
下面我们随便创建一个数组,逻辑上看作一个完全二叉树,此时它并不是堆,我们怎么把它变成堆呢?
方法如下:
我们可以从倒数第一个非叶子节点开始,依次向上,进行向下调整算法,直到调整到根节点为止,就可以调成一个堆。
举例如下:
3.4建堆的时间复杂度
因为堆是完全二叉树,而满二叉树又是完全二叉树的一种,所以我们以完全二叉树为例子分析更容易。
首先我们通过向下调整建堆:
由此可知向下调整建堆的时间复杂度为O(n)
我们在通过向上调整建堆分析:
我们发现,向上调整建堆:节点多时需要向上调整的层数多,而向下调整:节点数少时向下调整的层数多,依靠此分析我们可知向下调整建堆的时间复杂度最低。
3.5堆的插入
1.先将元素插入堆的末尾,即最后一个孩子之后。
2.如果插入的元素破坏了堆的性质,则进行向上调整。
3.6堆的删除
堆的删除就是删除堆顶的元素,将堆顶的元素与最后一个元素进行交换,删除最后一个元素,然后再用向下调整建堆恢复堆的性质。
3.7堆的代码实现
//堆的初始化
void HeapInit(Hp* php)
{
assert(php);
php->_a = NULL;
php->_capacity =php->_size = 0;
}
// 堆的销毁
void HeapDestory(Hp* php)
{
assert(php);
free(php->_a);
php->_a=NULL;
php->_capacity = php->_size = 0;
}
//交换两个元素
void swap(HPDataType* p1, HPDataType* p2)
{
int 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 HeapPush(Hp* php, HPDataType x)
{
assert(php);
if (php->_capacity == php->_size)
{
int newcapacity = php->_capacity == 0 ? 4 : php->_capacity * 2;
HPDataType* tmp = (HPDataType*)realloc(php->_a, newcapacity * sizeof(HPDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
php->_a = tmp;
php->_capacity = newcapacity;
}
php->_a[php->_size] = x;
php->_size++;
AdjustUp(php->_a, php->_size-1);
}
//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
//假设法子节点的左节点小
int child= parent * 2 + 1;
while(child+1<n&&child<n)
{
if (a[child] > a[child + 1])
{
child++;
}
if (a[parent] > a[child])
{
swap(&a[parent],&a[child]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
// 堆的删除
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);
}
//堆排序
void HeapSort(int* a, int n)
{
// 降序,建大堆
// 升序,建小堆
/*for (int i = 1; i < n; i++)
{
AdjustUp(a, i);
}*/
//向下调整法建堆
for (int i = (n - 1 - 1) / 2; i >= 0; i--)
{
AdjustDown(a, n, i);
}
int end = n - 1;
while (end > 0)
{
swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
--end;
}
}
4.二叉树链式结构的实现
1.前置说明
在初学二叉树的链式结构时,为了能更快的学习二叉树的基础操作,我们简单的建立一个树,等掌握了二叉树后在反过来在研究二叉树的真正建立。
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
//创建节点
BTNode* BuyNode(int x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
perror("malloc fail");
}
node->data = x;
node->left = NULL;
node->right = NULL;
return node;
}
//构建一颗树
BTNode* CreatBinaryTree()
{
BTNode* node1 = BuyNode(1);
BTNode* node2 = BuyNode(2);
BTNode* node3 = BuyNode(3);
BTNode* node4 = BuyNode(4);
BTNode* node5 = BuyNode(5);
BTNode* node6 = BuyNode(6);
node1->left = node2;
node1->right = node4;
node2->left = node3;
node4->left = node5;
node4->right = node6;
return node1;
}
2.二叉树的遍历
2.1前序、中序即后序遍历
1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。(根左右)
2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中(间)。(左根右)
3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后(左右根)
在理解二叉树的遍历时我们可以通过二叉树的图解来分析理解
一下是前序遍历递归图解:
中序和后序分析类似就不多做分析。
前序遍历结果:1 2 3 4 5 6
中序遍历结果:3 2 1 5 4 6
后序遍历结果:3 2 5 6 4 1
//前序遍历
void PrevOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
printf("%d ", root->data);
PrevOrder(root->left);
PrevOrder(root->right);
}
//中序遍历
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}
//后续遍历
void UndOrder(BTNode* root)
{
if (root == NULL)
{
printf("N ");
return;
}
UndOrder(root->left);
UndOrder(root->right);
printf("%d ", root->data);
}
2.2层序遍历
层序遍历:除了先序遍历、中序遍历、后序遍历外,还可以对二叉树进行层序遍历。设二叉树的根结点所在 层数为1,层序遍历就是从所在二叉树的根结点出发,首先访问第一层的树根结点,然后从左到右访问第2层 上的结点,接着是第三层的结点,以此类推,自上而下,自左至右逐层访问树的结点的过程就是层序遍历。
3.
目录
二叉树中常见问题
//求节点个数
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;
}
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);
}
//二叉树查找值
BTNode* TreeFind(BTNode* root, int 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;
}