树
树是一种数据结构，它是由n(n≥0)个有限节点组成一个具有层次关系的集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。第一个节点被称为根节点。
树是递归定义的。树可以分为根和子树，子树又被分为根和子树。
树的子树是不相交的。
树的概念
根节点：最上面的第一个节点。A是根节点。
节点的度：一个节点子树的个数。A的度是2，B的度是3。
树的度：树中的节点最大的度。树中最大的度是B的度，B的度是3，树的度是3。
节点的层次：从根开始定义，根为第一层，根的子节点为第二层，逐层递增。A是第一层，B是第二层，C是第三层。
树的高度或深度：树的最大层次。
叶节点或终端节点：度为0的节点。D、E、F、G、H。
分支节点或非终端节点：度不为0的节点。A、B、C。
父节点：分支节点有该节点的节点。A的分支节点有B，B的父节点是A。
子节点：节点的分子节点。A的分子节点有C，C是A的子节点。
兄弟节点：具有共同父节点的节点。B、C的父节点是A，B、C是兄弟节点。
堂兄弟节点：父节点在同一层的节点为堂兄弟节点。D、和G、H是堂兄弟节点。
节点的祖先：从根节点到该节点的所有节点。D的祖先的B和A。
子孙：以某节点为根的子树中任一节点都被称为该节点的子孙。
森林：由m（m >= 0）棵互不相交的数的合集称为森林。
树的表示
树的表示形式有很多种，其中孩子兄弟表示法比较简单。孩子兄弟表示法：左孩子右兄弟，存储第一个孩子的节点和兄弟节点。
typedef int DataType;
typedef struct TreeNode
{
DataType x;
struct TreeNode* child;
struct TreeNode* brother;
}TreeNode;二叉树
二叉树是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为：二叉树是一棵空树；或者是一个根节点加上两棵别称为左子树和右子树的二叉树，左子树和右子树又同样都是二叉树。
二叉树的子树有左右之分，次序不能颠倒。
满二叉树
一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是 ，则它就是满二叉树。
每一层都是满的，即第n层的节点数是2^(n-1)个。
完全二叉树
效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树，即每一个节点是连续的存储的。要注意的是满二叉树是一种特殊的完全二叉树。
完全二叉树如果这个节点有右孩子，那么这个节点一定有左孩子。
二叉树性质
在非空⼆叉树中，第i层的结点总数不超过2^(i-1)。
深度为h的⼆叉树最多有2^h-1个结点(h>=1)，最少有h个结点，全是左孩子或者右孩子。
度为0的叶节点个数为n0，度为2的节点个数为n2，有规律为：n0 = n2 + 1。 即度为0的叶节点个数比度为2的节点个数多一个。
二叉树的顺序结构
顺序存储
数据连续存储，如果没有节点需要空出位置，即如果2没有左孩子，4的位置要空出来。完全二叉树和满二叉树用顺序存储比较好。
通过下标计算父子关系。
leftchild = parent * 2 + 1。左孩子等于父亲的下标乘2再加1。
rightchild = parent * 2 + 2。右孩子等于父亲的下标乘2再加2。
parent = (child - 1) / 2 。父亲统一使用孩子减1的差再除2。
堆
堆是一个完全二叉树。堆中的父节点全都大于等于孩子或者父节点全部小于等于孩子。父节点全都大于等于孩子叫做大堆（大根堆），大堆中的第一个数据是堆中的最大数据；父节点全都小于等于孩子叫做小堆（小根堆），小堆中的第一个数据是堆中最小数据。并不是说数组是降序或者升序，而是父节点和孩子节点之间的关系。
堆的实现
使用顺序存储实现堆，分模块写。一个头文件Heap.h放头文件、结构体声明、函数声明。两个源文件Heap.c、Heap.c。Heap.c实现Heap.h声明的函数，即实现堆所使用的函数。test.c用来测试函数有没有问题，Heap.c文件中要包含头文件Heap.h。
Heap.h
#pragma once
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
#include <stdbool.h>
typedef int HDataType;
typedef struct Heap
{
HDataType* a;
int size;
int capacity;
}Heap;
// 初始化
void HeapInit(Heap* p);
// 打印堆数据
void HeapPrint(Heap* p);
// 插入
void HeapPush(Heap* p, HDataType x);
// 判断空
bool HeapEmpty(Heap* p);
// 删除
void HeapPop(Heap* p);
// 堆顶数据
HDataType HeapTop(Heap* p);
// 堆元素个数
int HeapSize(Heap* p);
// 销毁
void HeapDestroy(Heap* p);
// 交换数据
void Swap(HDataType* x, HDataType* y);
// 向上调整
void AdjustUp(HDataType* a, int child);
// 向下调整
void AdjustDown(HDataType* a, int size, int parent);
// 排序
void HeapSort(HDataType* a, int size);堆初始化
void HeapInit(Heap* p)
{
assert(p);
p->a = NULL;
p->size = p->capacity = 0;
}堆使用之前要初始化，避免对野指针进行操作。
打印堆数据
void HeapPrint(Heap* p)
{
assert(p);
for (int i = 0; i < p->size; ++i)
{
printf("%d ", p->a[i]);
}
printf("\n");
}插入数据
void HeapPush(Heap* p, HDataType x)
{
assert(p);
// 检查扩容
if (p->size == p->capacity)
{
// 扩容元素个数
p->capacity = p->capacity == 0 ? 4 : 2 * p->capacity;
p->a = (HDataType*)realloc(p->a, p->capacity * sizeof(HDataType));
if (p == NULL)
{
printf("realloc fail\n");
exit(-1);
}
}
p->a[p->size] = x;
p->size++;
// 向上调整数据，保证数据符合堆的结构
AdjustUp(p->a, p->size - 1);
}插入数据从数组的最后一个位置的下一个位置插入，每次插入数据都要判断是否符合堆的性质。堆中父节点存储的数据全都大于等于孩子存储的数据，或者父节点存储的数据全部小于等于孩子存储的数据。这里实现模拟实现小堆，父节点存储的数据全部小于等于孩子存储的数据。
数据的插入位置都是叶子节点，需要向上调整数据，只会影响它的祖先。如果孩子节点数据小于父节点数据，需要交换两个数据。
插入5之后，孩子节点下标是0，没有父节点，不需要调整；插入2的时候，孩子节点的数据是2，比父节点数据小，交换数据。
向上调整
// 交换数据
void Swap(HDataType* x, HDataType* y)
{
assert(x && y);
HDataType tmp = *x;
*x = *y;
*y = tmp;
}
// 向上调整
void AdjustUp(HDataType* a, int child)
{
assert(a);
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;
}
}
}当孩子节点没有父节点的时候结束，因为第一个数据不需要向上调整。如果孩子节点的数据小于父节点的数据，不符合小堆的性质，交换数据，把父节点的下标给孩子节点，再找这个孩子节点的父节点，进行下一次判断是否符合堆的性质，如果符合直接结束。
向上调整算法，是建立在堆的基础上的，使用之前必须是堆。
判堆是否为空
bool HeapEmpty(Heap* p)
{
assert(p);
return p->size == 0;
}如果没有数据的时候不能删除数据。
删除数据
void HeapPop(Heap* p)
{
assert(p);
assert(!HeapEmpty(p));
Swap(&(p->a[0]), &(p->a[p->size - 1]));
p->size--;
AdjustDown(p->a, p->size, 0);
}堆删除数据只能删除第一个数据（下标为0）。其它位置的删除对于堆而言是没有意义的。堆删除数据，不是将该位置的数据删除，将后面的数据往前移动，数据不再是堆，要重新建堆；而是将第一个数据和最后一个数据进行交换，size自减1，再将数据调整为堆，这时候需要向下调整算法，把第一个数据调整到符合堆性质的位置。
向下调整
void AdjustDown(HDataType* a, int size, int parent)
{
assert(a);
int child = parent * 2 + 1;
// 当没有孩子节点的时候，结束
while (child < size)
{
// 找到左右孩子中数据小的那个，先判断是否有右孩子
if (child + 1 < size && a[child + 1] < a[child])
++child;
// 如果孩子节点数据小于父节点数据，交换数据
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
// 孩子节点数据大于等于父节点数据， 结束
break;
}
}
}当父节点没有孩子节点的时候结束，因为叶子节点不需要向下调整。找父节点孩子节点中数据较小的节点。父节点有左孩子但是不一定有右孩子，需要对右孩子进行越界检查。
如果孩子节点的数据小于父节点的数据，不符合小堆的性质，交换数据，把孩子节点的下标给父节点，再找这个父节点的孩子，进行下一次判断是否符合堆的性质，如果符合直接结束。
向下调整算法是建立在左子树是堆，右子树也是堆的情况下使用的。
堆顶元素
HDataType HeapTop(Heap* p)
{
assert(p);
assert(!HeapEmpty(p));
return p->a[0];
}堆元素个数
int HeapSize(Heap* p)
{
assert(p);
return p->size;
}销毁
void HeapDestroy(Heap* p)
{
assert(p);
free(p->a);
p->a = NULL;
p->size = p->capacity = 0;
}堆排序
void HeapSort(HDataType* a, int size)
{
assert(a);
Heap h;
HeapInit(&h);
// 数据插入堆
for (int i = 0; i < size; ++i)
{
HeapPush(&h, a[i]);
}
// 删除堆数据，排序
while (!HeapEmpty(&h))
{
HeapPop(&h);
}
// 回写数据
for (int i = 0; i < size; ++i)
{
a[i] = h.a[i];
}
HeapDestroy(&h);
}堆排序数据，小堆排降序，大堆排升序。小堆的第一个元素是最小的，删除数据将第一个元素和最后一个元素交换，size自减一，最小的排在最后下标size的位置，向下调整，第一个元素又是堆中最小的，删除数据将第一个元素和最后一个元素交换，size自减一，最小的排在最后下标size的位置。
使用堆数据结构排序，需要创建一个堆的数据结构，空间复杂度是O(N)，排序完需要回写到数组中，复杂了。应该直接在数组上直接操作，使用向上调整或者向下调整建堆，排序数组。
void HeapSort(HDataType* a, int size)
{
assert(a);
// 向上调整建堆
//for (int i = 1; i < size; ++i)
//{
// AdjustUp(a, i);
//}
// 向下调整建堆
for (int i = (size - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, size, i);
}
int end = size - 1;
while (end > 0)
{
Swap(&a[0], &a[end]);
AdjustDown(a, end, 0);
end--;
}
}建堆有两种方法，向上调整建堆和向下调整建堆。向上建堆的时间复杂度是O(N*log(N))，向下建堆的时间复杂度是O(N)（可以查看一下如何计算）。所以使用向下建堆比较好。从最后一个叶子节点的父节点开始向下调整，size-1是下标，再-1的差除2是父节点下标。
建完堆的数组顺序。
建完堆，进行选数，每次选堆顶元素，将堆顶元素放在待排序元素集合的最后一个，第一个数据和最后一个数据交换，第一个数据向下调整，重复再堆顶选数，再调整，直到堆只剩下一个数据。
堆排序的时间复杂度是O(N*log(N))，是很快的排序算法。
大堆
修改向上调整和向下调整中的比较关系。
向上调整
if (a[child] > a[parent])向下调整
if (child + 1 < size && a[child + 1] > a[child])
if (a[child] > a[parent])TOP-K问题
在N个数中找前K个最大或最小的数，一般N非常大。例如世界上最高的十个人，世界500强公司等等。
直接排序，最后找k个。时间复杂度是O(N*log(N))。
建N个数的堆，删除数据k次。时间复杂度是O(N + K*log(N))，空间复杂度是O(N)。
如果N非常大，N是一亿个整形，存储在文件中，不能在内存中建N个元素的堆。如果要找前K个最大的数，建K个数的小堆，小堆的堆顶数据是最小的，如果数据比堆顶数据大，可以替换堆顶数据进堆，向下调整，剩下的N-K个数依次跟堆顶数据比较，最后堆的数据就是前K个最大的数，堆顶数据是第K大的数据。时间复杂度是O(K+(N-K)log(K))，空间复杂度是O(K)。
#include "Heap.h"
void TOP_K()
{
// 初始化数组
int arr[10000];
for (int i = 0; i < 10000; ++i)
{
arr[i] = rand() % 10000;
}
// 手动置前10个的大小
arr[10] = 10001;
arr[20] = 10002;
arr[30] = 10003;
arr[40] = 10004;
arr[50] = 10009;
arr[60] = 10008;
arr[70] = 10007;
arr[80] = 10006;
arr[90] = 10005;
arr[100] = 10000;
// 建10个元素的小堆
int* a = (int*)malloc(sizeof(int) * 10);
for (int i = 0; i < 10; ++i)
{
a[i] = arr[i];
}
for (int i = (10 - 1 - 1) / 2; i >= 0; --i)
{
AdjustDown(a, 10, i);
}
// 剩下10000-10个比较堆顶数据大小，向下调整
for (int i = 10; i < 10000; ++i)
{
if (arr[i] > a[0])
{
Swap(&arr[i], &a[0]);
AdjustDown(a, 10, 0);
}
}
// 打印堆数据
for (int i = 0; i < 10; ++i)
printf("%d ", a[i]);
printf("\n");
}
int main()
{
TOP_K();
return 0;
}
35万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
