My集合框架第六弹 左式堆

package com.wpr.collection;

/**
 * 左式堆：二叉堆缺点，首先，只能查找最小元素；其次，将两个堆合并的操作很麻烦
 * 		注意：所有支持有效合并的高级数据结构都需要使用链式数据结构
 * 		
 * 		定义：零路径长（null path length）npl表示从节点X到一个不具有两个儿子的节点的最短路径的长
 * 
 * @author wpr
 *
 */
public class LeftHeap<AnyType extends Comparable<? super AnyType>> {

	private Node<AnyType> root;
	
	public LeftHeap() {
		root = null;
	}
	private static class Node<AnyType> {
		AnyType element;
		Node<AnyType> left;
		Node<AnyType> right;
		int npl;
		public Node(AnyType element) {
			this(element,null,null);
		}
		public Node(AnyType element, Node<AnyType> left, Node<AnyType> right) {
			this.element = element;
			this.left = left;
			this.right = right;
			this.npl =0 ;
		}
	}
	/**
	 * @param x
	 */
	public void merge(LeftHeap<AnyType> x){
		if(this == x)
			return ;
		
		root = merge(root,x.root);
	}
	/**
	 * 插入一个新元素
	 * @param x
	 */
	public void insert(AnyType x){
		root = merge(new Node<AnyType>(x),root);
	}
	/**
	 * 删除最小元素
	 * @return
	 */
	public AnyType deleteMin(){
		if(root == null)
			return null;
		
		AnyType item = root.element;
		root = merge(root.left,root.right);
		
		return item;
	}
	/**
	 * 将h1和h2两个堆合并，返回根节点(递归的方式实现)
	 * @param h1
	 * @param h2
	 * @return
	 */
	private Node<AnyType> merge(Node<AnyType> h1, Node<AnyType> h2) {
		if(h1 == null)
			return h2;
		if(h2 == null)
			return h1;
		if(h1.element.compareTo(h2.element)<0){
			//h1<h2
			return merge1(h1,h2);
		}else{
			return merge1(h2,h1);
		}
	}
	/**
	 * 将较小的堆min和较大的堆max合并，返回根节点
	 * @param min 较小的堆,不为null
	 * @param max 较大的堆，不为null
	 * @return
	 */
	private Node<AnyType> merge1(Node<AnyType> min, Node<AnyType> max) {
		if(min.left==null)        //min是一个叶子节点
			min.left = max;
		else{
			min.right = merge(min.right,max);	//较小堆的右子堆和较大堆合并
			if(min.left.npl<min.right.npl){
				swapChildren(min);
			} 
			min.npl = min.right.npl+1;
		}
		return min;
	}
	/**
	 * 交换节点的左右子堆
	 * @param min
	 */
	private void swapChildren(Node<AnyType> min) {
		Node temp = min.left;
		min.left = min.right;
		min.right = temp;
	}
	/**
	 * 非递归的方式来写一下
	 * @param min
	 * @param max
	 * @return
	 */
/*	private Node<AnyType> merge2(Node<AnyType> h1, Node<AnyType> h2) {
		while(h1!=null && h2!=null){
			
		}
	}*/
	public static void main(String[] args) {
		LeftHeap<Integer> heap = new LeftHeap<>();
		for(int i=0;i<10;i++)
			heap.insert(i);
		print(heap);
	}
	
	public static void print(LeftHeap h){
		while(h.root!=null){
			System.out.println(h.deleteMin());
		}
	}
}