堆排序

1. 堆原理

1．父结点的键值总是大于或等于（小于或等于）任何一个子节点的键值。

2．每个结点的左子树和右子树都是一个二叉堆（都是最大堆或最小堆）。

当父结点的键值总是大于或等于任何一个子节点的键值时为最大堆。当父结点的键值总是小于或等于任何一个子节点的键值时为最小堆。

可以看出，其实堆排序的数据都是存储在数组中的，只是我们操作的时候把它用作完全二叉树进行排序。

3 . 堆的存储
一般都用数组来表示堆，i结点的父结点下标就为(i – 1) / 2。它的左右子结点下标分别为2 * i + 1和2 * i + 2。如第0个结点左右子结点下标分别为1和2。

4 . 堆操作-插入删除

2. 排序原理

1. 由于堆也是用数组模拟的，故堆化数组后，第一次将A[0]与A[n - 1]交换，再对A[0…n-2]重新恢复堆。第二次将A[0]与A[n – 2]交换，再对A[0…n - 3]重新恢复堆，重复这样的操作直到A[0]与A[1]交换。由于每次都是将最小的数据并入到后面的有序区间，故操作完成后整个数组就有序了。

2. 大根堆排序算法的基本操作
   ① 初始化操作：将A[0..n]构造为初始堆；
   ②每一趟排序的基本操作：将当前无序区的堆顶记录R[0]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆，其实重建堆的操作也就是建立堆操作)。

3. java实现堆排序代码

public class HeapSort {  
        public static void main(String[] args) {  
            int[] array = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, -1, -2, -3 };  

            System.out.println("Before heap:");  
            ArrayUtils.printArray(array);  

            heapSort(array);  

            System.out.println("After heap sort:");  
            ArrayUtils.printArray(array);  
        }  

        public static void heapSort(int[] array) {  
            if (array == null || array.length <= 1) {  
                return;  
            }  

            buildMaxHeap(array);  

            for (int i = array.length - 1; i >= 1; i--) {  
                ArrayUtils.exchangeElements(array, 0, i);  

                maxHeap(array, i, 0);  
            }  
        }  

        private static void buildMaxHeap(int[] array) {  
            if (array == null || array.length <= 1) {  
                return;  
            }  

            int half = array.length / 2;  
            for (int i = half; i >= 0; i--) {  
                maxHeap(array, array.length, i);  
            }  
        }  

        private static void maxHeap(int[] array, int heapSize, int index) {  
            int left = index * 2 + 1;  
            int right = index * 2 + 2;  

            int largest = index;  
            if (left < heapSize && array[left] > array[index]) {  
                largest = left;  
            }  

            if (right < heapSize && array[right] > array[largest]) {  
                largest = right;  
            }  

            if (index != largest) {  
                ArrayUtils.exchangeElements(array, index, largest);  

                maxHeap(array, heapSize, largest);  
            }  
        }  
    }