C语言数据结构-----二叉树(2)堆的深入理解及应用、链式二叉树的讲解及代码实现

最新推荐文章于 2024-11-01 12:24:41 发布
最新推荐文章于 2024-11-01 12:24:41 发布
阅读量942 收藏 20
点赞数 32
分类专栏： # 数据结构 文章标签： 数据结构 c语言 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_57425280/article/details/134908314
版权

前言

本篇文章讲述的内容有部分是上一节写过的。重复内容不会再进行说明，大家可以看上一节内容
链接: C语言数据结构-----二叉树(1)认识数、二叉树、堆及堆的代码实现

文章目录

1.使用堆解决TOP-K问题

TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。
比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。
对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。最佳的方式就是用堆来解决，基本思路如下：

  1. 用数据集合中前K个元素来建堆
    前k个最大的元素，则建小堆
    前k个最小的元素，则建大堆
  2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素
    将剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(HPDataType* a, int size, int parent)
{
	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;
		}
	}
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
			//child = (child - 1) / 2;
			//parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void CreateNDate()//创建随机数文本
{
	// 造数据
	int n = 10000000;
	srand(time(0));
	const char* file = "data.txt";
	FILE* fin = fopen(file, "w");
	if (fin == NULL)
	{
		perror("fopen error");
		return;
	}

	for (int i = 0; i < n; ++i)
	{
		int x = (rand() + i) % 10000000;
		fprintf(fin, "%d\n", x);
	}

	fclose(fin);
}

void PrintTopK(const char* file, int k)
{
	FILE* fout = fopen(file, "r");
	if (fout == NULL)
	{
		perror("fopen error");
		return;
	}

	// 建一个k个数小堆
	int* minheap = (int*)malloc(sizeof(int) * k);
	if (minheap == NULL)
	{
		perror("malloc error");
		return;
	}

	// 读取前k个，建小堆
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &minheap[i]);
		AdjustUp(minheap, i);
	}

	int x = 0;
	while (fscanf(fout, "%d", &x) != EOF)
	{
		if (x > minheap[0])
		{
			minheap[0] = x;
			AdjustDown(minheap, k, 0);
		}
	}

	for (int i = 0; i < k; i++)
	{
		printf("%d ", minheap[i]);
	}
	printf("\n");

	free(minheap);
	fclose(fout);
}

int main()
{
	 CreateNDate();
	PrintTopK("Data.txt", 5);

	return 0;
}

2.向下调整堆的时间复杂度与向上调整堆的时间复杂度对比

在这里插入图片描述
总体而言
①向下调整堆的时间复杂度为：O[N-log2(N+1)]，当N足够大时，约等于O(N)

②向上调整堆的时间复杂度为：在这里插入图片描述

3.堆排序问题

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

  1. 建堆
    升序：建大堆
    降序：建小堆
  2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。
#define _CRT_SECURE_NO_WARNINGS 1

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

typedef int HPDataType;

typedef struct Heap
{
	HPDataType* a;
	int size;
	int capacity;
}HP;

void Swap(HPDataType* p1, HPDataType* p2)
{
	HPDataType tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}

void AdjustDown(HPDataType* a, int size, int parent)
{
	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;
		}
	}
}

void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;
	//while (parent >= 0)
	while (child > 0)
	{
		if (a[child] < a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
			parent = (child - 1) / 2;
			//child = (child - 1) / 2;
			//parent = (parent - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	// 建大堆，向下调整
	// O(N*logN)
	/*for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}*/

	//建小堆，向上调整
	// O(N)
	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;
	}
}

int main()
{
	int a[] = { 4, 6, 2, 1, 5, 8, 2, 9 };
	HeapSort(a, sizeof(a)/sizeof(int));
	for (int i = 0; i < sizeof(a)/sizeof(int); i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");

	return 0;
}

在这里插入图片描述

4.链式二叉树

在这里插入图片描述

4.1 三种遍历二叉树

学习二叉树结构，最简单的方式就是遍历。所谓二叉树遍历(Traversal)是按照某种特定的规则，依次对二叉树中的节点进行相应的操作，并且每个节点只操作一次。访问结点所做的操作依赖于具体的应用问题。遍历是二叉树上最重要的运算之一，也是二叉树上进行其它运算的基础。
按照规则，二叉树的遍历有：前序/中序/后序的递归结构遍历：

  1. 前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。
  2. 中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。
  3. 后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。

以下是分别堆前序遍历、中序遍历、后序遍历的详细剖析！
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
前序遍历、中序遍历、后序遍历的代码实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include<stdbool.h>
#include<time.h>

typedef int BTDataType;
typedef struct BinaryTreeNode
{
	BTDataType data;
	struct BinaryTreeNode* left;
	struct BinaryTreeNode* right;
}TreeNode;

TreeNode* BuyTreeNode(int x)
{
	TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
	assert(node);

	node->data = x;
	node->left = NULL;
	node->right = NULL;

	return node;
}

TreeNode* CreateTree()
{
	TreeNode* node1 = BuyTreeNode(1);
	TreeNode* node2 = BuyTreeNode(2);
	TreeNode* node3 = BuyTreeNode(3);
	TreeNode* node4 = BuyTreeNode(4);
	TreeNode* node5 = BuyTreeNode(5);
	TreeNode* node6 = BuyTreeNode(6);

	node1->left = node2;
	node1->right = node4;
	node2->left = node3;
	node4->left = node5;
	node4->right = node6;

	return node1;
}

void PrevOrder(TreeNode* root)//前序遍历
{
	if (root == NULL)
	{
		printf("N ");//空
		return;
	}

	printf("%d ", root->data);
	PrevOrder(root->left);
	PrevOrder(root->right);
}

void InOrder(TreeNode* root)//中序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	InOrder(root->left);
	printf("%d ", root->data);
	InOrder(root->right);
}

void AfterOrder(TreeNode* root)//后序遍历
{
	if (root == NULL)
	{
		printf("N ");
		return;
	}

	AfterOrder(root->left);
	AfterOrder(root->right);
	printf("%d ", root->data);
}


int main()
{
	TreeNode* root = CreateTree();
	PrevOrder(root);
	printf("\n");

	InOrder(root);
	printf("\n");

	AfterOrder(root);
	printf("\n");

	return 0;
}

在这里插入图片描述
如图所示，结果和我们上面写的一样！
在这里插入图片描述

4.2 求二叉树节点的个数

错误法:
在这里插入图片描述
修改：
在这里插入图片描述
最优解：
也是递归思想

int TreeSize(TreeNode* root)
{
	return root == NULL ? 0 : TreeSize(root->left) +TreeSize(root->right) + 1;
	//如果是空那么节点为0，否则就是左子树的节点+右子树的节点+1(根节点)
}

在这里插入图片描述

4.3 求二叉树叶子节点(度为0的节点)的个数

int TreeLeafSize(TreeNode* root)//叶子节点的个数
{
	// 空 返回0
	if (root == NULL)
		return 0;
	// 不是空，是叶子 返回1
	if (root->left == NULL && root->right == NULL)
		return 1;

	// 不是空 也不是叶子  分治=左右子树叶子之和
	return TreeLeafSize(root->left) +TreeLeafSize(root->right);
}

4.4 求二叉树的高度

在这里插入图片描述

int TreeHeight(TreeNode* root)
{
	if (root == NULL)
		return 0;
	int leftHeight = TreeHeight(root->left);//记录数据
	int rightHeight = TreeHeight(root->right);//记录数据

	return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}

注意这里记录数据很重要，如果不记录数据直接使用三目的话，会导致效率低下。只知道谁大，不知道具体数值是多少,要输出具体数值的时候要重新进行计算，会大大降低效率！！！！
在这里插入图片描述

4.5 求二叉树第K层的节点个数

在这里插入图片描述

int TreeLevelK(TreeNode* 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.6 求二叉树查找值为x的结点

错误思想：
在这里插入图片描述
修改：

TreeNode* TreeFind(TreeNode* root, BTDataType x)// 二叉树查找值为x的结点
{
	if (root == NULL)
		return NULL;

	if (root->data == x)
		return root;

	TreeNode* ret1 = TreeFind(root->left, x);
	if (ret1)
		return ret1;

	TreeNode* ret2 = TreeFind(root->right, x);
	if (ret2)
		return ret2;

	return NULL;
}

其依然是一个复杂的递归，不过这里有记录了，返回也不是直接返回到最外面，而是返回到上一层递归！
在这里插入图片描述

4.7 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树

在这里插入图片描述
这样构建一棵树非常低效，我们可以利用前序遍历的值，直接构建好一棵树，这样效率大大提升！
在这里插入图片描述

TreeNode* TreeCreate(char* a, int* pi)// 通过前序遍历的数组"ABD##E#H##CF##G##"构建二叉树
{
	if (a[*pi] == '#')
	{
		(*pi)++;
		return NULL;
	}

	TreeNode* root = (TreeNode*)malloc(sizeof(TreeNode));
	if (root == NULL)
	{
		perror("malloc fail");
		exit(-1);
	}
	root->data = a[(*pi)++];

	root->left = TreeCreate(a, pi);
	root->right = TreeCreate(a, pi);
	return root;
}

这同样也是一个递归构建树的思路！
在这里插入图片描述

4.8 销毁链式二叉树

void DestroyTree(TreeNode* root)
{
	if (root == NULL)
		return;

	DestroyTree(root->left);
	DestroyTree(root->right);
	free(root);
}

摧毁二叉树用的是后序遍历的思想，从底层开始销毁!在这里插入图片描述
摧毁后置空！

4.9 层序遍历

层序遍历就是一层一层的读数据！具体过程如下：
在这里插入图片描述
但是层序遍历的本质是一个队列，我们要实现需要队列的代码，之前我介绍过队列，文章链接如下：
链接: C语言数据结构-----栈和队列(概念，代码实现及简单练习)

void LevelOrder(TreeNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	int levelSize = 1;//每一层的数据个数，控制一层一层出
	while (!QueueEmpty(&q))
	{
		// 一层一层出
		while (levelSize--)
		{
			TreeNode* 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");

		levelSize = QueueSize(&q);//读取每一层的数据个数
	}
	printf("\n");

	QueueDestroy(&q);
}

在这里插入图片描述

4.10 判断是否为完全二叉树

// 判断二叉树是否是完全二叉树
bool TreeComplete(TreeNode* root)
{
	Queue q;
	QueueInit(&q);
	if (root)
		QueuePush(&q, root);

	int levelSize = 1;
	while (!QueueEmpty(&q))
	{
		TreeNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front == NULL)
			break;

		QueuePush(&q, front->left);
		QueuePush(&q, front->right);
	}

	// 前面遇到空以后，后面还有非空就不是完全二叉树
	while (!QueueEmpty(&q))
	{
		TreeNode* front = QueueFront(&q);
		QueuePop(&q);

		if (front)
		{
			QueueDestroy(&q);
			return false;
		}
	}

	QueueDestroy(&q);
	return true;
}
Chris·Bosh
关注
专栏目录
C语言数据结构-----二叉树(1)认识数、二叉树、堆及堆的代码实现
qq_57425280的博客
12-09 982
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。①有一个特殊的结点，称为根结点，根节点没有前驱结点②除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1
数据结构--C语言实现链式二叉树--详解
weixin_52378334的博客
10-24 2518
本文以链表的方式实现了二叉树的创建，遍历，拷贝，求深度，删除子树，删除结点，插入结点等操作。
c语言-数据结构-链式二叉树
安权_code的博客
11-21 768
二叉树是由根节点和一个左子树以及一个右子树构成，且每一个结点的孩子节点可以少于两个但是不能多于两个，每个结点都带有一个数据，作为结点的有效值。二叉树的遍历一般采用递归的方式，对二叉树的每个结点进行相应操作。二叉树的遍历分为：前序遍历、中序遍历、后序遍历以及层序遍历。
【数据结构】C语言实现链式二叉树(附完整运行代码)
C/C++领域,数据结构,linux,MySQl学习者
12-25 1549
使用C语言实现链式二叉树程序新手入门详解.包括每个函数的设计思路详解图示及程序运行的完整代码.
C语言数据结构-层次遍历二叉树（非递归链队列实现遍历）
BamBoo_Bean的博客
08-05 275
C语言数据结构-层次遍历二叉树（非递归链队列实现遍历）
c语言实现数据结构---二叉树
qq_68695298的博客
10-03 979
二叉树的性质，以及实现二叉树的一些功能。
[ 数据结构-C语言 ] 二叉树--初阶 大总结~~
热门推荐
CSDN博客
04-14 1万+
今天要和大家一起步入一个新的数据结构--二叉树。在学习了解二叉树之前我们先来了解什么是树。 目录 1.树的概念及其结构 1.1树的概念 1.2树的相关概念(重点*) 1.3树的表示 2.二叉树概念及结构 2.1概念 2.2特殊的二叉树 2.3二叉树的性质（重要*） 2.4练习题 2.5 二叉树的存储结构 1. 顺序存储 2.链式存储 3.二叉树的顺序结构及实现 3.1 二叉树的顺序结构 3.2堆概念及其结构 3.2.1堆的实现 3.2.2堆的时间复杂...
二叉树的实现----C语言数据结构
qq_69261838的博客
01-17 951
用一个数组构建二叉树,将数组的每一个元素,像前序遍历一样,第一个赋予根节点,第二个根节点的左子树,第三个根结点的右子树,以此类推:值先给父节点,再给父节点的左子树,再给父节点的右子…在二叉树的销毁中,采用后序遍历是最佳的,因为对比中序和前序,当遍历到此结点时,销毁此节点,会丢失此节点的左右子树结点,不利于遍历到下一个结点.(当然可以设置临时变量记录此节点也是可以实现的)这里下标用的指针,是因为函数栈帧,在递归的时候,若传的是int pi ,那么这个值不会受上一个函数中的pi++影响,pi的值不会改变.
二叉树--C语言实现数据结构
2201_76062618的博客
07-18 1535
本文讲解二叉树的内容，较为详细
数据结构学习--二叉树及其应用
06-25
二叉树是数据结构中的重要概念，它是一种特殊的树形数据结构，每个节点最多只有两个子...通过这个程序，我们可以深入理解二叉树的链式存储结构和遍历算法，这对于后续学习其他复杂的数据结构和算法有着重要的基础作用。
数据结构C语言代码--线性表.7z
03-22
总结，线性表是数据结构的基础，理解和掌握其原理及C语言实现对于编程至关重要。无论是数组还是链表实现，都需要根据具体应用场景选择合适的数据结构，以达到高效的操作性能。在实际编程中，理解并熟练运用线性表的...
数据结构实验报告6-树-二叉树的遍历算法-实验内容及要求.docx
07-06
本次实验的主要目的是让学生深入理解并掌握二叉树的遍历算法。通过实际编程实践，加深对二叉树这一数据结构的理解，并熟练运用不同的遍历方法（先序、中序、后序和层次遍历）来处理二叉树问题。 ### 数据结构设计 ...
数据结构（十五） -- C语言版 -- 树 - 二叉树的操作进阶之创建、插入、删除、查询、销毁
青椒*^_^*凤爪爪的博客
06-05 1万+
本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。 设计的代码并非全部公开，部分无关紧要代码并没有贴出来。 如果你也对此感兴趣、也想测试源码的话，可以私聊我，非常欢迎一起探讨学习。 由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也很欢迎大佬看见的话批评指正。 嘻嘻。。。。 。。。。。。。。收！
C++ 数据结构 静态顺序表、动态顺序表。
qq_50373827的博客
11-01 503
静态顺序表（Static Array List）是一种线性数据结构，通常用数组实现。它具有固定的大小，并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。
通用型函数——冒泡排序
2401_84654619的博客
10-29 202
计算机中，任何数据最终都是二进制数，故只需有足够的空间，就可以将任何数据存储起来，相应的，读取时使用数据类型容器识别就可还原原本的意思。memcpy函数用于将指定数量的字节从源内存地址（src）复制到目标内存地址（dest）。n : 要复制的字节数，类型为size_t表示要复制的字节的数量。代码：（char型）
数据结构：并查集
2303_78940834的博客
10-29 785
在一些应用问题中，需要将n个不同的元素划分成一些不相交的集合。开始时，每个元素自成一个单元素集合，然后按一定的规律将归于同一组元素的集合合并。在此过程中要反复用到查询某一个元素归属于那个集合的运算。适合于描述这类问题的抽象数据类型称为并查集(union-findset)。举个例子看看比如：某公司今年校招全国总共招生10人，西安招4人，成都招3人，武汉招3人，10个人来自不同的学校，起先互不相识，每个学生都是一个独立的小团体，现给这些学生进行编号：{0, 1, 2, 3,
数据结构+算法分析与设计［19-21年真题版］
mufengzhiyu666的博客
10-29 338
八、设有一组关键字{19，01，23，14，55，20，84，27，68，11，10，77}，采用哈希函数： H(Key)=Key MOD 13， 采用开放地址法的线性探测再散列方法解决冲突，试在0～18的散列地址空间中对该关键字序列构造哈希表。八、依次输入表（30，15，28，20，24，10，12，68，35，50，46，55）中的元素，生成一棵二叉树排序树。七、给出一组关键字（29，18，25，47，58，12，51，10），分别写出按下列各种排序方法进行排序时的变化过程： （15分）
数据结构初识及顺序表详解
最新发布
chuxinweihui的博客
11-01 722
我们在写程序的时候，会出现许多的数据，如果我们想要修改某一个值或者删除和添加一个数据的时候就会非常困难，尤其是数据量庞大的时候，这时候数据结构就出来了。
20240818 字节跳动 笔试
lc_guo的博客
10-22 3728
BSP驱动开发工程师-OS、4 道编程题
掌握C语言二叉树实现：代码与数据结构详解
资源摘要信息:"数据结构第五章-树与二叉树二叉树的C语言实现代码" 该资源是一份关于数据结构中树与二叉树主题的C语言实现教程，涵盖了二叉树的理论知识与实际编码实践。资源主要包含两大部分内容：一是二叉树相关...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Chris·Bosh

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值