#include "stdafx.h"
Status init_priority_queue(priority_queue* pq)
{
  //初始化優先隊列pq
    pq->n=1;
    return OK;
}

/*Edge* IninEdge(int a,int b,int c)
{
  Edge* t=(Edge*) malloc (sizeof(Edge)); 
  t->v=a;
  t->w=b;
  t->weight = c;  
  return t;    
} 
 */
 Status Destory_priority_queue(priority_queue* pq)
 {//銷毀優先隊列
   int i; 
   for(i=1;i<pq->n;i++)
   free(pq->h[i]) ;     
   free(pq);
   return OK;     
 } 

Status max_heapify(priority_queue* pq,int i)
{
  //每次插入后進行的堆調整，因為每次都插入到最后，前面的元素都符合堆的要求，
  //調整成功返回0，不成功返回-1
  Edge* temp; 
 while(i>1)
 {
   int p = i/2 ;
   if(pq->h[i]->weight<pq->h[p]->weight)
   {
     //swap(pq->h[i],pq->h[p]); 
     temp = pq->h[i];
     pq->h[i]= pq->h[p];
     pq->h[p] =temp;         
     i=p;
   }
   else break;
 } 
 return OK;
}
/*
int min_heapAdjust(priority_queue& pq,int n)
{
//已知pq[1....n-1]中記錄的關健字除pq[1]外均滿足堆的定義，本函數調整L[1]的關健字
//使L[1...n-1]成為一個小頂堆,調整成功返回0，不成功返回-1
 int s = 1;
 Edge rc = pq.h[1];
 for(;s<=n-1;)
 {
    int j = 2*s;
    if(j<n-1 && pq.h[j].weight>pq.h[j+1].weight) ++j; //j為左右兄弟中最小的那個元素的下標
    if(rc.weight<=pq.h[j].weight)break; //找到rc所放的位置
   
        pq.h[s]=pq.h[j];
        s=j;
   
 } 
 pq.h[s]=rc;
 return 0;
}
*/

Status min_heapAdjust(priority_queue* pq,int n)
{//已知pq[1....n-1]中記錄的關健字除pq[1]外均滿足堆的定義，本函數調整L[1]的關健字
//使L[1...n-1]成為一個小頂堆,調整成功返回0

 int i=1;
 Edge* temp;
 int left,right, smallest; 
 for(;;)
 {
   left=i*2;
   right=left+1;
  if(left>=n)
   break;
  if(right>=n)
   smallest=left;
  else
  {
      if(pq->h[left]->weight<pq->h[right]->weight)
    smallest=left;
   else
    smallest=right;
  }
  if(pq->h[smallest]->weight<pq->h[i]->weight)
  {
  // swap(pq.h[smallest],pq.h[i]);
   temp =pq->h[smallest] ;
   pq->h[smallest] =  pq->h[i] ;
   pq->h[i] = temp ; 
   i=smallest;
  }
  else
   break;
 }
 return OK;
}


Status insert_priority_queue(priority_queue* pq,Edge* t)
{
  //向隊列pq中插入一元素 t, 操作成功返回0，操作失敗返回-1
   if(pq->n>MAX_NUM) return OVERFLOW;
   pq->h[pq->n]=t;
   max_heapify(pq,pq->n); //插入后要進行調整
   pq->n++;
   return OK;
}

Edge* extract_min(priority_queue* pq)
{//隊列pq中返回最小值，并也刪除了最小值 
 
  Edge* temp =pq->h[1];
  pq->h[1]=pq->h[ pq->n-1 ] ; //把最后一個元素調整為根
  --pq->n; //刪除第一個元素，也就是最小的元素
  min_heapAdjust(pq,pq->n);
  return temp;

}

Edge* Get_Min(priority_queue* pq)
{
  //僅僅從隊列pq中獲得了最小值
  return pq->h[1];
}

int isEmpty(priority_queue* pq)
{
  //隊列為空返回true, 否則返回false
    return pq->n>1? 0 :1 ;
}