C++构建堆

class Heap{
public:
    Heap(int);
    ~Heap();
    void maxHeap(int x);
    int leftChild(int x);
    int rightChild(int x);
    int parent(int x);
    void init(int *);
    void constructHeap();
    void print();
    void insertHeap(int );
private:
    int *heap;
    int m_size;
};

Heap::Heap(int size):m_size(size){
    heap = (int*) malloc(sizeof(int) * m_size);
}

Heap::~Heap(){
    free(heap);
}

int Heap::leftChild(int x){
    return 2 * x +1;
}

int Heap::rightChild(int x){
    return 2 * x + 2;
}

int Heap::parent(int x){
    return (x-1)/2;
}

void Heap::maxHeap(int x){
    int max = 0;
    if(leftChild(x) < m_size){
        max = leftChild(x);
        if( (rightChild(x) < m_size) && (heap[max] < heap[rightChild(x)])){
            max = rightChild(x);
        }
        if(heap[max] > heap[x]){
            swap(heap[x] , heap[max]);
        }
        maxHeap(max);
    }else{
        return;
    }

}

void Heap::init(int* x){
    for(int i = 0 ; i < m_size ;++i){
        heap[i] = x[i];
    }
}

void Heap::constructHeap(){
    for(int i = (m_size - 1)/2 ; i >= 0 ;--i ){
        maxHeap(i);
    }
}

void Heap::print(){
    for(int i = 0 ; i < m_size ; ++i){
        cout<<heap[i]<<" ";
    }
    cout<<endl;
}

void Heap::insertHeap(int d){
    if(heap[0] > d){
        heap[0] = d;
        maxHeap(0);
    }
}

struct Node{
    int data;
    struct Node* next;
    Node(int k){
        data = k;
        next = NULL;
    }
};

链表：

class LinkList{
public:
    void insert(int d);
    void print();
    LinkList();
    void reverse();
private:
    Node* head;
};

void LinkList::insert(int d){
    if(head == NULL){
        head = new Node(d);
    }else{
        Node* p = head;
        while(p->next != NULL){
            p = p->next;
        }
        p->next = new Node(d);
    }
}

void LinkList::print(){
    Node* p = head;
    while(p != NULL){
        cout<<p->data<<endl;
        p = p->next;
    }
}

LinkList::LinkList(){
    head = NULL;
}

void LinkList::reverse(){
    Node* p = head;
    Node* q = head->next;
    Node* r = head->next->next;
    p->next = NULL;
    while(r != NULL){
        q->next = p;
        p = q;
        q = r;
        r = r->next;
    }
    q->next = p;
    head = q;
}