数据结构——二叉树的概念及应用：堆

分类:热门推荐日期:2024-05-30浏览:1评论:0

文章目录

  • 一、树概念及结构
    • 1.1 树的概念
    • 1.2 树的相关概念
    • 1.3 树的表示
    • 二、二叉树概念
      • 2.1 二叉树
      • 2.2 特殊的二叉树
      • 2.3 二叉树的性质
      • 2.4 二叉树的存储结构
      • 三、二叉树的应用——堆
        • 3.1 二叉树的顺序结构
        • 3.2 堆的概念及结构
        • 四、堆的实现
          • 定义堆的结构
          • 堆的初始化
          • 堆的销毁
          • 向下调整法与向上调整法
          • 堆的插入
          • 堆的删除
          • 堆顶的数据
          • 堆数据个数
          • 堆的判空
          • 堆代码-> Heap.h
          • 堆代码->Heap.c
          • 五、堆的应用
            • 5.1 堆排序
              • 5.1.1 建堆
              • 5.1.2 排序
              • 5.2 Top-K问题

                一、树概念及结构

                1.1 树的概念

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

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

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

                  1.2 树的相关概念

                  • 节点的度 ：一个节点含有的子树的个数称为该节点的度； 如上图：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.3 树的表示

                    树结构相对线性表就比较复杂了，要存储表示起来就比较麻烦了，既然保存值域，也要保存结点和结点之间的关系，实际中树有很多种表示方式如：双亲表示法，孩子表示法、孩子双亲表示法以及孩子兄弟表示法等。

                    其中最常用的是 孩子兄弟表示法

                    typedef int DateType;
struct Node
{struct Node* firstChild1;//第一个孩子结点
	struct Node* pNextBrother;//指向其下一个兄弟结点
	DateType data;//结点中的数据域
};

                    二、二叉树概念

                    2.1 二叉树

                    一棵二叉树是结点的一个有限集合，该集合:

                    1. 或者为空
                    2. 由一个根节点加上两棵别称为左子树和右子树的二叉树组成

                    从上图可以看出：

                    1. 二叉树不存在度大于2的结点
                    2. 二叉树的子树有左右之分，次序不能颠倒，因此二叉树是有序树

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

                    2.2 特殊的二叉树

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

                      要注意的是满二叉树是一种特殊的完全二叉树，除了最后一层外其他每一层都是填满的，并且最后一层的节点都尽可能地靠左排列。

                    2.3 二叉树的性质

                    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) (ps： log2(n+1)是log以2为底，n+1为对数)
                    5. 对于具有n个结点的完全二叉树，如果按照从上至下从左至右的数组顺序对所有节点从0开始编号，则对于序号为i的结点有：
                    1. 若i>0，i位置节点的双亲序号： (i-1)/2；i=0，i为根节点编号，无双亲节点
                    2. 若2i+1左孩子序号：2i+1 ，2i+1>=n否则无左孩子
                    3. 若2i+2 右孩子序号：2i+2，2i+2>=n否则无右孩子

                    2.4 二叉树的存储结构

                    二叉树一般可以使用两种结构存储，一种顺序结构，一种链式结构。

                    1. 顺序存储

                    顺序结构存储就是使用数组来存储，一般使用数组只适合表示完全二叉树 ，因为不是完全二叉树会有空间的浪费。 而现实中使用中只有堆才会使用数组来存储。

                    二叉树顺序存储在物理上是一个数组，在逻辑上是一颗二叉树。

                    2. 链式存储

                    二叉树的链式存储结构是指，用链表来表示一棵二叉树，即用链来指示元素的逻辑关系。 通常的方法是链表中每个结点由三个域组成，数据域和左右指针域，左右指针分别用来给出该结点左孩子和右孩子所在的链结点的存储地址 。 链式结构又分为二叉链和三叉链，现在一般都是二叉链，高阶数据结构如红黑树等会用到三叉链 

                    typedef int BTDataType;
// 二叉链
struct BinaryTreeNode
{struct BinTreeNode* left; // 指向当前结点左孩子
	struct BinTreeNode* right; // 指向当前结点右孩子
	BTDataType data; // 当前结点值域
}
// 三叉链
struct BinaryTreeNode
{struct BinTreeNode* parent; // 指向当前结点的双亲
	struct BinTreeNode* left; // 指向当前结点左孩子
	struct BinTreeNode* right; // 指向当前结点右孩子
	BTDataType data; // 当前结点值域
}

                    三、二叉树的应用——堆

                    3.1 二叉树的顺序结构

                    普通的二叉树是不适合用数组来存储的，因为可能会存在大量的空间浪费。而完全二叉树更适合使用顺序结构存储。现实中我们通常把堆(一种二叉树)使用顺序结构的数组来存储

                    需要注意的是这里的堆和操作系统虚拟进程地址空间中的堆是两回事，一个是数据结构，一个是操作系统中管理内存的一块区域分段。

                    3.2 堆的概念及结构

                    堆的性质：

                    • 堆中某个节点的值总是不大于或不小于其父节点的值
                    • 堆总是一棵完全二叉树

                      四、堆的实现

                      定义堆的结构

                      堆的初始化

                      堆的销毁

                      向下调整法与向上调整法

                      我们通过从根节点开始的向下调整算法可以把它调整成一个小堆。向下调整算法有一个前提：左右子树必须是一个堆，才能调整

                      现在我们给出一个数组，逻辑上看做一颗完全二叉树。

                      int array[] = {27,15,19,18,28,34,65,49,25,37};

                      类似的，向上调整法是从最后一个结点开始，将该结点与其父亲结点比较，不断向上调整，直到符合堆的结构

                      这里的交换函数为

                      堆的插入

                      先插入一个10到数组的尾上，再进行向上调整算法，直到满足堆

                      堆的删除

                      删除堆是删除堆顶的数据，将堆顶的数据根最后一个数据一换，然后删除数组最后一个数据，再进行向下调整算法

                      堆顶的数据

                      堆数据个数

                      堆的判空

                      堆代码-> Heap.h

                      #pragma once
#include #include #include 
#include //创建堆结构
typedef int HPDateType;
typedef struct Heap
{HPDateType* a;//用动态数组存放堆的数据
	int size;//堆数据个数
	int capacity;//堆的容量
}HP;
//交换函数
void Swap(HPDateType* a, HPDateType* b);
//向上调整法 -> 现在调整为小堆
void AdjustUp(HPDateType* a, int child);
//向下调整法 ->现在调整为小堆
void AdjustDown(HPDateType* a, int n, int parent);
//堆的初始化和销毁
void HPInit(HP* php);
void HPDestroy(HP* php);
//堆的插入数据
void HPPush(HP* php, HPDateType x);
//堆的删除数据
void HPPop(HP* php);
//堆顶的数据
HPDateType HPTop(HP* php);
//堆数据个数
int HPSize(HP* php);
//堆的判空
bool HPEmpty(HP* php);

                      堆代码->Heap.c

                      #include "Heap.h"
//堆的初始化
void HPInit(HP* php)
{assert(php);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}
//堆的销毁
void HPDestroy(HP* php)
{assert(php);
	free(php->a);
	php->a = NULL;
	php->size = 0;
	php->capacity = 0;
}
//交换函数
void Swap(HPDateType* a, HPDateType* b)
{assert(a && b);
	HPDateType tmp = *a;
	*a = *b;
	*b = tmp;
}
//向上调整法 -> 现在调整为小堆
void AdjustUp(HPDateType* 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;
		}
	}
}
//堆的插入数据
void HPPush(HP* php, HPDateType x)
{assert(php);
	//判断堆的容量是否够插入新的数据
	if (php->size == php->capacity)
	{//扩容
		int newcapacity = php->capacity == 0 ? 4 : 2 * php->capacity;
		HPDateType* tmp = (HPDateType*)realloc(php->a, newcapacity * sizeof(HPDateType));
		if (tmp == NULL)
		{perror("realloc fail");
			exit(1);
		}
		php->a = tmp;
		php->capacity = newcapacity;
	}
	//插入数据
	php->a[php->size++] = x;
	//利用向上调整法将数据调整成堆
	AdjustUp(php->a, php->size-1);
}
//向下调整法 ->现在调整为小堆
void AdjustDown(HPDateType* a, int n,int parent)
{assert(a);
	//假设左孩子小
	int child = 2 * parent + 1;
	while (child < n)
	{//右孩子比左孩子小
		if (child + 1 < n && a[child + 1] < a[child])
		{child++;
		}
		if (a[child] < a[parent])
		{Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{break;
		}
	}
}
//堆的删除数据
void HPPop(HP* php)
{assert(php);
	assert(php->size > 0);
	Swap(&(php->a[0]), &(php->a[php->size - 1]));
	php->size--;
	//利用向下调整法将数据调整成堆
	AdjustDown(php->a, php->size,0);
}
//堆顶的数据
HPDateType HPTop(HP* php)
{assert(php);
	assert(php->size > 0);
	return php->a[0];
}
//堆数据个数
int HPSize(HP* php)
{assert(php);
	return php->size;
}
//堆的判空
bool HPEmpty(HP* php)
{assert(php);
	return php->size == 0;
}

                      五、堆的应用

                      5.1 堆排序

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

                      1. 建堆

                        升序：建大堆

                        降序：建小堆

                      2. 利用堆删除思想来进行排序

                        建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

                      5.1.1 建堆

                      对于数组怎么建堆呢？

                      第一种就是用向上调整法，依次将数组内的数据插入到堆中，就能完成堆的创建

                      向上调整法复杂度为O（N*logN）

                      第二种就是用向下调整法建堆

                      当向下调整的时候，必须保证左右子树都是堆，那么怎么保证左子树和右子树都堆呢，这时可以倒着往前调整

                      由于倒着进行调整，因此需要从倒数第一个非叶节点开始，至根节点。

                      向下调整法的时间复杂度为O（N）

                      5.1.2 排序

                      • 首先把无序数组构建成堆。（向下调整法比较占优势）
                      • 然后用向下调整法循环删除堆顶元素，移到数据尾部，调整堆产生新的堆顶。

                        当我们删除一个最大堆的堆顶其实就是放到最后面，经过循环调整，第二大的元素就会被交换上来，成为堆的新堆顶。

                        由于堆的性质，每一次删除堆顶，调整后的新堆顶的大小都是仅次于旧堆顶的节点。那么只要不断删除堆顶，调整堆，最终得到一个有序的数据

                        //堆排序
void HeapSort(HPDateType* a,int n)
{//升序  -> 大堆
	//降序  -> 小堆
	assert(a);
	//向上调整法创建堆 ->时间复杂度O(NlogN)
	/*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--;
	}
}

                        5.2 Top-K问题

                        TOP-K问题：即求数据结合中前K个最大的元素或者最小的元素，一般情况下数据量都比较大。

                        比如：专业前10名、世界500强、富豪榜、游戏中前100的活跃玩家等。

                        对于Top-K问题，能想到的最简单直接的方式就是排序，但是：如果数据量非常大，排序就不太可取了(可能数据都不能一下子全部加载到内存中)。

                        最佳的方式就是用堆来解决，基本思路如下：

                        1. 用数据集合中前K个元素来建堆

                        前k个最大的元素，则建小堆

                        前k个最小的元素，则建大堆

                        2. 用剩余的N-K个元素依次与堆顶元素来比较，不满足则替换堆顶元素

                        剩余N-K个元素依次与堆顶元素比完之后，堆中剩余的K个元素就是所求的前K个最小或者最大的元素。

                        #include #include #include #include 
//交换函数
void Swap(int* p1, int* p2)
{assert(p1 && p2);
	int tmp = *p1;
	*p1 = *p2;
	*p2 = tmp;
}
//向下调整法 
void AdjustDown(int* a,int n,int parent)
{assert(a);
	int child = 2 * parent + 1;
	while (child < n)
	{if (child + 1 < n && a[child + 1] < a[child])
		{child++;
		}
		if (a[child] < a[parent])
		{Swap(&a[child], &a[parent]);
			parent = child;
			child = 2 * parent + 1;
		}
		else
		{break;
		}
	}
}
//创建数据
void CreateData()
{FILE* fin = fopen("data.txt", "w");
	if (fin == NULL)
	{perror("fopen fail");
		exit(1);
	}
	int n = 10000;
	srand((unsigned)time(NULL));
	for(int i = 0;i < n;i++)
	{//控制数据在一万以内
		int x = (rand() + i) % 10000;
		fprintf(fin, "%d\n", x);
	}
	fclose(fin);
}
//打印前K个
void PrintTopK()
{FILE* fout = fopen("data.txt", "r");
	if (fout == NULL)
	{perror("fopen fail");
		exit(1);
	}
	int k = 0;
	int x = 0;
	//开辟大小为 K 的动态数组
	int* arr = (int*)malloc(sizeof(int) * k);
	printf("输入k的值\n");
	scanf("%d", &k);
	//读取数据
	for(int i = 0;i < k;i++)
	{fscanf(fout, "%d", &arr[i]);
	}
	//创建堆
	for (int i = (k - 1 - 1) / 2; i >= 0; i--)
	{//向下调整法
		AdjustDown(arr, k, i);
	}
	//取出剩下的数据
	while (fscanf(fout, "%d", &x) > 0)
	{//比堆顶大的进入堆
		if (x > arr[0])
		{arr[0] = x;
			AdjustDown(arr, k, 0);
		}
	}
	//打印最大的前K个
	for (int i = 0; i < k; i++)
	{printf("%d ", arr[i]);
	}
	printf("\n");
	fclose(fout);
}
int main()
{CreateData();
	PrintTopK();
	return 0;
}

                        在data.txt文件中可以手动赋值最大的前K个，方便检查程序的功能是否正常执行

相关推荐

关于我们常见问题广告服务免责声明联系我们
Powered By Z-BlogPHP 1.7.3 Theme By 优美主题
Copyright Your WebSite.Some Rights Reserved. 浙ICP备2023018783号