#include<iostream>

using namespace std;

struct TreeNode;
typedef struct TreeNode *PriorityQueue;

PriorityQueue Init(void);
int FindMin(PriorityQueue H);
bool IsEmpty (PriorityQueue H);
PriorityQueue Merge(PriorityQueue H1,PriorityQueue H2);  //合并操作

#define Insert(x,H) (H = Insert1(x,H))

PriorityQueue Insert1 (int x,PriorityQueue H);
PriorityQueue DeleteMin1(PriorityQueue H);

struct TreeNode
{
   int Element;
   PriorityQueue Left;
   PriorityQueue Right;
   int Npl;   //零路径长，节点X到一个没有两个儿子的节点的最短路径的长
};

static void SwapChildren (PriorityQueue H)   //交换根节点的左右子树
{
  PriorityQueue temp;
  temp = H->Right;
  H->Right = H->Left;
  H->Left = temp;
}
static PriorityQueue Merge1(PriorityQueue H1,PriorityQueue H2)
{
   if(H1->Left == NULL)  //H1为单点，就一个元素
	   H1->Left = H2;
   else
   {
      H1->Right = Merge(H1->Right,H2);
	  if(H1->Left->Npl < H1->Right->Npl)
		  SwapChildren(H1);
	  H1->Npl = H1->Right->Npl + 1;
   }
   return H1;
}

PriorityQueue Merge(PriorityQueue H1,PriorityQueue H2)     //处理特殊情况 
{
   if(H1 == NULL)
	   return H2;
   if(H2 == NULL)
	   return H1;
   if(H1->Element < H2->Element )
	   return Merge1(H1,H2);
   else
	   return Merge1(H2,H1);
}


PriorityQueue Insert1(int x,PriorityQueue H)   //把x看成但节点，执行合并操作，思想很巧妙
{
   PriorityQueue SingleNode;
   SingleNode = (PriorityQueue)malloc(sizeof(struct TreeNode));
   if(SingleNode == NULL) cout << "out of space" << endl;
   else
   {
      SingleNode->Element = x;
	  SingleNode->Left = NULL;
	  SingleNode->Npl = 0;
	  SingleNode->Right = NULL;
	  H = Merge(SingleNode, H);
   }
   return H;
}

bool IsEmpty(PriorityQueue H)
{
     if(H == NULL)
		 return true;
	 else
		 return false;
}

PriorityQueue DeleteMin(PriorityQueue H)    //删除操作，因为左式堆的堆序性，最小值就在根处，因此删除操作直接就是把根的左子树和右子树合并即可
{
   PriorityQueue LeftHeap,RightHeap;
   if(IsEmpty(H))
   {
      cout << "Priority queue is Empty" << endl;
	  return H;
   }
   LeftHeap = H->Left;
   RightHeap = H->Right;
   free(H);
   return Merge(LeftHeap,RightHeap);
}

int main ()
{


   return 0;
}