最大堆排序

/*
 *最大堆排序
 *            Author: StoryMonster
 *  last change date: 2016/6/25
 */

#include <iostream>
#include <stdlib.h>

typedef struct HeapNode
{
    int value;
    int index;
    struct HeapNode *left;
    struct HeapNode *right;
    struct HeapNode *father;
} HeapNode;

int NodeCount = 0;
HeapNode *root = (HeapNode *)malloc(sizeof(HeapNode));
/*
 *维持最大堆的基本性质：value[father[node]] >= value[node]
 */
void MaxHeapify(HeapNode *node)
{
    HeapNode *n_left  = node->left;
    HeapNode *n_right = node->right;
    if(n_left == NULL) return ;
    else
    {
        if(n_left->value > node->value)
        {
            int temp = node->value;
            node->value = n_left->value;
            n_left->value = temp;
            if(node->father != NULL)
                MaxHeapify(node->father);
        }
        MaxHeapify(n_left);
    }
    if(n_right == NULL) return ;
    else
    {
        if(n_right->value > node->value)
        {
            int temp = node->value;
            node->value = n_right->value;
            n_right->value = temp;
            if(node->father != NULL) MaxHeapify(node->father);
        }
        MaxHeapify(n_right);
    }
}
bool InsertToFitPos(HeapNode *p, HeapNode *node)
{
    if((p->index)*2 == node->index)
    {
        p->left = node;
        node->father = p;
        return true;
    }
    if((p->index)*2+1 == node->index)
    {
        p->right = node;
        node->father = p;
        return true;
    }
    if(p->left == NULL || p->right == NULL)
    {
        return false;
    }
    bool kk = InsertToFitPos(p->left,node);
    if(kk == false) InsertToFitPos(p->right,node);
}
void Insert(HeapNode *node)
{
    NodeCount++;
    if(root == NULL)
    {
        root = node;
        return ;
    }
    HeapNode *p = root;
    InsertToFitPos(p,node);
    MaxHeapify(root);
}
HeapNode *GetMaxIndexNode(HeapNode *node)
{
    if(node->index == NodeCount) return node;
    else 
    {
        if(node->left == NULL && node->right==NULL)
            return NULL;
    }
    HeapNode *p = GetMaxIndexNode(node->left);
    if(p != NULL) return p;
    p = GetMaxIndexNode(node->right);
    if(p != NULL) return p;
}
void HeapSort(HeapNode *node,int arr[])
{
    int count = 0;
    while(NodeCount > 0)
    {
        arr[count++] = node->value;
        HeapNode *p = GetMaxIndexNode(root);
        int temp = node->value;
        node->value = p->value;
        p->value = temp;
        if(p->father!=NULL)
        {
            if((p->father)->left == p)  (p->father)->left = NULL;
            else (p->father)->right = NULL;
        }
        free(p);
        p = NULL;
        if(NodeCount > 1)
            MaxHeapify(root);
        NodeCount--;
    }
}
void ShowHeap(HeapNode *r)
{
    std::cout << "arr[" << (r->index)-1 << "]="<<r->value <<"-->";
    if(r->left!=NULL) std::cout << " left:" << (r->left)->value;
    else std::cout << " left:NULL" ;
    if(r->right!=NULL) std::cout << "  right:"<<(r->right)->value<<std::endl;
    else std::cout << " right:NULL"<<std::endl;
    if(r->left!=NULL) ShowHeap(r->left);
    if(r->right!=NULL) ShowHeap(r->right);
}
int main()
{
    int arr[10] = {8,5,3,7,12,14,0,1,15,16};
    int arr2[10] = {0};
    int i = 0;
    root = NULL;
    while(i < 10)
    {
        HeapNode *node = (HeapNode *)malloc(sizeof(HeapNode));
        node->father = NULL;
        node->left = NULL;
        node->right = NULL;
        node->index = i+1;
        node->value = arr[i];
        Insert(node);
        i++;
    }
    ShowHeap(root);
    HeapSort(root,arr2);
    for(i=0;i<10;i++)
    {
        std::cout << arr2[i] << "  ";
    }
    std::cout << std::endl;
    return 0;
}

运行结果

上图中最后一行是排序结果，前面是对应二叉树分布