通用的堆排函数思想 :
1.对任意一个点进行调整, 需要往两个方向, 父节点和左右子节点进行比较, 交换
2.传入不同的比较函数使得函数变成通用的
对一堆数据，需要用堆排:
（1）. 插入方法建堆 （实际工作中这种是更常见）
（2）. 基于当前数组进行建堆
比较函数 , 交换函数， 打印函数 :
#include "common.h"
/**
* heap_size 此次调整堆的最大元素个数(因为堆排序过程中，后面已经调整好的就不需要调整了)
* pos 表示此次调整堆的节点
* */
typedef struct Heap
{
int heap[100];
int tail;
}Heap;
static int Compare(int idA, int idB)
{
return idA - idB;
}
//交换堆中任意两个数
static void Swap(Heap *pheap, int posA, int posB)
{
int ID1 = pheap->heap[posB];
int ID2 = pheap->heap[posA];
pheap->heap[posA] = ID2;
pheap->heap[posB] = ID1;
}
//打印堆中的数据
static void printHeap(Heap *pheap)
{
for (int i = 1; i < pheap->tail; i++) //从 index = 1 开始保存数据
{
printf("%d ", pheap->heap[i]);
}
printf("
");
}
通用的 堆 调整函数 :
#define parent (pos >> 1) //获得该父节点的左孩子
#define left (pos << 1) //获得该父节点的左孩子
#define right (pos*2 + 1) //获得该父节点的右孩子, 为啥不能((pos<<2) + 1)
static void adjustHeap(Heap *pheap, int pos, int Compare(int idA, int idB)) // heap_size --> tail
{
if (pos <= 0)
{
return;
}
int old_pos = pos;
while (pos > 1 && Compare(pheap->heap[parent], pheap->heap[pos]) < 0)
{
Swap(pheap, pos, parent);
pos = parent;
}
pos = old_pos;
while ((left < pheap->tail && Compare(pheap->heap[left], pheap->heap[pos]) > 0)
|| (right < pheap->tail && Compare(pheap->heap[right], pheap->heap[pos]) > 0))
{
if ((left < pheap->tail && Compare(pheap->heap[left], pheap->heap[pos]) > 0)
&& (right < pheap->tail && Compare(pheap->heap[right], pheap->heap[pos]) > 0))
{
if (Compare(pheap->heap[left], pheap->heap[right]) > 0) {
Swap(pheap, pos, left);
pos = left;
}
else
{
Swap(pheap, pos, right);
pos = right;
}
}// tail == 12 的时候, pos = 6, 又跟已经交换到 12 的值为 18 的元素交换, 所以不能用 <=
else if (left < pheap->tail && Compare(pheap->heap[left], pheap->heap[pos]) > 0)
{
Swap(pheap, pos, left);
pos = left;
}
else if (right < pheap->tail && Compare(pheap->heap[right], pheap->heap[pos]) > 0)
{
Swap(pheap, pos, right);
pos = right;
}
}
}
插入式建堆 :
static void maxHeapInsert(Heap *pheap, int key) { int old_pos = pheap->tail; pheap->heap[old_pos] = key; pheap->tail++; adjustHeap(pheap, old_pos, Compare); //在哪个节点插入就更新那个节点 } extern void test_heap_qfh() { //simple test int arr[] = { 20,14,10,8,7,9,3,2,4,1,80,50,40,70,11,19,12,18,23,35,22 }; // 这个不考虑 0 号元素， 可能好一点 int len = sizeof(arr) / sizeof(arr[0]); // no need to consider number 0, so the len is 9 only printf("%s %d : arr len = %d ", __FUNCTION__, __LINE__, len); Heap heap; heap.heap[0] = 0; // 源数组是有值的 heap.tail = 1; // 从 0 开始计算, 才满足 父节点 = i , 左子节点 = 2*i, 右子节点 = 2*i + 1 LOGE("will build max heap"); //build heap (插入式创建 heap) for (int i = 0; i < len; i++) { maxHeapInsert(&heap, arr[i]); printHeap(&heap); } LOGE("will sort all the heap"); for (int heap_size = len; heap_size >= 2; heap_size--) // heap_size is size of not sort of heap , from tail-1 to 1 { heap.tail--; //先将 tail - 1， 因为 tail-1 才是保存有数据的 Swap(&heap, 1, heap.tail);//将堆顶元素（通过调整堆获得的最大值）和最后一个交换（剩余未排好序部分的最后一个） adjustHeap(&heap, 1, Compare);//之后每次从堆顶开始调整，最大的值将上升到根节点 printHeap(&heap); }
heap.tail = len + 1; printHeap(&heap); }
进队 :
test_heap_qfh 101 : arr len = 21 e:c++c_testc_testheap_sort_not_use0-qfh.cpp test_heap_qfh 107 : will build max heap 20 20 14 20 14 10 20 14 10 8 20 14 10 8 7 20 14 10 8 7 9 20 14 10 8 7 9 3 20 14 10 8 7 9 3 2 20 14 10 8 7 9 3 2 4 20 14 10 8 7 9 3 2 4 1 80 20 10 8 14 9 3 2 4 1 7 80 20 50 8 14 10 3 2 4 1 7 9 80 20 50 8 14 40 3 2 4 1 7 9 10 80 20 70 8 14 40 50 2 4 1 7 9 10 3 80 20 70 8 14 40 50 2 4 1 7 9 10 3 11 80 20 70 19 14 40 50 8 4 1 7 9 10 3 11 2 80 20 70 19 14 40 50 12 4 1 7 9 10 3 11 2 8 80 20 70 19 14 40 50 12 18 1 7 9 10 3 11 2 8 4 80 23 70 20 14 40 50 12 19 1 7 9 10 3 11 2 8 4 18 80 35 70 20 23 40 50 12 19 14 7 9 10 3 11 2 8 4 18 1 80 35 70 20 23 40 50 12 19 22 7 9 10 3 11 2 8 4 18 1 14 //这是大顶堆 , 实际排序后将跟最后一个未排数据进行交换, 最终得到的数据是 从小到大排列
index 1 和 index = tail-1 进行交换 :
e:c++c_testc_testheap_sort_not_use0-qfh.cpp test_heap_qfh 115 : will sort all the heap 70 35 50 20 23 40 14 12 19 22 7 9 10 3 11 2 8 4 18 1 50 35 40 20 23 10 14 12 19 22 7 9 1 3 11 2 8 4 18 40 35 18 20 23 10 14 12 19 22 7 9 1 3 11 2 8 4 35 23 18 20 22 10 14 12 19 4 7 9 1 3 11 2 8 23 22 18 20 8 10 14 12 19 4 7 9 1 3 11 2 22 20 18 19 8 10 14 12 2 4 7 9 1 3 11 20 19 18 12 8 10 14 11 2 4 7 9 1 3 19 12 18 11 8 10 14 3 2 4 7 9 1 18 12 14 11 8 10 1 3 2 4 7 9 14 12 10 11 8 9 1 3 2 4 7 12 11 10 7 8 9 1 3 2 4 11 8 10 7 4 9 1 3 2 10 8 9 7 4 2 1 3 9 8 3 7 4 2 1 8 7 3 1 4 2 7 4 3 1 2 4 2 3 1 3 2 1 2 1 1
最终拍好的数据 :
1 2 3 4 7 8 9 10 11 12 14 18 19 20 22 23 35 40 50 70 80