左倾堆（一种可高效合并的优先队列)

左倾堆(Leftist Heap)是一个便于merge操作的数据结构，通过左倾树(Leftist Tree)实现。左倾树是一种特殊的二叉树,树中结点除了满足普通二叉堆的key大小规定外，还要求每一个结点X的左子树的Null Path Length（NPL)值不小于右子树的NPL值，因此这也是与普通二叉堆的区别：虽然普通二叉堆也满足左倾树的条件，左倾树往往不是一棵完全二叉树(而且通常不平衡)，从而左倾树不能用数组表示了。上面提到的NPL指的是某个结点到NULL结点（总共有n+1个NULL结点）的最短路径长度，规定NULL结点本身的NPL等于-1，叶子结点的NPL等于0,非叶结点的NPL等于它的两个孩子结点的NPL最小值加1。按照左倾树的定义，它的左右子树都是左倾树, 而且有一个重要属性：一个具有n个结点的左倾堆最右边路径长度（即相当于root或树的NPL值)最多为floor(log(n+1))，利用这个特性可以在右路高效地实现下面的merge操作。

普通的二叉堆合并复杂度为O(n)，而左倾堆的合并复杂度只有O(logn)，(n是合并后的左倾堆的结点个数)，因此左倾堆的最大优势是高效的合并操作。最小左倾堆的merge操作的算法是，输入两个左倾堆h1和h2，假设h1的根结点key值大于h2的根结点key值（如果不是这样，交换h1和h2），则将h2的根作为合并后的root结点，同时递归调用merge(h1.root，h2.root.right)，返回的结果作为h2.root的右子树，由于merge操作保证了返回的树满足左倾树条件，因此返回的结果（现在是h2.root的右子树）也已经是一颗左倾树了。如果h2.root.right的NPL值大于h2.root.left的NPL值，需要交换两棵子树h2.root.left和h2.root.right，最后更新h2.root的NPL。

左倾堆的Extract-Min操作先删除root结点，然后调用merge操作将左右子树合并为一颗新的左倾树；Insert操作将要插入的元素看作一个只包含root结点的左倾堆,然后调用merge操作将两个左倾堆合并。

构造左倾堆：如果还是采用Insert操作，则复杂度为O(nlogn)；如果使用普通二叉堆的构造方法，则复杂度为O(n)，但是这并不是最好的左倾堆，原因是一方面构造的左倾堆是完全二叉树，但是另一方面又不能按照数组对它进行操作。采用FIFO队列结构可以达到O(n)复杂度，同时构造出来的左倾堆左倾效果最好，做法如下：将每个元素作为左倾堆(允许任何两个元素值相同)依次enqueue，然后每次从队列中dequeue两个左倾堆，用merge算法合并，并将合并的左倾堆enqueue到队尾，直到队列中只剩一个左倾堆，这个左倾堆就是最终结果。

实现：

import java.util.LinkedList;

 
/**
 * 
 * Leftist Heap   
 *  
 * Copyright (c) 2011 ljs (http://blog.csdn.net/ljsspace/)
 * Licensed under GPL (http://www.opensource.org/licenses/gpl-license.php) 
 * 
 * @author ljs
 * 2011-08-20
 *
 */
public class LeftistMinHeap {
	static class LeftistHeapNode{
		int key;
		LeftistHeapNode left;
		LeftistHeapNode right;
		int npl; //null-path-length
		
		public LeftistHeapNode(int key){
			this.key = key;
			this.npl = 0;
		}
		
		public String toString(){
			return this.key + "(npl=" + this.npl + ")";
		}
		
		public LeftistHeapNode merge(LeftistHeapNode rhsRoot){
			if(rhsRoot==this || rhsRoot == null) return this;
										
			LeftistHeapNode root1 = null; //the root of the merged tree
			LeftistHeapNode root2 = null; 
			if(rhsRoot.key<this.key){
				//merge this with rhsRoot's right child
				root1 = rhsRoot;
				root2 = this;
			}else{
				//merge rhsRoot with this's right child
				root1 = this;
				root2 = rhsRoot;				
			}
			
			LeftistHeapNode tmpRoot = root2.merge(root1.right);
			root1.right = tmpRoot;
			if(root1.left == null){ //left can not be null unless right is null
				root1.right = null;
				root1.left = tmpRoot;
				root1.npl = 0;
			}else{
				if(root1.right.npl>root1.left.npl){
					//swap left and right child						
					root1.right = root1.left;
					root1.left = tmpRoot;					
				}
				//at this time, the right child has the shortest null-path
				root1.npl = root1.right.npl + 1;
			}
			
			return root1;
		}
	}
	
	private LeftistHeapNode root;
	
	public LeftistMinHeap(LeftistHeapNode root){
		this.root = root;
	}
	
	private static LeftistHeapNode merge(LeftistHeapNode root1,LeftistHeapNode root2){
  		if(root1 == null) return root2;
		if(root2 == null) return root1;
		return root1.merge(root2); 
	}      
	public static LeftistMinHeap merge(LeftistMinHeap h1,LeftistMinHeap h2){
		LeftistHeapNode rootNode = merge(h1.root,h2.root);
		return new LeftistMinHeap(rootNode);
	}      
	
	public static LeftistMinHeap buildHeap(int[] A){
		LinkedList<LeftistHeapNode> queue = new LinkedList<LeftistHeapNode>();
		int n = A.length;
		//init: queue all elements as a single-node tree
		for(int i=0;i<n;i++){
			LeftistHeapNode node = new LeftistHeapNode(A[i]);
			queue.add(node);
		}
		//merge adjacent heaps and enqueue the merged heap afterward
		while(queue.size()>1){
			LeftistHeapNode root1 = queue.remove(); //dequeue
			LeftistHeapNode root2 = queue.remove();
			LeftistHeapNode rootNode = merge(root1,root2);
			queue.add(rootNode);
		}
		LeftistHeapNode rootNode = queue.remove();
		return new LeftistMinHeap(rootNode);
	}
	public void insert(int x){
		this.root = LeftistMinHeap.merge(new LeftistHeapNode(x), this.root);
	}
	
	public Integer extractMin(){
		if(this.root == null) return null;
		
		int min = this.root.key;
		this.root = LeftistMinHeap.merge(this.root.left, this.root.right);
		return min;
	}
	 
	public static void main(String[] args) {
		 int[] A = new int[]{4,8,10,9,1,3,5,6,11};
		 
		 LeftistMinHeap heap = LeftistMinHeap.buildHeap(A);
		 heap.insert(7);
		 Integer min = null;
		 while((min = heap.extractMin()) != null){
			 System.out.format(" %d", min);
		 }
		 System.out.println();
		 
		 System.out.println("********************");
		 A = new int[]{3,10,8,21,14,17,23,26};
		 
		 
		 LeftistHeapNode a0 = new LeftistHeapNode(A[0]);
		 LeftistHeapNode a1 = new LeftistHeapNode(A[1]);
		 LeftistHeapNode a2 = new LeftistHeapNode(A[2]);
		 LeftistHeapNode a3 = new LeftistHeapNode(A[3]);
		 LeftistHeapNode a4 = new LeftistHeapNode(A[4]);
		 LeftistHeapNode a5 = new LeftistHeapNode(A[5]);
		 LeftistHeapNode a6 = new LeftistHeapNode(A[6]);
		 LeftistHeapNode a7 = new LeftistHeapNode(A[7]);		 
		 a0.left = a1;  a0.npl = 1;
		 a0.right = a2; 
		 a1.left = a3;  a1.npl = 1;
		 a1.right = a4;
		 a4.left = a6;
		 a2.left = a5;
		 a5.left = a7;
		 LeftistMinHeap h1 = new LeftistMinHeap(a0);
		 
		 int[] B = new int[]{6,12,7,18,24,37,18,33};
		 LeftistHeapNode b0 = new LeftistHeapNode(B[0]);
		 LeftistHeapNode b1 = new LeftistHeapNode(B[1]);
		 LeftistHeapNode b2 = new LeftistHeapNode(B[2]);
		 LeftistHeapNode b3 = new LeftistHeapNode(B[3]);
		 LeftistHeapNode b4 = new LeftistHeapNode(B[4]);
		 LeftistHeapNode b5 = new LeftistHeapNode(B[5]);
		 LeftistHeapNode b6 = new LeftistHeapNode(B[6]);
		 LeftistHeapNode b7 = new LeftistHeapNode(B[7]);
		 b0.left = b1;  b0.npl = 2;
		 b0.right = b2;
		 b1.left = b3;  b1.npl = 1;
		 b1.right = b4; 
		 b4.left = b7;
		 b2.left = b5;  b2.npl = 1;
		 b2.right = b6;
		 LeftistMinHeap h2 = new LeftistMinHeap(b0);
		 
		 heap = LeftistMinHeap.merge(h1,h2);
		 while((min = heap.extractMin()) != null){
			 System.out.format(" %d", min);
		 }
		 System.out.println(); 
		 
		 System.out.println("********************");
		 A = new int[]{1,5,7,10,15,20,25,50,99};
		 a0 = new LeftistHeapNode(A[0]);
		 a1 = new LeftistHeapNode(A[1]);
		 a2 = new LeftistHeapNode(A[2]);
		 a3 = new LeftistHeapNode(A[3]);
		 a4 = new LeftistHeapNode(A[4]);
		 a5 = new LeftistHeapNode(A[5]);
		 a6 = new LeftistHeapNode(A[6]);
		 a7 = new LeftistHeapNode(A[7]);
		 LeftistHeapNode a8 = new LeftistHeapNode(A[8]);	
		 a0.left = a1; a0.npl = 2;		 
		 a0.right = a2;
		 a1.left = a3;  a1.npl = 1;
		 a1.right = a4;
		 a2.left = a5;  a2.npl = 1;
		 a2.right = a6;
		 a5.left = a7;  a5.npl =  1;
		 a5.right = a8;
		 h1 = new LeftistMinHeap(a0);
		 
		 B = new int[]{22,75};
		 b0 = new LeftistHeapNode(B[0]);
		 b1 = new LeftistHeapNode(B[1]);
		 b0.left = b1;
		 h2 = new LeftistMinHeap(b0);
		 
		 heap = LeftistMinHeap.merge(h1,h2); 
		 while((min = heap.extractMin()) != null){
			 System.out.format(" %d", min);
		 }
		 System.out.println();
	}

}

测试输出：
 1 3 4 5 6 7 8 9 10 11
********************
 3 6 7 8 10 12 14 17 18 18 21 23 24 26 33 37
********************
 1 5 7 10 15 20 22 25 50 75 99