Complete Binary Tree:

A Complete binary tree is a binary tree in which every node other than the leaves
has two children. In complete binary tree at every level, except possibly the last,
is completely filled, and all nodes are as far left as possible.

If a Binary Tree is filled level by level, left to right (Left child followed by Right
child.) then it is called complete binary tree.
If Right child is present without Left child then it is not complete.

Heap Property :
A binary Tree is said to follow a heap property if tree is complete binary tree and
every element of the tree is Larger (or Smaller) than any of its descendants if they
exists.

Depending on the ordering, a heap is called a max-heap or a min-heap.

In a Max-heap, the keys of parent nodes are always greater than or equal to those
of the children.
In max-heap, Largest element of the Tree is always at top(Root Node).

In a Min-heap, the keys of parent nodes are less than or equal to those of the
children.
In min-heap, Smallest element of the Tree is always at top(Root Node).

Algorithm

STEP 1: Logically, think the given array as Complete Binary Tree,

STEP 2: For sorting the array in ascending order, check whether the tree is
satisfying Max-heap property at each node,

(For descending order, Check whether the tree is satisfying Min-heap property)

Here we will be sorting in Ascending order,

STEP 3: If the tree is satisfying Max-heap property, then largest item is stored at
the root of the heap.
 (At this point we have found the largest element in array, Now, if we
place this element at the end (nth position) of the array then 1 item in array is at
proper place.)

We will remove the largest element from the heap and put at its proper
place (nth position) in array.

After removing the largest element, which element will take its place?
We will put last element of the heap at the vacant place. After placing
the last element at the root, The new tree formed may or may not satisfy max-
heap property. So, If it is not satisfying max-heap property then first task is to
make changes to the tree, So that it satisfies max-heap property.

Heapify process: The process of making changes to tree so that it satisfies max-
heap property is called heapify

When tree satisfies max-heap property, again largest item is stored at the root of
the heap.
We will remove the largest element from the heap and put at its proper
place (n-1 position) in array.
Repeat step 3 until size of array is 1 (At this point all elements are sorted.)

Example:
public class HeapSort {

public static void main(String[] args) {

int[] array = new int[]{4, 10, 3, 5, 1};

new HeapSort().sort(array);

for (int i : array) {

System.out.print(i + " ");
}
}

public void sort(int data[]) {

int size = data.length;

for (int i = size / 2 - 1; i >= 0; i--) {

heapify(i, data, size);
}

for(int i=data.length-1;i>=0;i--){
int temp = data[0];
data[0]=data[i];
data[i]=temp;

//reduce the heap window by 1

size = size-1;

//call max heapify on the reduced heap

heapify(0, data, size);
}
}

private int leftChild(int i){

return 2 * i + 1;
}
private int rightChild(int i) {
return 2 * i + 2;
}

private void heapify(int i, int[] data, int size) {

int largestElementIndex = i;

int leftChildIndex = leftChild(i);

if (leftChildIndex < size && data[leftChildIndex] > data[largestElementIndex]) {
largestElementIndex = leftChildIndex;
}

int rightChildIndex = rightChild(i);

if (rightChildIndex < size && data[rightChildIndex] > data[largestElementIndex]) {
largestElementIndex = rightChildIndex;
}

if (largestElementIndex != i) {
int swap = data[i];
 data[i] = data[largestElementIndex];
data[largestElementIndex] = swap;

// Recursively heapify the affected sub-tree

heapify(largestElementIndex, data, size);
}
}

Summarize Heap Sort algorithm:

1. We build a heap(Max or Min) from the given array elements.

2. The root is the max (or min number). So extract it and put it in an array at its
proper position.
3. Put last element at the root of the tree and Heapify the remaining elements.
4. Again extract the root and repeat heapification until there is one element in
array.

Advantage of using Heap Sort algorithm for Sorting

1. Heap sort has the best possible worst case running time complexity of O(n Log
n).
2. It doesn't need any extra storage and that makes it good for situations where
array size is large.