Leftist Heap and Skew Heap

Leftist Heap

【Definition】The leftist heap property is that for every node X in the heap, the null path length of the left child is at least as large as that of the right child.(Npl(NULL)==-1)

【Theorem】A leftist tree with r nodes on the right path must have at least 2^r  – 1 nodes.So the length of right path is about logN 

Merging(O(logN)):sort the node in right path of two leftist heaps,and swap the left subtree and right subtree if necessary.

As for build a leftist tree:store the leftist tree in a queue(originally N one-node trees).Get the first two leftist trees, and merge them.Repeat the operation untill there is one leftist tree left.O(N) for doing it.(the worst case is O(N),when N=2^k)

struct TreeNode 
{ 
	ElementType Element;
	PriorityQueue Left;
	PriorityQueue Right;
	int Npl;
} ;

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 );
}
static PriorityQueue Merge1( PriorityQueue H1, PriorityQueue H2 )
{ 
	if ( H1->Left == NULL ) 	/* single node */
		H1->Left = H2;	/* H1->Right is already NULL 
				    and H1->Npl is already 0 */
	else {
		H1->Right = Merge( H1->Right, H2 );     /* Step 1 & 2 */
		if ( H1->Left->Npl < H1->Right->Npl )
			SwapChildren( H1 );	/* Step 3 */
		H1->Npl = H1->Right->Npl + 1;
	} /* end else */
	return H1;
}

Skew Heap

——a simple version of the leftist heaps

Any M consecutive operations take at most O(M log N) time.

ALWAYS SWAP CHILDREN

Di =  the resulting tree

ф( Di ) =number of heavy nodes

【Definition】A node p is heavy if the number of descendants of p’s right subtree is at least half of the number of descendants of p, and light otherwise.  Note that the number of descendants of a node includes the node itself.

Hi : li + hi  ( i = 1, 2 )(along the right path)

T=l1+l2+h1+h2

ф( Di -1)=h+h1+h2    ф( Di ) =h+l1+l2(consider the worst case that every light node on the right path becomes heavy node)

T amortize=T+ф( Di ) -ф( Di -1)=2(l1+l2)  which means O(logN)