初阶数据结构学习记录——아홉 二叉树和堆（2）

接着上一篇

之前写过一些关于堆的代码，向下调整，向上调整算法，以及常用的几个函数。这一篇继续完善堆，难度也会有所上升。先来看上一篇文末提到的创建堆算法。

首先要有空间，要有数据，之后再形成堆。我们可以malloc一块空间，数据也可push或者创建一个数组然后拷贝过来，不过面对一个不成规则的数据如何把他们做成堆？直接用向上或向下调整都不能做到，如果说根节点的整个左子树和右子树都是大堆，那么用向下调整就合适。现在用这串数字做例子

把它变成堆的样子后，最后一层就有49 25 37。现在要把左右子树都变成大堆，如何改变？我们一块一块来改。37和28、18，49和25、19，34和65,、15和子节点们，最后整体调整。而关于18应该怎么找到，如果数组大小是n，那么18的下标就是（n-1-1）/2，用循环即可一个个调整。

void HeapCreate(HP* php, HPDataType* a, HPDataType n)
{
   assert(php);
   php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
   if (php->a == NULL)
   {
       perror("realloc fail");
       exit(-1);
   }
   memcpy(php->a, a, sizeof(HPDataType) * n);
   php->size = php->capacity = n;
   for (int i = (n - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(php->a, n, i);
   }
}

测试一下

void TestHeap3()
{
   int arr[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
   HP hp;
   HeapCreate(&hp, arr, sizeof(arr) / sizeof(int));
   HeapPrint(&hp);
   HeapDestroy(&hp);
}

成功创建。

堆排序

现在做排序算法

给一个数组，通过排序算法把他们变成堆。原始的数组无序。

int arr[] = { 27, 15, 19, 18, 28, 34, 65, 49, 25, 37 };
HeapSort(arr, sizeof(arr) / sizeof(int));

这样的话我们有两个方案，做向上调整或者向下调整。

   for (int i = 1; i < n; i++)
   {
       AdjustUp(a, i);
   }
   for (int i = (n - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(a, n, i);
   }

向上调整的思路就是默认为大堆，遍历数组看成一个个插入，插入第一个不做操作，第二个开始就进行比较，然后决定是否交换位置

向下调整的思路则是所有数据无序，不能直接进行向下调整。其实这个条件可以从pop函数里看出来，pop操作时，整体是大堆顺序，交换首尾元素，size--，这样整个堆里除了根节点，左子树和右子树都是大堆，这种情况向下调整可行。所以同样，这里就不能直接调整，但从尾开始调整是可以的。找到尾部元素的父节点，一一调整。

但是一般使用向下调整。假设是一个完全二叉树，N为节点数，h是高度。向下调整的次数是2^h -1 -h，也就是N - h，也就是N - log2(N + 1)，最后时间复杂度就是O(N)。

而向上调整最后一层的最大调整次数就是2^(h-1) * (h-1)，把它变成2^h*(h-1) / 2,也就是(N + 1)(log2N + 1) / 2, 所以仅最后一层都达到了N * log2N，所以向上调整的时间复杂度明显比向下大，而向上调整的时间复杂度就是O(N * log2N)。

在二叉树里，最后一层的节点数最多，而向下调整跳过了最后一层，直接从最后一层的父节点开始调整，并且从下到上，节点数多的调整少，而向上调整则是节点多的调整多，最后一层更是很多调整。所以不管是不是全部都要调整，向下调整次数都明显比向上少。

所以用向下调整法

向下调整选好了，接下来思考另一个问题，如果要升序的话，应该是建立大堆还是小堆？假如现在建小堆，面对一串无序的数字，如果pop掉第一个元素，把它放到另一个空间里，然后一个个插入来调整做成小堆可以，但是这样空间复杂度变高了。但是不开辟空间的话，在原始数组里调整，会发现数字之间的关系很容易乱掉，耗掉了很多时间。所以升序还是建立大堆。

大堆建好后，我们开始做升序。关于升序，我们可以把首尾元素互换一下，这样最大值出现在尾部，然后对于前面的数值进行向下调整找到次大值，排在倒数第二个位置，然后重复这个操作即可。

void AdjustDown(HPDataType* a, int n, int parent)
{
   int child = parent * 2 + 1;
   while (child < n)
   {
       //确认child指向大的那个孩子并且child要小于size
       if (child + 1 < n && 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 HeapSort(HPDataType* a, HPDataType n)//O(N * log2N)
{
   //0(N)
   for (int i = (n - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(a, n, i);
   }
   int end = n - 1;
   //O(N * log2N)
   while (end > 0)
   {
       Swap(&a[0], &a[end]);
       AdjustDown(a, end, 0);
       end--;
   }
}

当然如果向下调整里a[child + 1] > a[child]以及a[child] > a[parent]都改成<，那么就是降序了。

TOPK问题

接着来下一个问题。

在一些数据中找到十个最大的数据，把这个数字设为k，也就是找到前k个大的数据。当然我们可以一个个比较，但是正因为数据量不确定，所以情况不能这样简单。假设是有N个数字，N为十亿，百亿个，如果还是之前的办法是肯定不可行的。我们现在用堆来解决。堆如何找到最大的那k个数字？如果建立一个大堆，放进所有数字，那么最大的那几个一定是在前面的，这样取堆顶，然后pop掉（pop里面有向下调整），再取堆顶，就能找到前十个了。虽然这个思路可以，但是忘了一个重要的事，还是数据很大的问题。百亿个数字，建立一个百亿数字的大堆，这需要占用多少内存？算下来，几十G。所以，这个方法其实是不现实的。单论这个思路来讲，时间复杂度是N + logN * K，空间复杂度是O（1）。

现在换另一个思路，假设k就是10吧，前10个大的数字集合起来叫做O，用整个数据集里前10个数字作一个小堆，这个小堆都有哪些数字不需要担心，即使有O里面的数字也可，因为它一定大于其它所有的数字，也一定在堆里面靠下点的位置。之后遍历剩下的数字，每个都和现有小堆的堆顶比较，小于就无操作，大于就进堆，如果遇到O里面的数字，假设编号是O1 - O10，无论哪个数字，都一定会进堆，然后放在下面。假如遍历到最后时，才遇到O1或者O10也没有关系，遇到O1会进堆，此时其他数字都进来了，那么排在第一层的就相对来说是一个小数字，进入后不断向下调整，堆顶就会变为O10，最后整个堆就是O里的数字。O10也一样，一定会替换掉堆顶，自己做堆顶。其他哪一个O里的数字都一样。

而这样的时间复杂度是K + (N - K) * logK，空间复杂度为K。这种做法会直接在磁盘里读取数据，空间问题也就解决了。

接下来是代码展示。

先随机1000个数字，范围在10000之内

向下调整改成小堆

a[child + 1]以及a[child]后的 > 改成 <即为小堆。

测试函数

这里数组也可以malloc。

但是这还有一个问题，程序给出的结果就真的是最大的那10个吗？我们应该怎么判定？其实我们可以主动对数据做点动作，改变k个数据，让他们变成毫无疑问的最大。这里我把生成随机数也放进测试函数里。

所以最大的几个就出来了。

放出这篇所有代码

创建堆

void HeapCreate(HP* php, HPDataType* a, HPDataType n)
{
   assert(php);
   php->a = (HPDataType*)malloc(sizeof(HPDataType) * n);
   if (php->a == NULL)
   {
       perror("mealloc fail");
       exit(-1);
   }
   memcpy(php->a, a, sizeof(HPDataType) * n);
   php->size = php->capacity = n;
   for (int i = (n - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(php->a, n, i);
   }
}

排序

Top K

由于网络极致不要脸地无法十分钟传输一张图片，所以这里只能展示改过后的代码，而图片则没有。其实也不算是网络的事，是学校扯淡到极其可笑了。改动位置是随机设置k个超大数那里。

void TestHeap5()
{
   int k, n = 0;
   printf("请输入n和k: >");
   scanf("%d%d", &n, &k);
   srand(time(0));
   int j = 0;
   int i = 0;
   int num = k;
   FILE* fd = fopen("E:\\c start\\data.txt", "a");
   if (fd == NULL)
   {
       perror("fopen fail");
       return;
   }
   for (i = 0; i < n; i++)
   {
       j = rand() % 10000;
       //随机设置k个超大数
       if (num)
       {
           j = num + 100000;
           num--;
       }
       fprintf(fd, "%d\n", j);
   }
   fclose(fd);

   //找Top K
   int* minHeap = malloc(sizeof(int) * k);
   if (minHeap == NULL)
   {
       perror("malloc fail");
       return;
   }
   int m = 0;
   FILE* ft = fopen("E:\\c start\\data.txt", "r");
   if (ft == NULL)
   {
       perror("fopne fail");
       return;
   }
   for (int i = 0; i < k; i++)
   {
       fscanf(ft, "%d", &minHeap[i]);
   }
   for (int i = (k - 1 - 1) / 2; i >= 0; i--)
   {
       AdjustDown(minHeap, k, i);
   }
   while (fscanf(ft, "%d", &m) != EOF)
   {
       if (m > minHeap[0])
       {
           minHeap[0] = m;
           AdjustDown(minHeap, k, 0);
       }
   }
   for (int i = 0; i < k; i++)
   {
       printf("%-8d", minHeap[i]);
   }
   printf("\n");
   fclose(ft);
}