C学习（数据结构）--＞实现顺序结构二叉树

。TAT。

于 2024-08-22 11:13:50 发布

阅读量571

点赞数 10

分类专栏：学习心得文章标签：数据结构 c语言学习

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/weixin_47298551/article/details/140606214

版权

学习心得专栏收录该内容

18 篇文章 0 订阅

订阅专栏

目录

一、堆的概念与结构

二叉树的性质

二、堆的实现

2、初始化与销毁

3、入堆与出堆（小堆）

1 数据的向上调整

1 数据的向下调整

1、入堆与出堆（大堆）

3、Top-K问题

四、总代码

一般堆使用顺序结构的数组来存储数据，堆是一种特殊的二叉树。具有二叉树的特性的同时，还具有其它的特性。

一、堆的概念与结构

如果有一个集合，把它所有的元素按完全二叉树的顺序存储方式存储，在一维数组中，并且每一个父节点小于它的孩子结点，则称这个完全二叉树为小堆，而称每一个父节点大于它的孩子结点的完全二叉树为大堆。

小堆

大堆

性质

根据以上可得，堆总是一棵完全二叉树，且堆中某个结点的值总是不大于或不小于父结点的值。

二叉树的性质

对于一个完全二叉树，按照从上至下从左至右的数组顺序对所有结点从0开始编号，那么对于序号为 i 的结点（i - 1）/ 2 对应的结点是它的父结点，2*i + 1 对应的结点是它的左孩子结点，2*i + 2 对应的结点是它的父结点

二、堆的实现

1、结构

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* arr;
	int size;//有效数据个数
	int capacity;//空间大小
}Heap;

2、初始化与销毁

//堆的初始化
void HPInit(Heap* php)
{
	assert(php);
	php->arr = NULL;
	php->capacity = php->size = NULL;
}

//堆的销毁
void HPDestroy(Heap* php)
{
	assert(php);
	if (php->arr)
	{
		free(php->arr);
	}
	php->arr = NULL;
	php->capacity = php->size = NULL;
}

3、入堆与出堆（小堆）

1）Swap

通过Swap函数交换两个数据

//两个数据的交换
void Swap(HPDataType* x, HPDataType* y)
{
	assert(x || y);
	HPDataType cpy = *x;
	*x = *y;
	*y = cpy;
}

2）入堆

1 数据的向上调整

//数据的向上调整(小堆)
void AdjustUpSmall(HPDataType* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;//求该子节点的父结点
	while (child > 0)
	{
		if (arr[child] < arr[parent])//当孩子结点小于父节点时，两个数据交换
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

2 入堆

//入堆(小堆)
void HPPushSmall(Heap* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->arr,sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fali!!!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;//因为数据还没有向上调整，所以size不能++
	//向上调整
	AdjustUpSmall(php->arr, php->size++);
}

3）出堆

1 数据的向下调整

//数据的向下调整(小堆)
void AdjustDownSmall(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//求该父节点的左孩子
	while (child < n)//该左孩子在数组内
	{
		if (child + 1 < n && arr[child] > arr[child + 1])//比较左右孩子大小
		{
			child++;
		}
		//父节点和孩子结点交换
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

2 出堆

//出堆(小堆)
void HPPopSmall(Heap* php)
{
	assert(php && php->size);//有效数据不能为零
	//头尾数据交换
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//出堆
	php->size--;
	//数据的向下调整
	AdjustDownSmall(php->arr, 0, php->size);
}

三、其他

1、入堆与出堆（大堆）

与小堆大同小异

//数据的向上调整(大堆)
void AdjustUpBig(HPDataType* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;//求该子节点的父结点
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//入堆(大堆)
void HPPushBig(Heap* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fali!!!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;//因为数据还没有向上调整，所以size不能++
	//向上调整
	AdjustUpBig(php->arr, php->size++);
}

//数据的向下调整(大堆)
void AdjustDownBig(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//求该父节点的左孩子
	while (child < n)//该左孩子在数组内
	{
		if (child + 1 < n && arr[child] < arr[child + 1])//比较左右孩子大小
		{
			child++;
		}
		//父节点和孩子结点交换
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//出堆(大堆)
void HPPopBig(Heap* php)
{
	assert(php && php->size);//有效数据不能为零
	//头尾数据交换
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//出堆
	php->size--;
	//数据的向下调整
	AdjustDownBig(php->arr, 0, php->size);
}

2、堆排序

1）排降序

以排降序为例，通过建小堆来实现堆排序

void HeapSortSmall(int* arr, int n)
{
	建小堆，向上排序法建堆
	//for (int i = 0; i < n; i++)
	//{
	//	//向上建堆
	//	AdjustUpSmall(arr, i);
	//}
	//向下排序，建小堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//(n - 1 - 1) / 2 求的是最底下子结点的父结点
	{
		AdjustDownSmall(arr, i, n);
	}
	//排降序
	int end = n - 1;
	while (end > 0)//出堆
	{
		Swap(&arr[0], &arr[end]);
		AdjustDownSmall(arr, 0, end);
		end--;
	}
}

2）排升序

同理，通过建立大堆排升序

void HeapSortBig(int* arr, int n)
{
	//向下排序，建大堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//(n - 1 - 1) / 2 求的是最底下子结点的父结点
	{
		AdjustDownBig(arr, i, n);
	}
	//排升序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDownBig(arr, 0, end);
		end--;
	}
}

3、Top-K问题

问：有一个数据量特别大的集合，如何用一个最多包含 K 个元素的集合来求得最大或最小的前 K 个元素
答：用前 K 个元素建大堆或小堆，在用剩余的N-K个元素依此与堆顶元素比较大小，如过该元素比堆顶元素大于或小于，则替换掉堆顶元素。

//造数据
void CreateNDate()
{
	int n = 100000;
	srand((unsigned int)time(NULL));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen fail!!!");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int x = (rand() + i) % 1000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}

//Top-K 问题
void TopK()
{
	int k = 10;

	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen fail!!!");
		exit(1);
	}

	int minHeap[10] = { 0 };
	
	//从文件中读前K个数据
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "&d\n", minHeap);
	}

	//建小堆
	for (int i = (k - 1 - 1) / 2; i > 0; i--)
	{
		AdjustDownSmall(minHeap, 0, k);
	}

	//继续取文件的数据，将读取到的数据和堆顶进行比较
	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minHeap[0])
		{
			minHeap[0] = x;
			AdjustDownSmall(minHeap, 0, k);
		}
	}

	//排升序
	printf("排升序：");
	HeapSortBig(minHeap, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", minHeap[i]);
	}
	printf("\n");

	fclose(fout);
}

四、总代码

Heap.h

#pragma once
#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
#include<time.h>

typedef int HPDataType;
typedef struct Heap
{
	HPDataType* arr;
	int size;//有效数据个数
	int capacity;//空间大小
}Heap;
//堆的初始化
void HPInit(Heap* php);
//堆的销毁
void HPDestroy(Heap* php);
//两个数据的交换
void Swap(HPDataType* x, HPDataType* y);
//数据的向上调整(小堆)
void AdjustUpSmall(HPDataType* arr, int child);
//入堆(小堆)
void HPPushSmall(Heap* php, HPDataType x);
//数据的向下调整(小堆)
void AdjustDownSmall(HPDataType* arr, int parent, int n);
//出堆(小堆)
void HPPopSmall(Heap* php);
//判空
bool HPEmpty(Heap* php);
//取堆顶数据
HPDataType HPTop(Heap* php);
//数据的向上调整(大堆)
void AdjustUpBig(HPDataType* arr, int child);
//入堆(大堆)
void HPPushBig(Heap* php, HPDataType x);
//数据的向下调整(大堆)
void AdjustDownBig(HPDataType* arr, int parent, int n);
//出堆(大堆)
void HPPopBig(Heap* php);
//堆排序
//排升序，建大堆
//排降序，建小堆
void HeapSortSmall(int* arr, int n);
void HeapSortBig(int* arr, int n);

Heap.cpp

#include"Heap.h"

//堆的初始化
void HPInit(Heap* php)
{
	assert(php);
	php->arr = NULL;
	php->capacity = php->size = NULL;
}

//堆的销毁
void HPDestroy(Heap* php)
{
	assert(php);
	if (php->arr)
	{
		free(php->arr);
	}
	php->arr = NULL;
	php->capacity = php->size = NULL;
}

//两个数据的交换
void Swap(HPDataType* x, HPDataType* y)
{
	assert(x || y);
	HPDataType cpy = *x;
	*x = *y;
	*y = cpy;
}

//数据的向上调整(小堆)
void AdjustUpSmall(HPDataType* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;//求该子节点的父结点
	while (child > 0)
	{
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//入堆(小堆)
void HPPushSmall(Heap* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->arr,sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fali!!!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;//因为数据还没有向上调整，所以size不能++
	//向上调整
	AdjustUpSmall(php->arr, php->size++);
}

//数据的向下调整(小堆)
void AdjustDownSmall(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//求该父节点的左孩子
	while (child < n)//该左孩子在数组内
	{
		if (child + 1 < n && arr[child] > arr[child + 1])//比较左右孩子大小
		{
			child++;
		}
		//父节点和孩子结点交换
		if (arr[child] < arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//出堆(小堆)
void HPPopSmall(Heap* php)
{
	assert(php && php->size);//有效数据不能为零
	//头尾数据交换
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//出堆
	php->size--;
	//数据的向下调整
	AdjustDownSmall(php->arr, 0, php->size);
}

//判空
bool HPEmpty(Heap* php)
{
	assert(php);
	return php->size == 0;
}

//取堆顶数据
HPDataType HPTop(Heap* php)
{
	assert(php && php->size);
	return php->arr[0];
}

//数据的向上调整(大堆)
void AdjustUpBig(HPDataType* arr, int child)
{
	assert(arr);
	int parent = (child - 1) / 2;//求该子节点的父结点
	while (child > 0)
	{
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

//入堆(大堆)
void HPPushBig(Heap* php, HPDataType x)
{
	assert(php);
	//判断空间是否足够
	if (php->capacity == php->size)
	{
		int newcapacity = php->capacity == 0 ? 4 : php->capacity * 2;
		HPDataType* tmp = (HPDataType*)realloc(php->arr, sizeof(HPDataType) * newcapacity);
		if (tmp == NULL)
		{
			perror("realloc fali!!!");
			exit(1);
		}
		php->arr = tmp;
		php->capacity = newcapacity;
	}
	php->arr[php->size] = x;//因为数据还没有向上调整，所以size不能++
	//向上调整
	AdjustUpBig(php->arr, php->size++);
}

//数据的向下调整(大堆)
void AdjustDownBig(HPDataType* arr, int parent, int n)
{
	int child = parent * 2 + 1;//求该父节点的左孩子
	while (child < n)//该左孩子在数组内
	{
		if (child + 1 < n && arr[child] < arr[child + 1])//比较左右孩子大小
		{
			child++;
		}
		//父节点和孩子结点交换
		if (arr[child] > arr[parent])
		{
			Swap(&arr[child], &arr[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

//出堆(大堆)
void HPPopBig(Heap* php)
{
	assert(php && php->size);//有效数据不能为零
	//头尾数据交换
	Swap(&php->arr[0], &php->arr[php->size - 1]);
	//出堆
	php->size--;
	//数据的向下调整
	AdjustDownBig(php->arr, 0, php->size);
}

//堆排序
//排升序，建大堆
//排降序，建小堆

void HeapSortSmall(int* arr, int n)
{
	建小堆，向上排序法建堆
	//for (int i = 0; i < n; i++)
	//{
	//	//向上建堆
	//	AdjustUpSmall(arr, i);
	//}
	//向下排序
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//(n - 1 - 1) / 2 求的是最底下子结点的父结点
	{
		AdjustDownSmall(arr, i, n);
	}
	//排降序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDownSmall(arr, 0, end);
		end--;
	}
}
void HeapSortBig(int* arr, int n)
{
	//向下排序
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)//(n - 1 - 1) / 2 求的是最底下子结点的父结点
	{
		AdjustDownBig(arr, i, n);
	}
	//排升序
	int end = n - 1;
	while (end > 0)
	{
		Swap(&arr[0], &arr[end]);
		AdjustDownBig(arr, 0, end);
		end--;
	}
}

main.cpp

#include"Heap.h"

//造数据
void CreateNDate()
{
	int n = 100000;
	srand((unsigned int)time(NULL));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen fail!!!");
		return;
	}
	for (int i = 0; i < n; i++)
	{
		int x = (rand() + i) % 1000000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}

//Top-K 问题
void TopK()
{
	int k = 10;

	const char* file = "data.txt";
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen fail!!!");
		exit(1);
	}

	int minHeap[10] = { 0 };
	
	//从文件中读前K个数据
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "&d\n", minHeap);
	}

	//建小堆
	for (int i = (k - 1 - 1) / 2; i > 0; i--)
	{
		AdjustDownSmall(minHeap, 0, k);
	}

	//继续取文件的数据，将读取到的数据和堆顶进行比较
	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minHeap[0])
		{
			minHeap[0] = x;
			AdjustDownSmall(minHeap, 0, k);
		}
	}

	//排升序
	printf("排升序：");
	HeapSortBig(minHeap, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", minHeap[i]);
	}
	printf("\n");

	fclose(fout);
}

void test01()
{
	Heap hpsmall;
	//堆的初始化
	HPInit(&hpsmall);
	//入堆(小堆)
	HPDataType arr[10] = { 32,11,55,223,86,123,867,3423,75,13 };
	for (int i = 0; i < 10; i++)
	{
		HPPushSmall(&hpsmall, arr[i]);
	}
	//取堆顶数据
	printf("Heap: ");
	while (!HPEmpty(&hpsmall))
	{
		printf("%d ", HPTop(&hpsmall));
		//出堆(小堆)
		HPPopSmall(&hpsmall);
	}
	printf("\n");
	//堆的销毁
	HPDestroy(&hpsmall);

	//排降序
	printf("排降序：");
	HeapSortSmall(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	//排升序
	printf("排升序：");
	HeapSortBig(arr, 10);
	for (int i = 0; i < 10; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");

	//CreateNDate();
	TopK();
}

int main()
{
	test01();
	return 0;
}

关注

10
点赞
踩
9

收藏

觉得还不错? 一键收藏
0
评论
C学习（数据结构）--＞实现顺序结构二叉树

一般堆使用顺序结构的数组来存储数据，堆是一种特殊的二叉树。具有二叉树的特性的同时，还具有其它的特性。
复制链接

扫一扫

专栏目录

。TAT。 CSDN认证博客专家 CSDN认证企业博客

码龄4年

24: 原创

105万+: 周排名

5万+: 总排名

1万+: 访问

: 等级

514: 积分

225: 粉丝

275: 获赞

9: 评论

259: 收藏

私信

关注

热门文章

分类专栏

学习心得 18篇

最新评论

C语言学习—俄罗斯方块
CSDN-Ada助手: 恭喜您写了第12篇博客！看到您分享关于C语言学习和俄罗斯方块的内容，我觉得您的热情和努力真的让人钦佩。希望您能继续保持写作的热情，不断挑战自我，尝试更多不同的主题和技术，让自己的创作更加丰富多彩。加油！
C语言学习—数据在内存中的储存
CSDN-Ada助手: 恭喜用户写了第11篇博客！学习C语言中数据在内存中的储存是一个很重要的知识点，你的文章写得很清晰易懂，让读者受益匪浅。接下来，建议可以继续深入探讨C语言中的数据类型、指针等内容，这些都是学习C语言中非常重要且有挑战性的知识点。期待你的下一篇作品！加油！
C语言学习—字符和字符串函数
CSDN-Ada助手: 恭喜您写了第9篇博客！学习C语言字符和字符串函数是一个很重要的步骤，能够帮助您更深入地理解编程的核心概念。接下来，建议您可以尝试写一些实际应用的例子，可以让读者更好地理解如何在实际项目中运用这些知识。期待您的下一篇作品！加油！
C语言学习—内存函数
CSDN-Ada助手: 恭喜您撰写了第10篇博客！学习C语言内存函数是一个很好的选择，对于深入了解程序内存管理至关重要。希望您能继续坚持创作，分享更多关于C语言学习的经验和知识。下一步建议可以尝试探讨C语言中其他重要函数的用法，或者分享一些实践经验和技巧，让读者能更加深入地了解和掌握C语言编程。期待您更多精彩的博客！
C语言学习—指针（1）
CSDN-Ada助手: 恭喜您撰写了第5篇博客“C语言学习—指针（1）”，学习指针这一难点知识，展现了您对C语言学习的执着和努力。希望您能继续保持写作的热情和动力，不断分享自己的学习心得和经验。或许在接下来的文章中，可以深入探讨指针的高级应用或者与其他知识点的结合，让读者更好地理解和运用。期待您的下一篇作品！

大家在看

最新文章

目录

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。