[数据结构][Sort]Heap Sort

public class Solution
{
    public void heapSort(int[] data)
    {
        heapBuild(data);
        
        for(int i = data.length - 1; i > 0; i --)
        {
            exchange(data, i, 0);
            
            heapAdjust(data, 0, i - 1);
        }
    }
    
    public void heapBuild(int[] data)
    {
        for(int i = (data.length + 1) / 2 - 1; i >= 0; i --)
        {
            heapAdjust(data, i, data.length - 1);
        }
    }
    
    public void heapAdjust(int[] data, int startPosition, int bottomPosition)
    {
        if(startPosition > (bottomPosition + 1) / 2 - 1)
        {
            return;
        }
        
        int leftChildIndex = 2 * startPosition + 1;
        
        int rightChildIndex = 2 * startPosition + 2;
        
        int maxValueIndex = startPosition;
        
        if(data[leftChildIndex] > data[maxValueIndex])
        {
            maxValueIndex = leftChildIndex;
        }
        
        if(rightChildIndex <= bottomPosition)
        {
            if(data[rightChildIndex] > data[maxValueIndex])
            {
                maxValueIndex = rightChildIndex;
            }
        }
        
        if(maxValueIndex != startPosition)
        {
            exchange(data, maxValueIndex, startPosition);
            
            heapAdjust(data, maxValueIndex, bottomPosition);
        }
    }
    
    public void exchange(int[] data, int m, int n)
    {
        int memory = data[m];
        
        data[m] = data[n];
        
        data[n] = memory;
    }
    
}