斜堆(Skew Heap)

斜堆(Skew Heap)基于左倾堆的概念，也是一个用于快速合并的堆结构，但它可自我调整(self-adjusting)，每一个merge操作的平摊成本仍为O(logN)，其中N为结点数，而且和左倾堆相比，每个结点没有npl属性，从而节省了空间。斜堆并不能保证左倾，但是每一个合并操作（也是采取右路合并）同时需要无条件交换（而左倾堆中只是根据左右子树的npl值不符合要求时才交换）左右子树，让新合并的右子树变成左子树，原来的左子树变成新的右子树（这有点类似于Splay Tree中的做法），从而可以达到平摊意义上的左倾效果。注意：一颗子树r和NULL子树合并时并不需要交换r子树的左右子树。

由于斜堆并不是严格的左倾堆，最坏的情况下右路长度可能为N，因此采用递归调用merge的风险是出现stack overflow。尽管如此，在下面的实现中还是提供了递归和非递归的两个版本。测试时使用的是非递归版本。

斜堆中除merge之外的其他操作跟左倾堆类似，具体情况参考以下代码，在此不再赘述。

实现：

import java.util.LinkedList;
import java.util.Stack;

 

/**
 * 
 * Skew 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-25
 *
 */
public class SkewHeap {
	static class Node{
		int key;
		Node left;
		Node right;
		
		public Node(int key){
			this.key = key; 
		}
		
		public String toString(){
			return String.valueOf(this.key);
		}
		
		public Node recursiveMerge(Node rhsRoot){
			if(rhsRoot==this || rhsRoot == null) {
				//Note: no need to swap the left and right children of this tree
				//Node tmp = this.left;
				//this.left = this.right;
				//this.right = tmp;
				return this;
			}
			
			Node root1 = null; //the root of the merged tree
			Node 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;				
			}
			
			Node tmpRoot = root2.recursiveMerge(root1.right);
			root1.right = root1.left;
			root1.left = tmpRoot;
			//or equivalently: we may first merge recursively, then swap left and right children.
			//Node right = root1.right;
			//root1.right = root1.left;			 
			//root1.left = root2.merge(right);			
						
			return root1;
		}
	}
	private Node root;
	
	public SkewHeap(Node root){
		this.root = root;
	}
	
	//version 1: recursive merge: not recommended because skew heap is 
	//unlike leftist heap to be deterministically leftist, so it can cause 
	//stack overflow in extreme cases.
	private static Node recursiveMerge(Node root1,Node root2){
  		if(root1 == null) return root2;
		if(root2 == null) return root1;
		return root1.recursiveMerge(root2); 
	}   

	//version 2: non-recursive merge
	private static Node iterativeMerge(Node root1,Node root2){
		if(root1 == null) return root2;
		if(root2 == null) return root1;
		
		Stack<Node> stack = new Stack<Node>();
		Node r1 = root1;
		Node r2 = root2;
		while(r1 != null && r2 != null){
			if(r1.key<r2.key){
				stack.push(r1);
				r1 = r1.right;
			}else{
				stack.push(r2);
				r2 = r2.right;
			}			
		}
		//at this point, exactly one of r1 and r2 is null
		//Again we don't need to swap the left and right children of r
		Node r = (r1 != null)?r1:r2;
		
		//merge
		while(!stack.isEmpty()){
			Node node = stack.pop();			
			node.right = node.left;
			node.left = r;
			r = node;
		}
		return r;
	}
	
	public static SkewHeap merge(SkewHeap h1,SkewHeap h2){
		Node rootNode = iterativeMerge(h1.root,h2.root);
		return new SkewHeap(rootNode);
	}      
	
	public static SkewHeap buildHeap(int[] A){
		LinkedList<Node> queue = new LinkedList<Node>();
		int n = A.length;
		//init: queue all elements as a single-node tree
		for(int i=0;i<n;i++){
			Node node = new Node(A[i]);
			queue.add(node);
		}
		//merge adjacent heaps and enqueue the merged heap afterward
		while(queue.size()>1){
			Node root1 = queue.remove(); //dequeue
			Node root2 = queue.remove();
			Node rootNode = iterativeMerge(root1,root2);
			queue.add(rootNode);
		}
		Node rootNode = queue.remove();
		return new SkewHeap(rootNode);
	}
	public void insert(int x){
		this.root = SkewHeap.iterativeMerge(new Node(x), this.root);
	}
	
	public Integer extractMin(){
		if(this.root == null) return null;
		
		int min = this.root.key;
		this.root = SkewHeap.iterativeMerge(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};
		 
		 SkewHeap heap = SkewHeap.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};
		 
		 
		 Node a0 = new Node(A[0]);
		 Node a1 = new Node(A[1]);
		 Node a2 = new Node(A[2]);
		 Node a3 = new Node(A[3]);
		 Node a4 = new Node(A[4]);
		 Node a5 = new Node(A[5]);
		 Node a6 = new Node(A[6]);
		 Node a7 = new Node(A[7]);		 
		 a0.left = a1;   
		 a0.right = a2; 
		 a1.left = a3;   
		 a1.right = a4;
		 a4.left = a6;
		 a2.left = a5;
		 a5.left = a7;
		 SkewHeap h1 = new SkewHeap(a0);
		 
		 int[] B = new int[]{6,12,7,18,24,37,18,33};
		 Node b0 = new Node(B[0]);
		 Node b1 = new Node(B[1]);
		 Node b2 = new Node(B[2]);
		 Node b3 = new Node(B[3]);
		 Node b4 = new Node(B[4]);
		 Node b5 = new Node(B[5]);
		 Node b6 = new Node(B[6]);
		 Node b7 = new Node(B[7]);
		 b0.left = b1;  
		 b0.right = b2;
		 b1.left = b3;  
		 b1.right = b4; 
		 b4.left = b7;
		 b2.left = b5;  
		 b2.right = b6;
		 SkewHeap h2 = new SkewHeap(b0);
		 
		 heap = SkewHeap.merge(h1,h2);
		 while((min = heap.extractMin()) != null){
			 System.out.format(" %d", min);
		 }
		 System.out.println(); 
		 
		 System.out.println("********************");
		 A = new int[]{1,4,23,63,24,44,28};
		 a0 = new Node(A[0]);
		 a1 = new Node(A[1]);
		 a2 = new Node(A[2]);
		 a3 = new Node(A[3]);
		 a4 = new Node(A[4]);
		 a5 = new Node(A[5]);
		 a6 = new Node(A[6]); 
		 a0.left = a1;   
		 a0.right = a2;
		 a1.left = a3;   
		 a1.right = a4;
		 a2.left = a5;  
		 a2.right = a6;
		 h1 = new SkewHeap(a0);
		 
		 B = new int[]{13,17,99,57,49,105,201};
		 b0 = new Node(B[0]);
		 b1 = new Node(B[1]);
		 b2 = new Node(B[2]);
		 b3 = new Node(B[3]);
		 b4 = new Node(B[4]);
		 b5 = new Node(B[5]);
		 b6 = new Node(B[6]);
		 b0.left = b1;
		 b0.right = b2;
		 b1.left = b3;
		 b1.right = b4;
		 b2.left = b5;
		 b2.right = b6;
		 h2 = new SkewHeap(b0);
		 
		 heap = SkewHeap.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 4 13 17 23 24 28 44 49 57 63 99 105 201

参考资料：

Sleator & Tarjan (1986). "Self-Adjusting Heaps"