左偏树（Leftist Heap/Tree）简介及代码

左偏树是一种常用的优先队列（堆）结构。与二叉堆相比，左偏树可以高效的实现两个堆的合并操作。

左偏树实现方便，编程复杂度低，而且有着不俗的效率表现。

它的一个常见应用就是与并查集结合使用。利用并查集确定两个元素是否在同一集合，利用左偏树确定某个集合中优先级最高的元素。

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 template <class T>
 struct HeapNode
 {
     typedef HeapNode<T> Node;
     Node* lch;
     Node* rch;
     T val;
     int dist;

     HeapNode(),rch(),val(_val),dist() {}

     void clear()
     {
         if(lch) lch->clear();
         if(rch) rch->clear();
         delete this;
     }
 };

 template <class T,class Comp>
 struct LeftistHeap
 {
     typedef HeapNode<T> Node;
     typedef LeftistHeap<T,Comp> Heap;

     Node* root;
     Comp cmp;

     LeftistHeap():root() {}
     ~LeftistHeap()
     {
         clear();
     }

     void clear()
     {
         if(root) root->clear();
         root=;
     }

     Node* merge(Node* A,Node* B)
     {
         if(!A) return B;
         if(!B) return A;

         if(cmp(B->val,A->val)) std::swap(A,B);
         A->rch=merge(B,A->rch);

         if(!A->lch || A->rch->dist > A->lch->dist)
             std::swap(A->lch,A->rch);
         A->dist = (A->rch) ? A->rch->dist +  :  ;

         return A;
     }

     void push(const T& _val)
     {
         Node* nNode=new Node(_val);
         root=merge(root,nNode);
     }

     Heap& operator << (const T& _val)
     {
         push(_val);
         return *this;
     }

     T top()
     {
         return root->val;
     }

     void pop()
     {
         Node* temp=root;
         root=merge(temp->lch,temp->rch);
         delete temp;
     }

     Heap& operator >> (T& _dest)
     {
         _dest=top();
         pop();
         return *this;
     }

     void merge(Heap& _other)
     {
         this->root=merge(this->root,_other.root);
         _other.root=;
     }

     bool empty()
     {
         ;
     }
 };

Leftist Heap

定义左偏树节点的“距离”（dist）为从其右子树开始，一直向右走的路径总长。特别地，若某个节点没有右孩子，其dist值为0。

树中的每个节点都必须满足左孩子的dist值不小于右孩子（如果有的话）的dist值。

和大多数可并堆一样，左偏树的核心操作就是合并（Merge）操作。

（以下伪代码以小根堆为例，节点的数据域记为val）

function merge(Node* A,Node* B)

if(A和B中某一个为空) return 另一个　　　//特判，同时也是递归终止的条件

交换A和B（如果需要的话），使得A的val小于B的val

A->rch = merge(B,A->rch)

if(A的左孩子的dist小于右孩子的dist或A的左孩子不存在) 交换A的左、右孩子

根据A的右孩子更新A的dist

return A

实现细节详见代码。

有了合并操作，其他的也就水到渠成了：

插入（push）：建立一个新节点，然后把它视为一个左偏树，将其与已有的合并。

删除（pop）：删除其根节点，合并原先根节点的左右孩子。

附一道左偏树+并查集的练习题：

 #include <cstdio>
 #include <cstring>
 #include <algorithm>

 template <class T>
 struct HeapNode
 {
     typedef HeapNode<T> Node;
     Node* lch;
     Node* rch;
     T val;
     int dist;

     HeapNode(),rch(),val(_val),dist() {}

     void clear()
     {
         if(lch) lch->clear();
         if(rch) rch->clear();
         delete this;
     }
 };

 template <class T,class Comp>
 struct LeftistHeap
 {
     typedef HeapNode<T> Node;
     typedef LeftistHeap<T,Comp> Heap;

     Node* root;
     Comp cmp;

     LeftistHeap():root() {}
     ~LeftistHeap()
     {
         clear();
     }

     void clear()
     {
         if(root) root->clear();
         root=;
     }

     Node* merge(Node* A,Node* B)
     {
         if(!A) return B;
         if(!B) return A;

         if(cmp(B->val,A->val)) std::swap(A,B);
         A->rch=merge(B,A->rch);

         if(!A->lch || A->rch->dist > A->lch->dist)
             std::swap(A->lch,A->rch);
         A->dist = (A->rch) ? A->rch->dist +  :  ;

         return A;
     }

     void push(const T& _val)
     {
         Node* nNode=new Node(_val);
         root=merge(root,nNode);
     }

     Heap& operator << (const T& _val)
     {
         push(_val);
         return *this;
     }

     T top()
     {
         return root->val;
     }

     void pop()
     {
         Node* temp=root;
         root=merge(temp->lch,temp->rch);
         delete temp;
     }

     Heap& operator >> (T& _dest)
     {
         _dest=top();
         pop();
         return *this;
     }

     void merge(Heap& _other)
     {
         this->root=merge(this->root,_other.root);
         _other.root=;
     }

     bool empty()
     {
         ;
     }
 };

 #include <functional>

 ;

 int N,M;
 int idx[maxN];

 int father(int x)
 {
     return idx[x]==x ? x : idx[x]=father(idx[x]) ;
 }

 LeftistHeap<int,std::greater<int> > heap[maxN];

 void init()
 {
     ;i<maxN;i++) heap[i].clear();
     ;i<maxN;i++) idx[i]=i;
 }

 bool solve()
 {
     init();

     if(scanf("%d",&N)==EOF) return false;
     ;i<=N;i++)
     {
         int s; scanf("%d",&s);
         heap[i].push(s);
     }

     scanf("%d\n",&M);
     while(M--)
     {
         int mk1,mk2;
         scanf("%d%d",&mk1,&mk2);

         int f1=father(mk1);
         int f2=father(mk2);
         if(f1==f2)
         {
             printf("-1\n");
             continue;
         }

         int s1,s2;
         heap[f1]>>s1;
         heap[f2]>>s2;

         if(f1<f2)
         {
             idx[f2]=f1;
             heap[f1].merge(heap[f2]);
             );
             ));
             heap[f1] << (s1>>) << (s2>>);
         }
         else
         {
             idx[f1]=f2;
             heap[f2].merge(heap[f1]);
             );
             ));
             heap[f2] << (s1>>) << (s2>>);
         }
     }

     return true;
 }

 int main()
 {
     while(solve());
     ;
 }

Problem：ZOJ P2334