目录
一、树概念及结构
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;
}
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
