数据结构与算法 - 树-堆相关算法的时间复杂度分析 #向上调整 #向下调整 #向上调整建堆 #向下调整建堆 #堆排序

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	while (child)
	{
		//大堆
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

小堆：

//向上调整
void AdjustUp(HPDataType* a, int child)
{
	int parent = (child - 1) / 2;

	while (child)
	{
		//小堆
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			child = parent;
			parent = (child - 1) / 2;
		}
		else
		{
			break;
		}
	}
}

三、向下调整算法

当执行删除逻辑的时候，即将堆根中的数据与尾数据进行交换，然后删除尾数据再对堆根上的数据进行向下调整；

注：向下调整算法的前提：该根节点的左右子树必须都为堆，才能进行调整；

具体过程如下图所示：

同理，向下调整算法最坏的情况：从堆根一直调整到叶节点，即高度次，可以认为是 logN

代码如下：

大堆：

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//大堆
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child++;
		}
		//大堆
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

小堆：

//向下调整
void AdjustDown(HPDataType* a, int n, int parent)
{
	int child = parent * 2 + 1;
	while (child < n)
	{
		//小堆
		if (child + 1 < n && a[child + 1] < a[child])
		{
			child++;
		}
		//小堆
		if (a[parent] > a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

四、建堆算法时间复杂度的分析

建堆分为向上调整建堆与向下调整建堆；

堆的逻辑类型：1、满二叉树 2、完全二叉树

因为时间复杂度是分析最坏的情况，因为满二叉树的每一层节点均为满的，故而此处分析满二叉树；

(一)、向上调整算法建堆

向上调整建堆的逻辑：遍历每一个节点(除了根节点，因为根节点没有前继节点)，让该节点与其祖先节点进行比较(比较的次数与该树的层数有关);

代码如下：

//向上调整建堆
for (int i = 1; i < sz; i++)//根节点无需进行调整,因为根节点无祖先
{
	AdjustUp(a, i);
}

//注：sz 为数组中数据的个数

图解分析如下：

综上，向上调整算法的时间复杂度为 O(NlogN)

(二)、向下调整算法建堆

向下调整算法建堆的逻辑分析：

所要调整的节点的子树必须为堆；
因为在建堆的过程，其数据是乱的，向下调整建堆不是删除逻辑中的调整堆根中的数据，而应该从数据后面开始调整，而叶节点没有孩子其本身又可以看作一个堆，所以向下调整建堆从最后一个非叶子节点开始；最后一个非叶子节点其实就是最后一个叶节点的父节点；

注：在堆的删除逻辑中，会将堆根的数据与最后一个数据进行交换，然后删除最后一个数据，再对堆根进行向下调整；直接对堆根进行向下调整的原因在于，将堆根中的数据与尾数据进行交换并不会影响到堆的结构，即根节点的左右子树仍然为堆，故而可以对堆根中的数据直接进行向下调整；而此处的向下调整建堆在物理层面，该数组中的数据是乱的(不符合堆中父子节点的大小关系)，那么就不可以从下标为0的数据开始向下调整，而应该从后面开始，因为叶节点无子节点，其本身就为一个堆无需进行向下调整，故而向下调整应该是从二叉树的最后一个非叶节点开始(最后一个节点的父节点);

代码如下：

//向下调整建堆
for (int i = (sz - 1 - 1) / 2; i >= 0; i--)
{
	AdjustDowm(a, n, i);
}

//注：sz 为数组中数据的个数

图解分析如下：

综上，向下调整算法建堆的时间复杂度为 O(N)

(三)、向上、向下调整算法调整建堆的区别

向上调整建堆是将本节点与其祖先节点进行比较，而节点所在的层数越大，那一层的节点数越多，该层一个节点所要向上调整的次数也就越多，即节点数量多的层*调整次数多，节点数量少的层*调整次数少；
而向下调整是将本节点与其子孙节点进行比较，而层数越大，该层的节点数量越多，调整的次数少；层数越小，该层的节点数量越少，调整的次数越多，即节点数量多的层*调整次数少，节点数量少的层*调整次数多；

综上，从建堆算法来看，向下调整建堆算法更优；

五、堆排序

堆排序的逻辑：

堆中的结构规定了父子节点之间的大小关系，堆根中的数据是该堆中最大或者最小的数据；
如果排降序建大堆，显然堆根中的数据(下标为0的空间中的数据是所有数据中最大的一个)，倘若将堆根中的数据“定”好了，再利用堆的特点去处理后面的数据，首先是需要重新建堆，因为打乱了原先父子节点之间的关系，父子变成兄弟，即直接"去除"堆根中的数据会破坏堆的结构，则需要重新建堆，建堆的时间复杂度为 O(N^2*logN) 或者 O(N^2) [注：因为会有N次建堆，而每次建堆都需要向上或者向下调整建堆]，效率不太高；
又联想到堆接口函数中“删除”的逻辑，将堆根中的数据与尾数据进行交换，然后再进行向下调整，相当于确定好所要排序数据后方数据的位置，那么排降序，建小堆；排升序，建大堆。此方法的时间复杂度为O(NlogN), 相较于前面的方法，效率明显高了很多；

具体分析如下：

代码如下：

   int arr[] = { 23,45,1,32,67,34,14,17,88,79 };
   int sz = sizeof(arr) / sizeof(arr[0]);
   //堆排序
   //建堆算法 

   //向上调整建堆 - 不调整根节点，因为根节点没有祖先节点
   /*for (int i = 1; i < sz; i++)
   {
       AdjustUp(arr, i);
   }*/

   //向下调整建堆 - 不调整叶节点 - 因为叶节点没有孩子节点
   //从最后一个非叶子节点开始向下调整建堆
   for (int i = (sz - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(arr, sz, i);
   }

   //排降序 - 建小堆
   //排升序 - 建大堆
   int n = sz - 1;//最后一个数据的下标
   while (n)//sz个数据需要调整 sz -1 次
   {
       //将堆根的数据与尾数据进行交换，然后伪删
       Swap(&arr[0], &arr[n]);
       //进行向下调整
       AdjustDown(arr, n, 0);
       n--;
   }

   //打印
   for (int i = 0; i < sz; i++)
   {
       printf("%d ", arr[i]);
   }
   printf("\n");

从上文中我们得知，利用向上调整建堆的时间复杂度为：O(NlogN) , 利用向下调整建堆的时间复杂度为O(N)；

在堆排序中，首先是需要将堆根中的数据与尾数据进行交换，伪删尾数据，然后再对堆根中的数据进行向下调整；如果有N个数据，就需要调整(N-1) 次，而每次向下调整的时间复杂度为O(logN), 那么整体的时间复杂度为O(NlogN);