值相同的C ++时的Minheap

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

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

我的bug位于minheap upheap downheap，删除或插入中。

我已经尝试了好几天，但我的大脑却无法应付，要做很多其他有趣的事情，例如模拟城市。 （不是，我必须完成此操作）

这是我的堆

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指针。 只需要弄清楚为什么它的顺序不正确。

我的程序适用于霍夫曼编码器，这里是： 我的文件

它具有一个在ubuntu 64系统上编译的make文件。 使用重定向输入。

上面的堆来自
回显“ Sally在海边出售的贝壳”>输入
./huff <输入

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;
}