Question

所以我做了一堆二叉树。为了测试它，我创建了一组具有2个不同值的节点。

说

struct node 
{
   int frequency;
   int data;
}

说频率是堆主要排序的频率，但如果节点频率相同，则按节点数据排序。

当我制作一堆节点时，加载堆，然后弹出并打印它们（大小，树中有多少个节点，min是每棵树保存的最小数据）

Data    Freq    Size    Min
10      1       1       10
84      1       1       84
115     1       1       115
66      1       1       66
114     1       1       114
100     1       1       100
121     2       1       121
111     2       1       111
104     3       1       104
97      3       1       97
101     5       1       101
108     5       1       108
83      6       1       83
32      9       1       32

如果您没有注意到，第三个条目是错误的，因此堆错了。

我的错误位于minheap upheap的某处，删除或插入。

我已经尝试了好几天，我的大脑根本无法处理它，还有很多其他有趣的事情，比如sim city。（不是真的，我必须完成这个）

这是我的堆

class MinHeap
{
  public:
    int length;
    MinHeap(int mVal );

   ~MinHeap();

    int size();  // returns N, the size of the heap
    void insert(node* e);
    node* remove();
    void printheap();

  private:

    node **a;  // Array of pointers

    int MaxSize;
    int N;      // current size of heap
    int itemMin;
    void upheap(int k);
    void downheap(int k);

   };


MinHeap::MinHeap(int mVal)
{
   a = new node*[mVal+1]();  //  a**  is an array of pointers;
   N=0;  // Sets heap size to zero
   a[0]= new node();
   length = mVal+1;
   MaxSize = mVal;
   itemMin = -32767; // Minimum Heap
   a[0]->frequency= itemMin ;
}

MinHeap::~MinHeap()
{ delete [] a;}

void MinHeap::upheap(int k)
{
node *e = a[k]  ;
while( e->frequency < a[k/2]->frequency  )
    {
        a[k] = a[k/2] ;    //move parent down
        k = k/2 ;
    }
while(e->frequency == a[k/2]->frequency && e->minkey < a[k/2]->minkey)
    {
        a[k] = a[k/2] ;    //move parent down
        k = k/2 ;
    }
 a[k] = e ;

}


void MinHeap::downheap(int k)
{
   int j = 2 * k ;     
   node *e = a[k] ;

   while (j <= N) {

    if ((j < N) && (a[j+1]->frequency < a[j]->frequency)) j++ ;

    if((j<N) && (a[j+1]->frequency == a[j]->frequency) && (a[j+1]->minkey > a[j]->minkey ))j++;

    if (( e->frequency <= a[j]->frequency) ) break;

    a[j/2] = a[j];  // move child up
    j *= 2;         // move child down a level
}
a[j/2] = e;
}


void MinHeap::insert(node* e)
{
a[++N] = e ;
upheap(N) ;
}


node* MinHeap::remove()
{
node *e = a[1];

a[1] = a[N--]; downheap(1) ;
return &(*e);
}

我应该提到我需要创建自己的STL类，如果频率相同，则假设堆也选择树中保存的最小值的优先级，这就是minkey指针在码。只需要弄清楚为什么它的顺序不正确。

我的程序适用于霍夫曼程序员，这里是： My Files

它有一个make文件，可以在ubuntu 64系统上编译。使用重定向进行输入。

上面的堆来自于回声“Sally出售的海边海壳”＆gt;输入
./huff＆lt;输入

Answer 1

所以我设法弄明白了，我觉得这有点愚蠢。

在我的minheap downheap函数中

void MinHeap::downheap(int k)
{
int j = 2 * k ;     node *e = a[k] ;
while (j <= N) {

    if (( (j < N) && (a[j+1]->frequency < a[j]->frequency) ) ||  ( (j < N) && (a[j+1]->frequency == a[j]->frequency) && a[j+1]->minkey < a[j]->minkey )     ) j++ ;
   //((a[j+1]->frequency == a[j]->frequency) && (a[j+1]->minkey > a[j]->minkey ))j++;

   if (( e->frequency < a[j]->frequency) ) break;
   if((e->frequency == a[j]->frequency && e->minkey < a[j]->minkey)) break;


    a[j/2] = a[j];  // move child up
    j *= 2;         // move child down a level
}
a[j/2] = e;
}

当值与C ++相同时，Min Heap

1 个答案: