目录
前言
堆排序是一种使用堆数据结构的排序算法。堆是一种完全二叉树，且满足堆属性，即每个节点的值都大于（或小于）它的子节点的值。
二叉树的遍历有三种方式：前序遍历、中序遍历、后序遍历。这三种遍历方式都是深度优先遍历。
一、堆排序
1.概念
堆排序是一种基于堆数据结构实现的排序算法。它将待排序的序列构建成一个大顶堆（或小顶堆），然后依次取出堆顶元素，将其与最后一个元素交换位置，并不断调整堆使其重新满足堆的性质，最终得到一个有序的序列。
2.堆排序思想
堆排序即利用堆的思想来进行排序，总共分为两个步骤：
1. 建堆
升序：建大堆
降序：建小堆
注意：升序排列时，并不是建小堆，而是建大堆，堆排列都是从后往前排的，如果建小堆还需要多次交换数组。
建堆时可以使用向上调整也可以使用向下调整，但是向上调整的时间复杂度更高为Nlog(N)，而向下调整建堆的时间复杂度更低，为N，所以采用向下调整建堆。
2. 利用堆删除思想来进行排序
建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
3.具体步骤
- 构建初始堆：将待排序序列构建成一个大顶堆。从最后一个非叶子节点开始，依次对每个节点进行调整，使其满足大顶堆的性质（父节点的值大于子节点的值）。
- 交换堆顶元素和最后一个元素：将堆顶元素与最后一个元素交换位置，并缩小堆的范围（即去掉最后一个元素）。
- 调整堆：对交换后的堆进行调整，使其重新满足大顶堆的性质。
- 重复步骤2和3，直到堆的范围缩小至1，即所有元素都已经排序完成。
4.实现
//左右子树都是大堆或者小堆
void ADjustDown(HPDataType* a, int sz, int parent)
{
int child = parent * 2 + 1;
while (child < sz)
{
//选出左右孩子中大的一个
//这里child+1的判断在前，不要先访问再判断
//这里a[child + 1] > a[child] 建大堆用>， 建小堆用<
if (child + 1 < sz && a[child + 1] < a[child])
{
//这地方可能会越界
++child;
}
//这里a[child] > a[parent] 建大堆用>， 建小堆用<
if (a[child] < a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void HeapSort(int* a, int sz)
{
//1.建堆 -- 向上调整建堆 NlogN
//左右子树必须是大堆/小堆
/*for (int i = 1; i < sz; i++)
{
ADjustUp(a, i);
}*/
//2.向下调整建堆 N
//左右子树必须是大堆/小堆
for (int i = (sz - 1 -1) / 2; i >= 0; i--)
{
ADjustDown(a, sz, i);
}
int end = sz - 1;
while (end > 0)
{
Swap(&a[end], &a[0]);
ADjustDown(a, end, 0);
--end;
}
}测试代码：
int main()
{
int a[10] = { 2, 1, 5, 4, 7, 9, 8, 3, 6, 0};//对数组排序
int sz = sizeof(a) / sizeof(a[0]);
HeapSort(a, sz);
for (int i = 0; i < sz; i++)
{
printf("%d ", a[i]);
}
return 0;
}测试结果：
5.复杂度
堆排序的时间复杂度为O(nlogn)，其中n为待排序序列的长度。堆排序是一种原地排序算法，不需要额外的存储空间，但由于堆的构建过程需要占用一定的空间，所以它并不是稳定的排序算法
二、堆的应用——TopK问题
TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：
-
用数据集合中前K个元素来建堆
-
前k个最大的元素，则建小堆
-
前k个最小的元素，则建大堆
-
-
用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
typedef int HPDataType;
typedef struct Heap
{
HPDataType* a;
int size;
int capacity;
}HP;
void ADjustDown(HPDataType* a, int sz, int parent)
{
int child = parent * 2 + 1;
while (child < sz)
{
//选出左右孩子中大的一个
//这里child+1的判断在前，不要先访问再判断
//这里a[child + 1] > a[child] 建大堆用>， 建小堆用<
if (child + 1 < sz && a[child + 1] > a[child])
{
//这地方可能会越界
++child;
}
//这里a[child] > a[parent] 建大堆用>， 建小堆用<
if (a[child] > a[parent])
{
Swap(&a[child], &a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void PrintTopk(const char* file, int k)
{
//1.建堆 -- 用a中的前k个元素建小堆
int* topk = (int*)malloc(sizeof(int) * k);
assert(topk);
FILE* fout = fopen(file, "r");
if (fout == NULL)
{
perror("fopen error");
return;
}
//读出前k个数据建小堆
for (int i = 0; i < k; i++)
{
fscanf(fout, "%d", &topk[i]);
}
for (int i = (k - 1 - 1) / 2; i >= 0; i--)
{
ADjustDown(topk, k, i);
}
//2.将剩余n-k个元素依次与堆顶元素交换，不满则替换
int val = 0;
int ret = fscanf(fout, "%d", &val);
while (ret != EOF)
{
if (val > topk[0])
{
topk[0] = val;
ADjustDown(topk, k, 0);
}
ret = fscanf(fout, "%d", &val);
}
for (int i = 0; i < k; i++)
{
printf("%d ", topk[i]);
}
printf("\n");
free(topk);
topk = NULL;
}
void CreatNData()
{
//造数据
int n = 10000;
srand((unsigned int)time(0));
const char* file = "data.txt";
FILE* fin = fopen(file, "w");
if (fin == NULL)
{
perror("fopen error");
return;
}
for (size_t i = 0; i < n; ++i)
{
int x = rand() % 10000;
fprintf(fin, "%d\n", x);
}
fclose(fin);
}
int main()
{
// 在测试时可以先运行第一个函数，创造好数据，
// 然后修改k条数据，再运行第二步，在监视窗口观察
CreatNData();
PrintTopk("data.txt", 10);
return 0;
}三、链式二叉树
只有完全二叉树的实现使用数组比较方便，因为很少造成空间浪费。其他二叉树使用链式结构更节省空间，但是由于链式二叉树的构造比较麻烦，所以这里只介绍链式二叉树的遍历。
1.二叉树创建
在操作二叉树前，需要创建一颗二叉树，这里为了简单直接手动创建一颗二叉树
typedef int BTDataType;
typedef struct BinaryTreeNode
{
BTDataType data;
struct BinaryTreeNode* left;
struct BinaryTreeNode* right;
}BTNode;
BTNode* BuyNode(BTDataType x)
{
BTNode* node = (BTNode*)malloc(sizeof(BTNode));
if (node == NULL)
{
perror("malloc fail");
return NULL;
}
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);
//BTNode* node7 = BuyNode(7);
node1->left = node2;
node1->right = node4;
node2->left = node3;
node4->left = node5;
node4->right = node6;
//node2->right = node7;
return node1;
}2.二叉树遍历
学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的结点进行相应的操作，并且每个结点只操作一次。访问结点所做的操作依赖于具体的应用问题。 遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
1）前序、中序以及后序遍历
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：
-
前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
-
中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
-
后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。
由于被访问的结点必是某子树的根，所以N(Node）、L(Left subtree）和R(Right subtree）又可解释为根、根的左子树和根的右子树。NLR、LNR和LRN分别又称为先根遍历、中根遍历和后根遍历。
前序遍历图示：
前序遍历实现：
void PreOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
printf("%d ", root->data);
PreOrder(root->left);
PreOrder(root->right);
}前序遍历递归图示：
后序遍历实现：
void InOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
InOrder(root->left);
printf("%d ", root->data);
InOrder(root->right);
}后序遍历：
void PostOrder(BTNode* root)
{
if (root == NULL)
{
printf("NULL ");
return;
}
PostOrder(root->left);
PostOrder(root->right);
printf("%d ", root->data);
}前序遍历结果：1 2 3 4 5 6
中序遍历结果：3 2 1 5 4 6
后序遍历结果：3 2 5 6 4 1
2）层序遍历
设二叉树的根结点所在层数为1，层序遍历就是从所在二叉树的根结点出发，首先访问第一层的树根结点，然后从左到右访问第2层上的结点，接着是第三层的结点，以此类推，自上而下，自左至右逐层访问树的结点的过程就是层序遍历。
层序遍历的实现可以借助队列，利用队列先进先出的特点，如果根不为空，就入队；如果左子树或右子树不为空就入队，直到队列为空。
void LevelOrder(BTNode* root)
{
Queue q;
QueueInit(&q);
if (root != NULL)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
printf("%d ", front->data);
if (front->left)
{
QueuePush(&q, front->left);
}
if (front->right)
{
QueuePush(&q, front->right);
}
}
printf("\n");
QueueDestory(&q);
}3.结点个数以及高度
1）结点个数：
注意：节点个数的返回，如果是要返回变量一定要注意，函数栈帧的会存储各自的变量，因此最好传入变量地址。
下面介绍不传变量的写法：
//分治思想
int TreeSize(BTNode* root)
{
return root == NULL ? 0 :
TreeSize(root->left)
+ TreeSize(root->right)
+ 1;
}2）结点高度
要进行结点的递归比较时，存储变量值可以极大的提高效率
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;
}3）二叉树第K层结点的个数
根结点为第一层
当前树的第k层个数=左子树的第k-1层个数 +左子树的第k-1层个数
int TreeLevelK(BTNode* root, int k)
{
assert(k > 0);
if (root == NULL)
{
return 0;
}
if (k == 1)
{
return 1;
}
return TreeLevelK(root->left, k - 1)+TreeLevelK(root->right, k - 1);
}4）查找值为x的结点
BTNode* BinaryTreeFind(BTNode* root, BTDataType x)
{
if (root == NULL)
{
return NULL;
}
if (root->data == x)
{
return root;
}
BTNode* lret = BinaryTreeFind(root->left, x);
if (lret)
{
return lret;
}
BTNode* rret = BinaryTreeFind(root->right, x);
if (rret)
{
return rret;
}
//左右树都没有，返回空
return NULL;
}4. 判断二叉树是否为完全二叉树
完全二叉树按层序走，非空节点一定是连续的。
bool TreeComplete(BTNode* root)
{
Queue q;
QueueInit(&q);
//为空则不入
if (root)
{
QueuePush(&q, root);
}
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
if (front == NULL)
{
break;
}
else
{
QueuePush(&q, front->left);
QueuePush(&q, front->right);
}
}
//判断是不是完全二叉树
while (!QueueEmpty(&q))
{
BTNode* front = QueueFront(&q);
QueuePop(&q);
//后面有非空，说明非空结点不是完全连续
if (front)
{
QueueDestory(&q);
return false;
}
}
QueueDestory(&q);
return true;
}5.二叉树的销毁
采用后序遍历，不用存储根结点的位置。
void TreeDestory(BTNode* root)
{
if (root == NULL)
{
return;
}
TreeDestory(root->left);
TreeDestory(root->right);
free(root);
}总结
- 堆排序的基本思想是先将待排序的序列构建成一个最大堆（或最小堆），然后将根节点与最后一个节点交换，再将剩下的 n-1 个节点重新构建成一个最大堆（或最小堆），如此循环，直到所有节点都被交换到适当的位置，从而得到一个有序序列。
- 前序遍历先访问根节点，然后递归地前序遍历左子树，再递归地前序遍历右子树。
- 中序遍历先递归地中序遍历左子树，然后访问根节点，再递归地中序遍历右子树。
- 后序遍历先递归地后序遍历左子树，然后递归地后序遍历右子树，最后访问根节点。
- 二叉树的遍历时间复杂度均为 O(n)，其中 n 是二叉树的节点数量。
扫一扫
876
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
