堆排序

                                                 一 初识堆

堆 数据结构是一种数组，它可以视为一颗完全二叉树。如下图：

       

图中的树是数组，A={16, 14, 10, 8, 7, 9, 3, 7}，圈内表示数值，圈外红色的数字表示数组的下标。

array_size是数组的大小（此时是8），heap_size是构建堆的元素的多少。满足heap_size<= array_size

给定某结点的下表i,其父结点下标为PARENT(i), 左儿子下标为LEFT(i), 右儿子下标为RIGHT(i)。满足

         PARENT(i) = int((i-1)/2) ;   LEFT(i) = 2*i+1;   RIGHT(i)=2*i+2

最大堆满足：对于任何结点（除根节点）PARENT(i) > i

最小堆满足：对于任何结点（除根节点）PARENT(i) <i

叶子节点（下标）：int(i/2), int(i/2)+1......array_size

下面的介绍以最大堆为例

                                              二 保持堆的性质

       最大堆的性质为 PARENT(i) > i，因此对于特定的结点，应满足比左右儿子都大

、

    在上图中下标为1的结点值为2，左孩子为4，右孩子为1，1结点比左孩子小，就让1结点和3结点数值换过来。若此时4结点大于4，就把1结点和4结点数值换过来。

参考程序：

void MAX_HEAPIFY(int *A, int heap_size, int i)   //i 为待处理保持性质的结点下标
{
        int l = 2 * i + 1;                       //左孩子
        int r = 2 * i + 2;                       //右孩子
        int largest = i;
        if(l < heap_size && A[largest] < A[l])   // 左孩子数值大
        {
            largest = l;
        }
　　　　　if(r < heap_size && A[largest] < A[r])   //右孩子数值大
        {
            largest = r;
        }

        if(largest != i)
        {
            int tmp = A[i];
            A[i] = A[largest];
            A[largest] = tmp;
            MAX_HEAPIFY(A, heap_size, largest); //再从数值大的结点继续往下递归处理
        }
}

                                              三 构建堆

      从底向上使得每个结点保持堆的性质就可以构建堆，因为叶子节点就自己，无儿女，因此从倒数第一个非叶子节点开始依次往上构建，直到树根位置，而叶子节点开始的位置是int(i/2),因此第一个令其保持性质的结点下标为int((i-1)/2)。接着是int((i-1)/2-1)一直到0为止。下图表示了构建堆的详细过程：

图中有9个结点，int(9/2)= 4, 从4-1=3开始（依次是4 3 2 1 0）。注意是从后往前，为何不是从前往后，显然如果是上图中，从0开始，是6和3交换，我们知道在最大堆中根是最大的，可是从前往后的话，最大值7在无出头之日。

参考程序：

void BUILD_MAX_HEAP(int *A, int array_size, int heap_size)
{
        int i;
        for (i=array_size/2-1; i>=0; i--)
        {
            MAX_HEAPIFY(A, heap_size, i);
        }
}

                                              四 堆排序

      最大堆把最大值排到了首个位置A[0]，这是如果把最大值和最后一个值A[heap_size-1]换过来，再使A[0]保持堆的性质，再使heap_size自建。重复以上过程，就是个非递减排序。下图是一个事例过程：

参考程序：

void HEAP_SORT(int *A, int array_size, int heap_size)
{
        int tmp;
        BUILD_MAX_HEAP(A, array_size, heap_size);
        while(heap_size > 1)
        {
            tmp = A[0];
            A[0] = A[heap_size-1];
            A[heap_size] = tmp;
            heap_size--;
            MAX_HEAPIFY(A, heap_size, 0);
        }
}

测试

#include <iostream>
#include <vector>
using namespace std;
void maxHeapify(int A[], int lens, int i)
{
    if (A == NULL || i >= lens)
        return;
    int l = 2 * i + 1;
    int r = 2 * i + 2;
    int largest = i;
    if (l < lens || A[i] > A[largest])
        largest = l;
    if (r < lens && A[r] > A[largest])
        largest = r;
    if (largest != i)
    {
        int tmp = A[largest];
        A[largest] = A[i];
        A[i] = tmp;
        maxHeapify(A, lens, largest);
    }
}
void buildHeap(int A[], int lens)
{
    if (A == NULL || lens <= 0)
        return;
    int mid = (lens-2) / 2;
    for (int i = mid; i >= 0; --i)
        maxHeapify(A, lens, i);
}
void heapSort(int A[], int lens)
{
    buildHeap(A, lens);
    while (lens > 1)
    {
        int tmp = A[lens-1];
        A[lens-1] = A[0];
        A[0] = tmp;
        --lens;
        maxHeapify(A, lens, 0);
    }
}
void tranverse(int A[], int lens)
{
    if (A == NULL || lens <= 0)
        return;
    for (int i = 0; i < lens; ++i)
        cout << A[i] << "  ";
    cout << endl;
}
    
int main()
{
    int A[] = {3, 2, 8, 7, 0, 11};
    int lens = sizeof(A) / sizeof(*A);
    tranverse(A, lens);
//    buildHeap(A, lens);
//    tranverse(A, lens);
    heapSort(A, lens);
    tranverse(A, lens);
}

                                            

五 堆操作

1.HEAP_MAXIMUM(A) 找出最大的元素

int  HEAP_MAXIMUM(int *A)
{
        return A[0];
}

2.int HEAP_EXTRACT_MAX(int *A, int heap_size) 找出堆中最大元素，并删除，保持堆

int HEAP_EXTRACT_MAX(int *A, int heap_size)
{
        int max;
        max = A[0];
        A[0] = A[heap_size-1];
        heap_size--;
        MAX_HEAPIFY(A, heap_size, 0);
        
        return max;
}

3. void HEAP_INCREASE_KEY(int *A, int heap_size, int i, int key) 第i个位置出若key比原来大，就改成key,保持堆

void HEAP_INCREASE_KEY(int *A, int heap_size, int i, int key)
{
        int tmp;
        if(A[i] > key)
        {
            printf("The key is smaller than A[i]");
        }
        else
        {
            A[i] = key;
            while(i>=1 && A[(i-1)/2] < A[i])
            {
                tmp = A[i];
                A[i] = A[(i-1)/2];
                A[(i-1)/2] = tmp;
                i = (i-1)/2;
                MAX_HEAPIFY(A, heap_size, i);
            }
        }

}

4.void MAX_HEAP_INSERT(int *A, int array_size, int heap_size, int key) 堆中插入元素

void MAX_HEAP_INSERT(int *A, int array_size, int heap_size, int key)
{
        array_size++;
        heap_size++;
        A[heap_size] = -32768;
        HEAP_INCREASE_KEY(A, heap_size, heap_size-1, key);
}