最大堆与优先队列

//
//  main.c
//  FirstProgram
//
//  Created by Calvin Zang on 12-4-17.
//  Copyright (c) 2012年 SYSU. All rights reserved.
//
#include <stdio.h>
//for test
#include <time.h> //
#include <stdlib.h> //rand
//
#define N 1000
#define INF_MIN -9999

#define LEFT(x) ((x)<<1)
#define RIGHT(x) (((x)<<1)+1)
#define PARENT(x) ((x)>>1)

typedef int TYPE;
int heapSize, arrayLength;

void exchange(TYPE A[], int a, int b){ TYPE tmp = A[a]; A[a] = A[b]; A[b] = tmp;}
//int cmp(int a, int b){ return a - b;}//验证不稳定性
void maxHeapifyRecursive(TYPE A[], int i)
{
    /* Pre: Binary trees rooted at LEFT(i) and RIGHT(i) are maxheaps.
     *      A[0] is unused.
     */
    int l = LEFT(i), r = RIGHT(i), largest;
    if(l <= heapSize && A[l] > A[i])
        largest = l;
    else largest = i;
    if(r <= heapSize && A[r] > A[largest])
        largest = r;
    if( largest != i)
    {
        exchange(A, i, largest);
        maxHeapifyRecursive(A, largest);
    }
    
}

void maxHeapify(TYPE A[], int i)
{
    int l, r, largest;
    while(i <= heapSize)
    {
        l = LEFT(i); r = RIGHT(i);
        if(l <= heapSize && A[l] > A[i]) //if(l <= heapSize && cmp(A[l], A[i]) > 0)
            largest = l;
        else largest = i;
        if(r <= heapSize && A[r] > A[largest])//if(r <= heapSize && cmp(A[r], A[largest]) > 0)
            largest = r;
        if(largest != i)
        {
            exchange(A, largest, i);
            i = largest;
        }
        else break;
    }
}
void buildMaxHeap(TYPE A[])
{
    int i;
    heapSize = arrayLength;
    for(i = arrayLength/2; i>=1; --i)
        maxHeapify(A, i);
    
}
void heapSort(TYPE A[])
{
    int i;  
    buildMaxHeap(A);
    for(i = arrayLength; i >= 2; --i)
    {
        exchange(A, 1, i);
        heapSize--;
        maxHeapify(A, 1);
    }
}
void print(TYPE A[])
{
    int i;
    for(i = 1; i <= arrayLength; ++i)
    {
        printf("%d ", A[i]);
        if(i %10 == 0) printf("\n");
    }
    printf("\n");
}

/* MAX_PRIORITY_QUEUE
   INSERT(S,x)
   MAXIMUM(S)
   EXTRACT_MAX(S)
   INCREASE_KEY(S,X,K)
 */

TYPE heapMaximum(TYPE A[])
{
    return A[1];
}
TYPE heapExtractMax(TYPE A[])
{
    if(heapSize < 1){ /*perror*/printf("Error:empty heap!\n"); exit(1);}
    TYPE max = A[1];
    A[1] = A[heapSize];
    heapSize--;
    maxHeapify(A, 1);
    return max;
}
void heapIncreaseKey(TYPE A[], int i, TYPE key)
{
    if(key < A[i]){printf("New key is smaller than current key!\n");exit(1);}
    int parent = PARENT(i);
    A[i] = key;
    while(i>1 && A[parent]<A[i])
    {
        exchange(A, i, parent);
        i = parent; parent = PARENT(i);
    }
}
void maxHeapInsert(TYPE A[], TYPE key)
{
    heapSize++;
    A[heapSize] = INF_MIN;
    heapIncreaseKey(A, heapSize, key);
}

void maxHeapDelete(TYPE A[], int i)
{
    if(i <1 || i > heapSize){printf("Error:i is not in [1..heapSize]!\n");exit(1);}
    exchange(A, i, heapSize);
    heapSize--;
    maxHeapify(A, i);
}
//
//


/*
 0(h)1(e)2(l)3(l)4(o)5( )6( )7( )8( )9(w)10(o)11(r)12(l)13(d)14(!)15( )16( )17( )18(n)19(i)20(c)21(e)22( )hello    world!   nice 
 */

int main(int argc, const char * argv[])
{
    int A[] = {-1,16,14,10,8,7,9,3,2,4,1};
    arrayLength = 10;
    buildMaxHeap(A);
    int m;
    //heapIncreaseKey(A, 9, 15);
    maxHeapDelete(A, 2);
    print(A);
    while(heapSize > 0){
        m = heapExtractMax(A);
        printf("%d ", m);
    }
        
/*  //rand number test:
    arrayLength = N;
    int A[N+1];
    int i;
    srand(time(NULL));
    for(i = 1; i <= N; i++) A[i] = rand() % 10000;
    heapSort(A);
    typedef enum bool {false=0, true} bool;
    bool flag = true;
    for(i = 2; i <= N; ++i) if(A[i-1] > A[i]){flag = false; break;}
    
    if(flag) printf("right!\n");
    print(A);
*/  
    return 0;
}