堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。堆即一颗二叉树，树中任一个非叶子节点的关键字均不大于（或者均不小于）其左右孩子（若存在）节点的关键字。

 其主要思想为构造一个堆结构，从第二个元素开始，如果此元素比起父节点的元素值大则交换此元素和其父节点，直到到达根节点，同样方法处理后面所以元素。此时第一个元素即为数组中最大的元素，将第一个元素和最后一个元素交换。此时对数组前n-1个元素构造一个合适的堆结构，对前n-1个元素做调整的步骤为：设开始父节点为根节点，如果存在左右子节点，则将父节点和大的节点比较，如果父节点较小则交换，如果不存在右节点和比较左子节点和父节点，如果父节点较小则和左子节点交换。将交换的节点设为下个父节点。直到父节点不含有左右子节点或不需要交换。

#include <iostream>

void AdjustHeap(int ary[], int len)
{
    int parent_pos;
    int left_child;
    int right_child;
    int pos = 0;

    while(1)
    {
        parent_pos = pos;
        left_child = 2 * parent_pos + 1;
        right_child = 2 * parent_pos + 2;
        if (right_child < len - 1 && left_child < len - 1)
        {
            pos = ary[right_child] > ary[left_child] ? right_child : left_child;
        }
        else if (left_child < len - 1)
        {
            pos = left_child;
        }
        else
            break;
        
        if (ary[pos] > ary[parent_pos])
        {
            int value = ary[pos];
            ary[pos] = ary[parent_pos];
            ary[parent_pos] = value;
        }
        else
            break;
    }
}

void CreateHeap(int ary[], int len)
{
    for (int i = 1; i < len; ++i)
    {
        int parent;
        int j = i;

        do
        {
            parent = (j - 1) / 2;

            if (ary[j] >= ary[parent])
            {
                int value = ary[parent];
                ary[parent] = ary[j];
                ary[j] = value;
            }

            j = parent;
        }
        while (parent);
    }
    
    
    for (int i = len - 1; i > 0; --i)
    {
        int tmp = ary[0];
        ary[0] = ary[i];
        ary[i] = tmp;
        AdjustHeap(ary, i);
    }
}

int main()
{
    //int ary[] = {10, 15, 56};
    int ary[] = {10, 15, 56, 25, 30, 70};
    CreateHeap(ary, sizeof(ary) / sizeof(ary[0]));

    for (int i = 0; i < sizeof(ary) / sizeof(ary[0]); ++i)
    {
        std::cout << ary[i] << " ";
    }

    std::cout << std::endl;
    system("pause");
    return 0;
}