博客介绍了树和二叉树的概念、结构与性质，阐述了二叉树的顺序和链式存储结构。重点讲解了堆的概念、结构及实现，包括创建、初始化、插入、删除等操作。还介绍了堆排序的三种版本，分析了各版本的思路、优缺点及实现方法。
一、树的概念
我们都知道栈和队列是线性的数据结构。
既然有线性数据结构，那么有没有非线性的数据结构呢？
当然是有的，树就是一种非线性的数据结构
因此，树是递归定义的
相关概念
typedef int DataType;
struct Node
{
struct Node* firstChild; // 第一个孩子结点
struct Node* pNextBrother; // 指向其下一个兄弟结点
DataType _data; // 结点中的数据
};
每个节点都指向一个孩子节点(最左边的第一个孩子)
还指向自己右边的兄弟节点
如上图，树从根节点开始，指向自己最左边的孩子节点
让孩子节点去找自己的兄弟节点(每个节点都有指向兄弟节点的指针)
当节点指向的孩子节点为NULL时则说明本节点为叶子节点(上图E、F、C、D为叶子节点)
根据上面的思想我们可以得出遍历这颗树的代码
TreeNode* Anode;
TreeNode* child = Anode->firstchild;
while(child)
{
printf("%d ",child->val);
child = child->pnextbrother;
}
二、二叉树的概念和结构
2.1二叉树的概念
以下是一棵二叉树的图
由上图可以看出:
二叉树不存在度大于2的节点(最多两个孩子，也就是可以1个或者没孩子)
二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树
注意:对任意的二叉树都是由以下几种情况复合而成的:
2.2特殊的二叉树
2.3二叉树的性质
2.4 二叉树的存储结构
(1)顺序结构
(2)链式结构
二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。
链表中每个结点由三个变量组成，数据和左右指针，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。链式结构又分为二叉链和三叉链，三叉链有多了个指向父节点的指针
三、二叉树的顺序结构及实现
3.1 二叉树的顺序结构
3.2 堆的概念及结构
堆的概念
一种非线性结构的完全二叉树
把它的所有元素按完全二叉树的顺序存储方式存储在一个一维数组中
底层 堆的物理结构是数组 逻辑结构是完全二叉树
堆有两种：大堆和小堆
小堆：树中任意一个父亲都<=孩子(指的是值)，
大堆：树中任意一个父亲都=>孩子
其中根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆
3.3堆的实现
(1)堆的创建和初始化
堆的创建
完全二叉树适合用数组来实现，结构体需要创建一个数组a
size用来计算有效数据个数(也可以充当下标)
capacity为容量，判断数组是否满了，需不需要扩容
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}Heap;
初始化堆
将结构体里的数组置空，有效数据个数和容量置为0
//初始化
void HeapInit(HP* hp)
{
assert(hp);
hp->a = NULL;
hp->capacity = 0;
hp->size = 0;
}
(2)堆的销毁
释放数组a的空间，然后置空
容量和有效个数置为0
void HeapDestory(HP* hp)
{
assert(hp);
free(hp->a);
hp->a = NULL;
hp->capacity = 0;
hp->size = 0;
}
(3)堆的插入
堆和顺序表都是用数组实现的，插入也可以采用顺序表的尾插
插入时需要考虑到数组的容量是否足够容纳数据，不够则需要扩容(也就是判断是否扩容)
由于前面初始化是没有开辟空间，我们需要判断走到这时容量是否为0(之前有没有开辟空间)
可以创建一个新的变量newcapacity，用三目操作符如果之前的容量为0，就给一个常数作为初始容量，否则扩容为原来的两倍。扩容完把要插入的数据插入，有效元素个数(下标)++
void HeapPush(HP* hp, HPDataType x)
{
assert(hp);
//判断是否需要扩容
if (hp->size == hp->capacity)
{
//判断之前的容量是否为0
int newcapacity = hp->capacity == 0 ? 4 : hp->capacity * 2;
//扩容
HPDataType* tmp = (HPDataType*)realloc(hp->a,sizeof(HPDataType) * newcapacity);
if (tmp == NULL)
{
perror("realloc fail");
exit(-1);
}
hp->a = tmp;
hp->capacity = newcapacity;
}
//增加数据
hp->a[hp->size] = x;
hp->size++;
AdjustUp(hp->a,hp->size - 1);
}
你没办法保证每次数据插入数组正好满足堆的条件，所以我们需要对其进行调整
这里用到了向上调整的算法AdjustUp
而向上调整的前提是:该数组原来是大堆或者小堆，所以我们需要在每次插入后进行调整
要从最后一个叶子节点开始向上调整。以建小堆为例 ，父节点要比子节点小
如果插入的值比父节点的值要小，交换插入的值与其父节点的值，依次向上判断
那么如何找到父节点呢？
其实上面我们有提过一个公式parent = (child-1)/2
当然调整不可能只调整一次，最坏情况下，比如：上面插入的不是50而是5(插入值比根还小)
则需要调整到根节点，这里可以用循环解决
当孩子>0就进入循环，孩子节点的值小于其父节点的值和我们上面说的那样交换 再往上走(孩子节点=之前的父节点，孩子现在的父节点=之前父节点的父节点)
否则说明孩子的值(插入的数)>=父节点的值，那就跳出循环
或者孩子=0也就是走到根位置时就跳出循环
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 = (parent - 1) / 2;
}
else
{
break;
}
}
}
(4)堆的删除
删除谁比较有意义呢？小堆有一个特点堆顶的值是堆的最小值，所以删除堆顶比较有意义
可是如果用头删的话每次删除都要挪动很多数据
我们可以换一个思路:将堆顶元素和最后一个元素交换，然后再尾删
但是删除后堆顶元素的大小就不确定了，现在的数组不一定是小堆
所以我们需要另外一个算法:向下调整
向下调整的前提是左右子树都是小堆/大堆
删除的时候左子树和右子树没有改变堆的性质(还是小堆)
所以我们可以使用前面的公式
左孩子：child = parent * 2+1 右孩子：child = parent * 2+2
当然size=0(数组里面没东西)就不用删了，所以最开始我们需要断言一下
void HeapPop(HP* hp)
{
assert(hp);
assert(hp->size > 0);
Swap(&hp->a[0], &hp->a[hp->size - 1]);
--hp->size;
AdjustDown(hp->a, hp->size,0);
}
刚才向上调整是从最后一个节点开始向上调整；向下调整正好相反，是从堆顶元素开始向下调整
向上调整的公式是parent = (child-1)/2
那么问题来了，一个孩子只能有一个父亲
而一个父亲可不止有一个孩子
该选择那个呢？
这里我们可以默认选择左孩子，然后再加一个判断变成选择左右孩子中小的那一个
循环当孩子走到数组尾就停下来
孩子小于父亲就交换
不然就跳出循环
void AdjustDown(HPDataType* a, int n, int parent)
{
int child = parent * 2 + 1;
//child走到n(数组尾)就停下来
while (child < n)
{
//找兄弟中小的那个
if ( child + 1 < n && a[child + 1] < a[child])//小心数组越界访问
{
++child;
}
//如果孩子小于父亲就交换
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
//不然就跳出循环
else
{
break;
}
}
}
(5)获取堆顶元素和元素个数以及堆的判空
获取堆顶元素要注意数组没东西就别获取了，记得开头断言一下
其实就是获取数组首元素
HPDataType HeapTop(HP* hp)
{
assert(hp);
assert(hp->size > 0);
return hp->a[0];
}
堆的元素个数
返回size
// 堆的数据个数
int HeapSize(HP* hp)
{
assert(hp);
return hp->size;
}
判断堆是否为空
为空为真，非空为假
bool HeapEmpty(HP* hp)
{
assert(hp);
return hp->size == 0;
}
四、堆排序
4.1堆排序版本1
思路：
把数据一个个插入堆中
然后一值取堆顶(堆顶是最大/最小元素)，取完删除堆顶，一直循环直到堆顶的位置为空
void HeapSort(int* a,int n)
{
HP hp;
HeapInit(&hp);
for(int i=0;i<n;i++)
{
HeapPush(&hp,a[i]);
}
int i = 0;
while(!HeapEmpty(&hp))
{
a[i++]=HeapTop(&hp);
HeapPop(&hp);
}
HeapDestroy(&hp);
}
这种写法的缺点
1.得先有一个堆的数据结构
2.频繁扩容空间复杂度的消耗大
4.2优化版本2
数组有开辟空间，就着原先的空间用(也就是说数组原地排序)
把一个数组看成一个完全二叉树(不可能每次刚好都是堆)
那就把它搞成堆(建堆)
那升序应该建大堆还是建小堆呢
如果建的是小堆，堆顶确实是最小的
选完最小的之后要选次小的，那么只能将后面的值看作堆
然后绝大多数情况下堆的关系就全乱了，剩下的数据不一定是堆
那么这个时候怎么办，我们只能重新建堆，这样时间复杂度就变大了，效率也底
所以升序最好的方法是建大堆(同理降序建小堆)，用删除的思想
堆顶跟最后一个数交换，最大的数就排好了
不是真的要把最后一个元素删除，把最后一个数不看做堆里面的
end指向最后一个数
剩下的数据还是大堆，那么就可以向下调整，选出次大的数(堆顶)
end--，end指向倒数第二的数，堆顶和倒数第二的数交换，如此反复，直到end走到堆顶跳出循环
void HeapSort(int* a,int n)
{
//建大堆(升序)
for(int i=1;i<n;i++)
{
AdjustUp(a,i);
}
int end = n-1;
while(end > 0)
{
Swap(&a[0],&a[end]);
AdjustDown(a,end,0);
--end;
}
}
4.3版本3
堆排序也可以只用向下调整建堆
和向上调整不同，它是从最后一棵树倒着往前去调整，而叶子节点没有必要去调整
叶子节点只有一个节点，我们既可以看作小堆也可以看作大堆
所以要从倒数第一个非叶子节点开始，也就是最后一个节点的父节点(n-1-1)/2，一直走到根位置
void HeapSort(int*a,int n)
{
assert(a);
//建堆
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--;
}
}
扫一扫
1343
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
