二叉数之堆

最新推荐文章于 2024-07-07 18:26:58 发布

奇点 ♡

最新推荐文章于 2024-07-07 18:26:58 发布

阅读量819

点赞数 24

分类专栏：数据结构与算法文章标签：数据结构算法

本文链接：https://blog.csdn.net/2302_81250321/article/details/135788607

版权

数据结构与算法专栏收录该内容

9 篇文章 0 订阅

订阅专栏

树的概念

树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。

有一个特殊的结点，称为根结点，根节点没有前驱结点
除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i<= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继
因此，树是递归定义的。

注意：树形结构中，子树之间不能有交集，否则就不是树形结构

树的相关概念

节点的度：一个节点含有的子树的个数称为该节点的度；如上图：A的为6
叶节点或终端节点：度为0的节点称为叶节点；如上图：B、C、H、I...等节点为叶节点
非终端节点或分支节点：度不为0的节点；如上图：D、E、F、G...等节点为分支节点
双亲节点或父节点：若一个节点含有子节点，则这个节点称为其子节点的父节点；如上图：A是B的父节点
孩子节点或子节点：一个节点含有的子树的根节点称为该节点的子节点；如上图：B是A的孩子节点
兄弟节点：具有相同父节点的节点互称为兄弟节点；如上图：B、C是兄弟节点
树的度：一棵树中，最大的节点的度称为树的度；如上图：树的度为6
节点的层次：从根开始定义起，根为第1层，根的子节点为第2层，以此类推；
树的高度或深度：树中节点的最大层次；如上图：树的高度为4
堂兄弟节点：双亲在同一层的节点互为堂兄弟；如上图：H、I互为兄弟节点
节点的祖先：从根到该节点所经分支上的所有节点；如上图：A是所有节点的祖先
子孙：以某节点为根的子树中任一节点都称为该节点的子孙。如上图：所有节点都是A的子孙
森林：由m（m>0）棵互不相交的树的集合称为森林

二叉树的概念和结构

一棵二叉树是结点的一个有限集合，该集合:
1. 或者为空
2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

从上图可以看出：
1. 二叉树不存在度大于2的结点
比特科技
2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

注意：对于任意的二叉树都是由以下几种情况复合而成的：

特殊的二叉树：
1. 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个二叉树的层数为K，且结点总数是，则它就是满二叉树。
2. 完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是由满二叉树而引出来的。对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。要注意的是满二叉树是一种特殊的完全二叉树。

二叉树性质

1. 若规定根节点的层数为1，则一棵非空二叉树的第i层上最多有 2^（i-1）个结点.
2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h -1.
3. 对任何一棵二叉树, 如果度为0其叶结点个数为n0 , 度为2的分支结点个数为n2 ,

则有n0 ＝n2 ＋1
4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log2(n+1).

堆的概念

把一个完全二叉树把他的所以元素按照他的顺序存储到一维数组中，根节点比任何一个节点大的叫大堆，根节点比任何一个节点小的叫小堆。

堆的实现

堆的初始化

typedef int HPdatatype;
typedef struct Heap
{
	HPdatatype* p;
	int size;
	int capacity;
}Heap;

void Heapinit(Heap* hp)
{
	assert(hp);
	hp->p = NULL;
	hp->size = 0;
	hp->capacity = 0;
}

堆的插入

void Heappush(Heap* hp, HPdatatype x)
{
	assert(hp);

	if (hp->size == hp->capacity)
	{
		int n = hp->capacity == 0 ? 4 : hp->capacity * 2;
		HPdatatype* tem = (HPdatatype*)realloc(hp->p,sizeof(HPdatatype) * n);
		if (tem == NULL)
		{
			perror("malloc fail");
			return;
		}
		hp->p = tem;
		hp->capacity = n;
	}
	hp->p[hp->size] = x;
	hp->size++;
	adjuctup(hp->p, hp->size - 1);
}

向上调整法

void adjuctup(HPdatatype* h, int child)
{
	assert(h);
	int parent = (child - 1) / 2;
	while (child>0)//用孩子来作为条件结束比较好
	{
		if (h[child] < h[parent])
		{
			swap(&h[child], &h[parent]);
			child = parent;
		}
		else
		{
			break;
		}
	}
}

注：要建大堆改变不等号就可以了

补充：

void swap(HPdatatype* p1, HPdatatype* p2)
{
	assert(p1);
	assert(p2);
	HPdatatype tem = *p1;
	*p1 = *p2;
	*p2 = tem;
}

堆的删除

void Heappop(Heap* hp)
{
	assert(hp);
	assert(!Heapisempty(hp));

	swap(&hp->p[0], &hp->p[hp->size - 1]);
	hp->size--;
	adjuctdown(hp->p,hp->size,0);
}

向下调整法

void adjuctdown(HPdatatype* h, int n, HPdatatype parent)
{
	assert(h);
	int child = parent * 2 + 1;
	while (child<n)
	{
		if ((child + 1) < n && h[child] > h[child + 1])
		{
			child++;
		}
		if (h[parent] > h[child])
		{
			swap(&h[parent], &h[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

注：要建大堆改变不等号就可以了

其他简单的实现

这些简单就不解释了

bool Heapisempty(Heap* hp)
{
	assert(hp);
	return hp->size == 0;
}

HPdatatype Heaptop(Heap* hp)
{
	assert(hp);
	assert(!Heapisempty(hp));
	return hp->p[0];
}

int Heapsize(Heap* hp)
{
	assert(hp);
	return hp->size;
}

堆的应用

堆排序

void Heapsort(int* p)//p 是数组
{
	Heap hp;
	Heapinit(&hp);
	for(int i=0;i<8;i++)
	{
		Heappush(&hp, p[i]);
	}
	for (int i = 0; i < 8; i++)
	{
		int top = Heaptop(&hp);
		p[i] = top;
		Heappop(&hp);
	}
	Heapdestroy(&hp);
}

这种方法简单，但是效率低，需要另开辟空间建堆

我们可以考虑在原来的数组建堆，怎么弄呢？

void Heapsort(int* p,int n)//n指数组大小
{
	for (int i = 1; i<n; i++)
	{
		adjuctup(p, i);
	}
}

void Heapsort(int* p,int n)//n指数组大小
{
	for (int i = (n-1-1) / 2; i >=0; i--)
   {
	 adjuctdown(p, n, i);
   }
}

是不是很妙，哈哈哈哈哈哈哈哈哈哈哈！

因此：向下调整建堆的时间复杂度为O(N)

同理可算：向上调整建堆的时间复杂度为O(N*log N)

显然向下调整建堆更好，以后就用向下调整建堆了

建好堆就进行排序了

void Heapsort(int* p,int n)//n指数组大小
{
	for (int i = 1; i<n; i++)
	{
		adjuctup(p, i);
	}
	for (int i = (n-1-1) / 2; i >=0; i--)
	{
		adjuctdown(p, n, i);
	}
	int end = n - 1;
	for(int i=0;i<n-1;i++)
	{
		swap(&p[end], &p[0]);
		adjuctdown(p, end--, 0);
	}
}

TOPK问题

当你要找一堆数中前k个最大或最小，怎么找？

简单啦，利用堆的特点，假如找前k个最小的数，建小堆，取顶元素，再删顶元素，一直到最后就可以找出来。


int main()
{
	int a[8] = { 23,45,12,57,35,78,26,90 };
	Heap hp;
	Heapinit(&hp);
	for(int i=0;i<8;i++)
	{
		Heappush(&hp, a[i]);
	}
	
	while(!Heapisempty(&hp))
	{
		int top = Heaptop(&hp);
		printf("%d ", top);
		Heappop(&hp);
	}
	Heapdestroy(&hp);
	return 0;
}

pop多少次就可以找出前多少个。

但是这种方法不太好，假如数据很多很多，无法全部加载到内存中，也就无法建堆，就实现不了。

那怎么办呢？

改进思路：

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

以文件的方式给大家呈现：

void CreateData()
{
	int n = 1000;
	srand(time(0));
	FILE* fin = fopen("text.txt", "w");
	if (fin == NULL)
	{
		perror("fopen fin fail");
		return;
	}
	
	for (int i = 0; i < n; i++)
	{
		int m = rand() % 10000;
		fprintf(fin, "%d\n", m);
	}
	fclose(fin);
}
void PrintfTok(k)
{
	HPdatatype* p = (HPdatatype*)malloc(sizeof(HPdatatype) * k);
	if (p == NULL)
	{
		perror("malloc fail");
		return;
	}
	FILE* fout = fopen("text.txt", "r");
	if (fout == NULL)
	{
		perror("fopen fout fail");
		return;
	}
	for (int i = 0; i < k; i++)
	{
		fscanf(fout, "%d", &p[i]);
	}
	for (int i = (k-1-1) / 2; i >=0; i--)
	{
		adjuctdown(p, k, i);
	}
	int val;
	while (!feof(fout))
	{
		fscanf(fout, "%d", &val);
		if(p[0]<val)
		{
			p[0] = val;
			adjuctdown(p, k, 0);
		}
	}
	for (int i = 0; i < k; i++)
	{
		printf("%d ", p[i]);
	}
}
int main()
{
	int k = 10;
	PrintfTok(k);

	return 0;
}

有了前面的基础，这个代码就很简单看懂了。

谢谢！

奇点 ♡

关注

24
点赞
踩
22

收藏

觉得还不错? 一键收藏
打赏
1
评论
二叉数之堆

对于深度为K的，有n个结点的二叉树，当且仅当其每一个结点都与深度为K的满二叉树中编号从1至n的结点一一对应时称之为完全二叉树。简单啦，利用堆的特点，假如找前k个最小的数，建小堆，取顶元素，再删顶元素，一直到最后就可以找出来。4. 若规定根节点的层数为1，具有n个结点的满二叉树的深度，h= log2(n+1).：若一个节点含有子节点，则这个节点称为其子节点的父节点；2. 若规定根节点的层数为1，则深度为h的二叉树的最大结点数是 2^h -1.：一个节点含有的子树的根节点称为该节点的子节点；
复制链接

扫一扫