堆

1、概念 ：

大堆：

任一节点的关键码均大于等于它的左右孩子的关键码位于堆顶的关键码最大。

小堆：

任一节点的关键码均小于等于它的左右孩子的关键码位于堆顶的关键码最小。

2、规则：

堆存储在下标为n的数组中，因此在给定下标为i的堆中：

3、堆的创建

1、创建最小堆原理：

从最后一个非叶子节点开始整理，一直到根节点为止，将每个节点及其子树调整到满足小堆的性质即可。

具体如下：

代码如下：
首先创建结构体：

typedef struct Heap{
     DataType arr[Max_Size];
     int size;
}Heap;

其次、堆得初始化：

void Init(Heap *pH,int *arr,int size )//初始化
{
     assert(pH);
     assert(size < Max_Size);
     pH->size = size;
     memcpy(pH->arr, arr, sizeof(DataType)*size);
}

最后。建堆

void CreateHeap(Heap *pH)//建最小堆
{
     int i = (pH->size-2)/2;//找最后一个节点的父节点
     int left;
     int right;
     int minchild;
     for (; i>=0; i--)
     {
          left = 2 * i + 1;
          right = 2 * i + 2;
          minchild = left;
          if ((right < pH->size)&&(pH->arr[right] < pH->arr[left]))
              minchild = right;
          if (pH->arr[i]>pH->arr[minchild])
          {
              swap(pH->arr+i, pH->arr+minchild);
          }
          AjustDown(pH, minchild);//向下调整
     }
}

建堆需要向下调整：

void AjustDown(Heap* pH, int root)
{
     int parent = root;
     int left;
     int right;
     int minchild;
     while (parent<pH->size)
     {
          left = parent * 2 + 1;
          right = parent * 2 + 2;
          if (left > pH->size)
              return;
          minchild = left;
          if ((right < pH->size)&&(pH->arr[right] < pH->arr[left]))
              minchild = right;
          if (pH->arr[minchild] < pH->arr[parent])
              swap(pH->arr+minchild, pH->arr+parent);
          parent = minchild;
     }
}

2、从最小堆中取得堆顶元素

DataType Top(Heap* pH)
{
     assert(pH);
     return pH->arr[0];
}

3、从堆中删除一个元素

删除只能删除堆顶的元素。
方法：将堆中的最后一个元素和堆顶元素交换，再将堆的大小减1，最后向下调整。

void HeapPop(Heap* pH)//在堆上删除一个数只能删除堆顶的数据
{
     assert(pH);
     pH->arr[0] = pH->arr[pH->size-1];
     --pH->size;
     AjustDown(pH, 0);
}

4、向堆中加入一个数据

加入一个数据，只能从后面加，加了之后再想上调整，知道寻到合适的位置。

void HeapPush(Heap* pH, DataType data)
{
     assert(pH);
     pH->arr[pH->size] = data;
     pH->size++;
     AjustUp(pH, data);
}

向上调整：

void AjustUp(Heap* pH, DataType child)
{
     assert(pH);
     int parent = (child + 1) / 2;
     while (parent)
     {
          parent = (child + 1) / 2;
          if (pH->arr[child] > pH->arr[parent])
          {
              return;
          }
          swap(pH->arr + child, pH->arr + parent);
          child = parent;
     }
}

5、堆排序

void HeapSort1(int arr[], int size)
{
     int i = size-2/2;
     for (; i>=0; i--)
     {
          AdjustDownMax(arr, size, i);
     }
     for (i = 0; i < size; i++)
     {
          Swap(arr + 0, arr +size - i-1);
          AdjustDownMax(arr, size - i - 1, 0);
     }
}

void AdjustDownMax(int arr[], int size, int Root)
{
     int parent = Root;
     int left ;
     int right ;
     int maxchild;
     while (parent < size)
     {
          left = parent * 2 + 1;
          right = parent * 2 + 2;
          if (left>=size)
              return;
          maxchild = left;
          if ((right < size) && (arr[left] < arr[right]))
              maxchild = right;
          if (arr[maxchild] < arr[parent])
              return;
          Swap(arr + maxchild, arr + parent);
          parent = maxchild;
     }
}