Heap Algorithm
Heap Sort Algorithm is a comparison-based sorting technique that utilizes a binary heap data structure to efficiently sort a collection of data elements. This algorithm was introduced by J.W.J. Williams in 1964 as an in-place sorting algorithm with an excellent worst-case time complexity of O(n log n). Heap Sort is particularly suitable for sorting large data sets, as it takes advantage of the heap data structure's properties, which allows for efficient access and manipulation of the data.
The algorithm works by first constructing a binary heap (usually a max-heap) from the input data, where each parent node in the heap is greater than or equal to its child nodes. Once the heap is formed, the largest element (the root of the heap) is extracted and swapped with the last element of the heap. The heap size is then reduced by one, and the process is repeated by maintaining the max-heap property through a process called "heapifying" or "sifting down". This process is repeated until the entire heap is sorted, resulting in an ordered list of elements. The primary advantage of Heap Sort is its efficiency in sorting large data sets, as it has a consistent time complexity of O(n log n) regardless of the input distribution. However, it's worth noting that Heap Sort tends to be slower in practice when compared to other sorting algorithms like Quick Sort and Merge Sort due to its relatively high constant factors and poor cache performance.
package DataStructures.Heaps;
/**
* Interface common to heap data structures.<br>
* <p>Heaps are tree-like data structures that allow storing elements in a specific
* way. Each node corresponds to an element and has one parent node (except for the root) and
* at most two children nodes. Every element contains a key, and those keys
* indicate how the tree shall be built. For instance, for a min-heap, the key of a node shall
* be greater than or equal to its parent's and lower than or equal to its children's (the opposite rule applies to a
* max-heap).</p>
* <p>All heap-related operations (inserting or deleting an element, extracting the min or max) are performed in
* O(log n) time.</p>
*
* @author Nicolas Renard
*/
public interface Heap {
/**
* @return the top element in the heap, the one with lowest key for min-heap or with
* the highest key for max-heap
* @throws EmptyHeapException if heap is empty
*/
HeapElement getElement() throws EmptyHeapException;
/**
* Inserts an element in the heap. Adds it to then end and toggle it until it finds its
* right position.
*
* @param element an instance of the HeapElement class.
*/
void insertElement(HeapElement element);
/**
* Delete an element in the heap.
*
* @param elementIndex int containing the position in the heap of the element to be deleted.
*/
void deleteElement(int elementIndex);
}
