一些烂代码（自娱自乐）之堆

heap::heapify(int n)                  
 
{
   int l,r,largest;                             
   l=left(i)
   if(l<heapsize)
    if(a[i]<a[l])
     largest=l;
   r=right(i);
   if(r<heapsize)
    if(a[largest]<a[r])
     largest=r;
   int tmp=a[i];
   a[i]=a[largest];
   a[largest]=tmp;
   heapify(largest);             //仿算法导论写的递归维持堆性质的代码
}

void heapify(int* a,int n)
{
   int l=left(n),r=right(n);
   while(l<heapsize&&a[i]<a[l]||r<heapsize&&a[i]<a[r])
  {
      int largest=a[l]>a[r]?l:r;
      int tmp=a[i];
      a[i]=a[largest];
      a[largest]=tmp;
      i=largest;
      l=left(i);
     r=right(i);                   //用while循环消除尾递归的代码
   }
}

从数组构造堆

makeheap(int* a)
{
  int length=size(a);
  heapsize=length;
  for(int i=length/2;i>=0;i--)
 {
   heapify(a,i);
  }
 }               //从直觉上看时间复杂度为o（nlogn),但有数学家证出了实际复杂度为o(n) :)
     

 void heapsort(int *a)
{
   makeheap(a);
  for(int i=size(a)-1;i>=1;i++)
 {
    int tmp=a[i];
    a[i]=a[0];
    a[0]=a[i];
    heapsize=heapsize-1;
    heapify(a,0);
  }
}          //堆排序

int ExtractMax(int* a)
{
   if(heapsize<1)
   error("there is no instance");
   int result=a[0];
   a[0]=a[heapsize];
   heapsize--;
   heapify(a);
   return result;
}                     //提取堆最大的元素

 

 insert(int* a,int key)
{
   heapsize++;
   a[heapsize]=key;
   i=heapsize;
   while(i>=1&&a[parent(i)]<key){
     a[i]=a[parent(i)];
     i=parent(i);}
   a[i]=key
}            //消除尾递归