/*		 
 * Copyright (C) 2003-2013 Paolo Boldi and Sebastiano Vigna 
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License. 
 */


package PACKAGE;

#if #keyclass(Object)
import java.util.Comparator;
#endif

/** A class providing static methods and objects that do useful things with heaps.
 *
 * <P>The static methods of this class allow to treat arrays as 0-based heaps. They
 * are used in the implementation of heap-based queues, but they may be also used
 * directly.
 *
 */

public class HEAPS {

	private HEAPS() {}

	/** Moves the given element down into the heap until it reaches the lowest possible position.
	 *
	 * @param heap the heap (starting at 0).
	 * @param size the number of elements in the heap.
	 * @param i the index of the element that must be moved down.
	 * @param c a type-specific comparator, or <code>null</code> for the natural order.
	 * @return the new position of the element of index <code>i</code>.
	 */

	@SuppressWarnings("unchecked")
	public static KEY_GENERIC int downHeap( final KEY_GENERIC_TYPE[] heap, final int size, int i, final KEY_COMPARATOR KEY_SUPER_GENERIC c ) {
		if ( i >= size ) throw new IllegalArgumentException( "Heap position (" + i + ") is larger than or equal to heap size (" + size + ")" );

		final KEY_GENERIC_TYPE e = heap[ i ];
		int child;

		if ( c == null )
			while ( ( child = 2 * i + 1 ) < size ) {
				if ( child + 1 < size && KEY_LESS( heap[ child + 1 ], heap[ child ] ) ) child++;
				if ( KEY_LESSEQ( e, heap[ child ] ) ) break;
				heap[ i ] = heap[ child ];
				i = child;
			}
		else 
			while ( ( child = 2 * i + 1 ) < size ) {
				if ( child + 1 < size && c.compare( heap[ child + 1 ], heap[ child ] ) < 0 ) child++;
				if ( c.compare( e, heap[ child ] ) <= 0 ) break;
				heap[ i ] = heap[ child ];
				i = child;
			}

		heap[ i ] = e;

		return i;
	}

	/** Moves the given element up in the heap until it reaches the highest possible position.
	 *
	 * @param heap the heap (starting at 0).
	 * @param size the number of elements in the heap.
	 * @param i the index of the element that must be moved up.
	 * @param c a type-specific comparator, or <code>null</code> for the natural order.
	 * @return the new position of the element of index <code>i</code>.
	 */

	@SuppressWarnings("unchecked")
	public static KEY_GENERIC int upHeap( final KEY_GENERIC_TYPE[] heap, final int size, int i, final KEY_COMPARATOR KEY_GENERIC c ) {
		if ( i >= size ) throw new IllegalArgumentException( "Heap position (" + i + ") is larger than or equal to heap size (" + size + ")" );

		final KEY_GENERIC_TYPE e = heap[ i ];
		int parent;

		if ( c == null )
			while ( i != 0 && ( parent = ( i - 1 ) / 2 ) >= 0 ) {
				if ( KEY_LESSEQ( heap[ parent ], e ) ) break;
				heap[ i ] = heap[ parent ]; 
				i = parent;
			}
		else
			while ( i != 0 && ( parent = ( i - 1 ) / 2 ) >= 0 ) {
				if ( c.compare( heap[ parent ], e ) <= 0 ) break;
				heap[ i ] = heap[ parent ]; 
				i = parent;
			}

		heap[ i ] = e;

		return i;
	}

	/** Makes an array into a heap.
	 *
	 * @param heap the heap (starting at 0).
	 * @param size the number of elements in the heap.
	 * @param c a type-specific comparator, or <code>null</code> for the natural order.
	 */

	public static KEY_GENERIC void makeHeap( final KEY_GENERIC_TYPE[] heap, final int size, final KEY_COMPARATOR KEY_GENERIC c ) {
		int i = size / 2;
		while( i-- != 0 ) downHeap( heap, size, i, c );
	}

}
