Young氏矩阵

Young氏矩阵

利用堆思想实现Young氏矩阵

#include <iostream>
class YoungTableau {
private:
    int *array;
    int row;
    int column;
    int heap_size;
public:
    YoungTableau(int *array,int length,int row,int column);

private:
    void build_heap();
    void heapify(int index);
    int right_neighbor(int index);
    int down_neighbor(int index);
    int left_neighbor(int index);
    int up_neighbor(int index);
    void increase_key(int key,int index);
    void left_check(int key,int index);
    bool up_check(int key,int index);

public:
    int extra_min();
    void insert(int key);
    bool is_full();
    bool is_empty();
};

#include "YoungTableau.h"
YoungTableau::YoungTableau(int *array,int length, int row, int column) :row(row),column(column){
    this->array = new int [row * column];
    for (int i = 0; i < row*column; ++i) {
        this->array[i] = INT_MAX;
    }
    heap_size  = 0;
    for (int i = 0; i < length; ++i) {
        insert(array[i]);
    }
}
void YoungTableau::build_heap()
{
    for (int i = row*column - 1; i >=0 ; i--) {
        heapify(i);
    }
}
void YoungTableau::heapify(int index)
{
    int r = right_neighbor(index);
    int d = down_neighbor(index);
    int smallest = index;
    if(r != INT_MAX && array[r] < array[smallest])
        smallest = r;
    if(d != INT_MAX && array[d] < array[smallest])
        smallest = d;
    if(smallest != index)
    {
        int temp = array[smallest];
        array[smallest] = array[index];
        array[index] = temp;
        heapify(smallest);
    }
}
int YoungTableau::right_neighbor(int index){
    int next = index + 1;
    if(next % column == 0) return INT_MAX;
    return next;
}
int YoungTableau::down_neighbor(int index)
{
    int next = index + column;
    if(next >= row * column)return INT_MAX;
    return next;
}
int YoungTableau::left_neighbor(int index)
{
    if(index % column == 0) return INT_MAX;
    return index - 1;
}
int YoungTableau::up_neighbor(int index){
    int next = index - column;
    if(next<0) return INT_MAX;
    return next;
}
int YoungTableau::extra_min(){
    if(is_empty())
    {
        perror("table is empty");
        return INT_MAX;
    }
    heap_size -- ;
    int min = array[0];
    array[0] = INT_MAX;
    heapify(0);
    return min;
}
void YoungTableau::increase_key(int key,int index)
{
    if(array[index]<key)
    {
        perror("new key underflow");
        return;
    }
    array[index] = key;
    if(!up_check(key,index))
        left_check(key,index);
}
void YoungTableau::left_check(int key,int index){
    if(array[index]<key)
    {
        return;
    }
    int l_n = left_neighbor(index);
    if(l_n != INT_MAX && key < array[l_n])
    {
        array[index] = array[l_n];
        array[l_n] = key;
        left_check(key,l_n);
    }
}
bool YoungTableau::up_check(int key,int index){
    int u_n = up_neighbor(index);
    if(u_n != INT_MAX && key < array[u_n])
    {
        array[index] = array[u_n];
        array[u_n] = key;
        left_check(array[index],index);
        if(!up_check(key,u_n))
            left_check(key,u_n);
        return true;
    }
    return false;
}
void YoungTableau::insert(int key){
    if(is_full())
    {
        perror("table is full");
        return;
    }
    heap_size++;
    array[heap_size - 1] = INT_MAX;
    increase_key(key,heap_size-1);
}
bool YoungTableau::is_full()
{
    if(array[row*column - 1] == INT_MAX) return false;
    return true;
}
bool YoungTableau::is_empty(){
    if(array[0] == INT_MAX) return true;
    return false;
}