浙大数据结构：05-树7 堆中的路径

这道题主要难在创建一个小根堆，输出并不难，而创建代码可以参考MOOC上代码。

1、条件准备

定义结构体，data数组来存储堆的，size是当前堆的大小，MaxSize是堆的最大大小。

#include <iostream>
using namespace std;

typedef int ElementType;
typedef int position;
typedef struct HNode   
{
  ElementType *data;
  int size ;
  int MaxSize;
}* Heap;

typedef Heap MinHeap;

#define MIN -20000

主函数先是读入结点数量，输出组数。

然后初始化一下堆，输入元素建立小根堆。

然后循环调用solve函数输出每一组的数据。

f是用来控制输出格式的保证没有多余空格。

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int n, l;
  cin >> n >> l;
  MinHeap H = createheap(5);
  for (int i = 0; i < n; i++)
  {
    int elem;
    cin >> elem;
    insert(H, elem);
  }
  int f = 0;
  for (int i = 0; i < l; i++)
  {
    if (f)
      cout << endl;
    int node;
    cin >> node;
    solve(H, node);
    f = 1;
  }

  return 0;
}

2、createheap函数

分配空间，一般多分配一点。

初始化里面数据，data[0]作为哨兵结点。

MinHeap createheap(int maxsize)
{
  MinHeap H = (MinHeap)malloc(sizeof(struct HNode));
  H->data = (ElementType *)malloc(sizeof(ElementType) * (maxsize + 5));
  H->size = 0;
  H->MaxSize = maxsize;
  H->data[0] = MIN;
  return H;
}

3、insert函数

将x插入到堆末尾，然后循环与其父亲结点比较，比它小就交换，直到不小于。

这里利用完全二叉树的性质：如果根节点标为1的话，则树中每一个结他的左节点为2i，右结点为2i+1。

bool insert(MinHeap H, ElementType x)
{
  int i;
  i = ++H->size;
  for (; H->data[i / 2] > x; i /= 2)
  {
    H->data[i] = H->data[i / 2];
  }
  H->data[i] = x;
  return true;
}

4、solve函数

传入起始位置，然后一直输出，下一次的位置为当前位置的父亲结点的位置。

f是为了控制没有多余空格输出。

void solve(MinHeap H, position x)
{
  int f = 1;
  for (; x; x /= 2)
  {
    if (f)
    {
      cout << H->data[x];
      f = 0;
    }
    else
      cout << ' ' << H->data[x];
  }
}

5、总结

该题主要考察堆的相关性质，以及完全二叉树的性质，难度不算大。

完整代码如下：

#include <iostream>
using namespace std;

typedef int ElementType;
typedef int position;
typedef struct HNode
{
  ElementType *data;
  int size;
  int MaxSize;
} *Heap;

typedef Heap MinHeap;

#define MIN -20000

MinHeap createheap(int maxsize)
{
  MinHeap H = (MinHeap)malloc(sizeof(struct HNode));
  H->data = (ElementType *)malloc(sizeof(ElementType) * (maxsize + 5));
  H->size = 0;
  H->MaxSize = maxsize;
  H->data[0] = MIN;
  return H;
}

bool insert(MinHeap H, ElementType x)
{
  int i;
  i = ++H->size;
  for (; H->data[i / 2] > x; i /= 2)
  {
    H->data[i] = H->data[i / 2];
  }
  H->data[i] = x;
  return true;
}

void solve(MinHeap H, position x)
{
  int f = 1;
  for (; x; x /= 2)
  {
    if (f)
    {
      cout << H->data[x];
      f = 0;
    }
    else
      cout << ' ' << H->data[x];
  }
}

int main()
{
  ios::sync_with_stdio(false);
  cin.tie(0), cout.tie(0);
  int n, l;
  cin >> n >> l;
  MinHeap H = createheap(5);
  for (int i = 0; i < n; i++)
  {
    int elem;
    cin >> elem;
    insert(H, elem);
  }
  int f = 0;
  for (int i = 0; i < l; i++)
  {
    if (f)
      cout << endl;
    int node;
    cin >> node;
    solve(H, node);
    f = 1;
  }

  return 0;
}

附录：堆的定义与操作

#include <iostream>
using namespace std;

typedef int ElementType;

typedef struct HNode   
{
  ElementType *data;
  int size ;
  int MaxSize;
}* Heap;

typedef Heap MaxHeap;
typedef Heap MinHeap;

#define MAX 1000

MaxHeap createheap(int maxsize)
{
  MaxHeap H=(MaxHeap)malloc(sizeof(struct HNode));
  H->data=(ElementType*)malloc(sizeof(ElementType)*(maxsize+1));
  H->size=0;
  H->MaxSize=maxsize;
  H->data[0]=MAX;
  return H;
}

bool isfull (MaxHeap H)
{
  return (H->size==H->MaxSize);
}
bool insert(MaxHeap H ,ElementType x)
{
  int i;
  if(isfull(H))return false;

  i=++H->size;
  for(;H->data[i/2]<x;i/=2)
  {
    H->data[i]=H->data[i/2];
  }
  H->data[i]=x;
  return true;

}

#define ERROR -1

bool isempty(MaxHeap H)
{
  return H->size==0;
}

ElementType deletemax(MaxHeap H)
{
 int parent ,child;
 ElementType maxitem,x;
 if(isempty(H))return ERROR;

 maxitem=H->data[1];
 x=H->data[H->size--];

 for(parent=1;parent*2<=H->size;parent=child)
 {
  child=parent*2;
  if(child!=H->size&&H->data[child]<H->data[child+1])
  child++;
  if(x>=H->data[child])break;
    else H->data[parent]=H->data[child];
 }

 H->data[parent]=x;
  return maxitem;

}

void  percdown(MaxHeap H,int p)
{
  int parent,child;
  ElementType x;

  x=H->data[p];
for(parent=p;parent*2<=H->size;parent=child)
{
  child=parent*2;
  if(child!=H->size&&H->data[child]<H->data[child+1])
   child++;
  if(x>=H->data[child])break;
  else H->data[parent]=H->data[child];
}
H->data[parent]=x;

} 

void buildheap(MaxHeap H)
{
  int i;
  for(i=H->size/2;i>0;i--)
  {
    percdown(H,i);
  }
}