堆与二叉树的相爱相杀
这里写目录标题
- 前言
-
- 什么是树
- 树中包括了什么、
- 什么是二叉树
-
- 二叉树的介绍
- 二叉树的定义
-
- 什么是前序、中序、尾序
- 怎么计算二叉树中节点个数、叶子节点个数、高度
- 查找二叉树有没有为x的节点、销毁二叉树
- 什么是堆
-
- 小堆
- 大堆
- 堆的实现
-
- 堆的定义
- 堆中的接口
- 堆中初始化和销毁
- 交换
- 向上调整、向下调整
- 堆的插入与删除
- 堆顶与判断堆为不为空与打印堆
- 堆排序
-
- 堆排序的时候要取大堆（建小堆 取小的可能不是堆了）
- 找堆中前K个最大的数据
- 什么叫深度优先遍历与广度优先遍历
-
- 深度优先遍历
- 广度优先遍历
前言
什么是树
树中包括了什么、
节点的度:一个节点的子节点
叶子节点: 度为0的节点/没有子节点的节点
非终端节点: 度不为0的节点
父节点:一个节点有分支节点， 这个节点就叫 分支节点的 父节点
子节点:由一个节点分裂的节点 叫 子节点
兄弟节点: 相同的父节点的节点
树的度:一颗树中最大节点的度 就叫树的度
树的高度/深度： 树中节点最大的层次
节点的祖先：从该节点到所经过分支上的所有节点
森林：由m颗树但互不相交的多颗树
什么是二叉树
二叉树的介绍
二叉树:每一个父节点只有2个子节点
任何一颗二叉树:其度为0的节点个数为N个，度为2的节点个数为M个，则有 N=M+1;
二叉树中的特例：完全二叉树
完全二叉树：高度为H的树中前 h-1层都是满的 最后一层不满，但是从左往右是连续存在节点的
满二叉树：每一层都是满的 上图显示的是就是完全二叉树
二叉树的定义
我们使用左孩子，右兄弟的方法定义二叉树
typedef char BTDataType;
typedef struct BinaryTreeNode
{
struct BinaryTreeNode* left;//左孩子
struct BinaryTreeNode* right;//右孩子
BTDataType data;
}BTNode;
什么是前序、中序、尾序
前序：先遍历根，然后遍历左子树，然后遍历右子树
void PrevOrder(BTNode* root)//前序 二叉树
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%c ", root->data);
PrevOrder(root->left);//左子树递归 递归到NULL时返回到上一个递归的调用
PrevOrder(root->right);
}
中序：先遍历左子树，然后遍历根，然后遍历右子树
void InOrder(BTNode* root)//中序
{
if (root == NULL)
{
printf("NULL ");
return;
}
InOrder(root->left);
printf("%c ", root->data);
InOrder(root->right);
}
尾序：先遍历左子树，然后遍历右子树，然后遍历根
void PostOrder(BTNode* root)//尾序
{
if (root == NULL)
{
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%c ", root->data);
}
怎么计算二叉树中节点个数、叶子节点个数、高度
节点个数：算出左子树的个数加上右子树的个数+1（这里的1是根）
int TreeSize(BTNode*root)//计算节点个数
{
return root == NULL ? 0 : TreeSize(root->left) + TreeSize(root->right) + 1;//左子树个数+右子树个数+1
}
叶子节点个数:左子树为NULL且右子树为NULL才为叶子节点
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);
}
高度：左子树和右子树比大小谁大谁+1
int TreeHeight(BTNode* root)
{
if (root == NULL)
{
return 0;
}
int a = TreeHeight(root->left);
int b = TreeHeight(root->right);
//return fmax(TreeHeight(root->left), TreeHeight(root->right)) + 1;
return a > b ? a + 1 : b + 1;
}
查找二叉树有没有为x的节点、销毁二叉树
查找节点：
先在左子树找，如果有返回那个节点的，如果没有则在右子树找，右子树有则返回节点，
没有则返回空
（返回的时候要用变量来保存，不然返回时值会被下一次查找覆盖）
BTNode* TreeFind(BTNode* root, BTDataType x)//二叉树查找值为x的节点
{
if (root == NULL)//如果找到了 在左子树 但是还是要走右子树 右子树进入返回来一个空
{
return NULL;
}
if (root->data == x)
{
return root;
}
BTNode* ret = NULL;
ret = TreeFind(root->left, x);
if (ret)
{
return ret;
}
return TreeFind(root->right, x);
}
销毁二叉树:先释放左子树，然后释放右子树，然后释放根
void TreeDestory(BTNode* root)//销毁程序
{
if (root == NULL)
{
return;
}
TreeDestory(root->left);
TreeDestory(root->right);
free(root);
}
什么是堆
堆：非线性表，完全二叉树
堆：底层：
物理结构：数组
逻辑勾结：完全二叉树
小堆
小堆：树中任意一个父亲都<=孩子
大堆
大堆：树中任意一个父亲都>=孩子
堆的实现
堆的定义
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
堆中的接口
void Swap(HPDataType* p1, HPDataType* p2);//交换函数
void HeapInit(HP* php);//初始化
void HeapDestory(HP* php);//销毁
void HeapPush(HP* php,HPDataType x);//插入
void HeapPrint(HP* php);//打印
void HeapPop(HP* php);//删除
HPDataType HeapTop(HP* php);//堆顶
bool HeapEmpty(HP* php);//判断为不为空堆
void AdjustUP(HPDataType* a, int child);//向上调整 小堆
void AdjustDown(HPDataType* a, int n, int parent);//向下调整
堆中初始化和销毁
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)
{
HPDataType tmp = *p1;
*p1 = *p2;
*p2 = tmp;
}
向上调整、向下调整
完全二叉树相当于一个数组
向上调整：因为堆可以看成一个数组，父节点的下标=（子节点-1）/2，
如果子节点比父节点小那么交换（小堆），大堆则改小于成大于
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 AdjustDown(HPDataType* a, int n, int parent)//向下调整
{
int child = parent * 2 + 1;
while (child < n)//确保这个子树的下标 小于数组大小
{
if (child + 1 < n&&a[child + 1] < a[child])//child+1这个右子树不存在那么 则直接输出左子树
//假设做孩子小 如果比右孩子小的话 ++换成右孩子
{
++child;
}
if (a[child] < a[parent])//小孩比父亲大那么交换（大堆）
//小的孩子比 父亲小 那么交换（小堆）
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
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, sizeof(HPDataType)* newCapacity);
if (tmp == NULL)
{
perror("relloc fail");
exit(-1);
}
php->a = tmp;
php->capacity = newCapacity;
}
php->a[php->size] = x;
php->size++;
AdjustUP(php->a, php->size - 1);
}
删除：先让尾节点跟根交换，然后让有效长度–，最后向下调整让整个二叉树成为堆
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);
}
堆顶与判断堆为不为空与打印堆
堆顶：
HPDataType HeapTop(HP* php)//堆顶
{
assert(php);
assert(php->size > 0);
return php->a[0];
}
判断为不为空：
bool HeapEmpty(HP* php)
{
assert(php);
return php->size != NULL;
}
打印：
void HeapPrint(HP* php)//打印
{
assert(php);
for (size_t i = 0; i < php->size; i++)
{
printf("%d ", php->a[i]);
}
printf("\n");
}
堆排序
堆排序的时候要取大堆（建小堆 取小的可能不是堆了）
向上调整（缺点时间复杂度为O（N*logN））：
for (int i = 1; i < n; i++)//向上调整
{
adjustup(a, i);
}
向下调整（时间复杂度为O（N））
int end = n - 1;
for (int i = (end-1)/2; i >=0; i--)//i= 父亲节点
{
adjustdown(a, i, 0);
}
排序完之后 再向下调整（时间复杂度为O（N*logN））
while (end >0)
{
swap(&a[0], &a[end]);
adjustdown( a, end, 0);
end--;
}
找堆中前K个最大的数据
void PrintTopk(int* a, int n, int k)
{
if (a == NULL)
{
perror("a fail");
return;
}
int* minheap = (int*)malloc(sizeof(int) * k);
if (minheap == NULL)
{
perror("malloc fail");
return;
}
//保存前k个数据
for (int i = 0; i < k; i++)
{
minheap[i] = a[i];
}
for (int i = (k - 2) / 2; i >= 0; i--)//建小堆
{
AdjustDown(minheap, k, i);
}
/*int end = k - 1;*/
//while (end >0)//向下调整
//{
// Swap(&minheap[0], &minheap[end]);
// AdjustDown( minheap, end, 0);
// end--;
//}
int x = 10;
while (x<=100)
{
if(a[x] > minheap[0])
{
minheap[0] = a[x];
AdjustDown(minheap, k,0);
}
x++;
}
int b = 0;
while (k--)
{
printf("%d ", minheap[k]);
}
}
void TestTopk()
{
int n = 100;
int* a = malloc(sizeof(int) * n);
srand(time(0));
for (int i = 0; i < n; i++)
{
a[i] = rand() % 100;
}
a[9] = 100 + 1;
a[19] = 100 + 2;
a[29] = 100 + 3;
a[39] = 100 + 4;
a[49] = 100 + 5;
a[59] = 100 + 6;
a[69] = 100 + 7;
a[79] = 100 + 8;
a[89] = 100 + 9;
a[99] = 100 + 10;
PrintTopk(a, n, 10);
}
int main()
{
//10亿个数据
//前k个最大的数
//k==100
//数组中存储前100个数建小堆
//如果堆顶的数据比剩下的数据下 则交换 再向下调整
//读完所有数据 ，堆中100个数是最大的前100个
//时间复杂度O(N*logK)
//空间复杂度(K)
TestTopk();
return 0;
}
什么叫深度优先遍历与广度优先遍历
深度优先遍历
完全二叉树中的前序就是深度优先遍历
广度优先遍历
完全二叉树中的层数遍历就是广度优先遍历