堆排序

  1 package test;
  2 /**
  3  * 
  4  * 平均性能O(N*logN)。
  5  * 堆排序是就地排序，辅助空间为O(1）
  6  * 它是不稳定的排序方法
  7  * @author xixingwang
  8  *
  9  */
 10 public class HeapSort {
 11     private static int[] sort = new int[] { 1, 0, 10, 20, 3, 5, 6, 4, 9, 8, 12,
 12             17, 34, 11 };
 13 
 14     public static void main(String[] args) {
 15         //初始化堆
 16         buildMaxHeapify(sort);
 17         heapSort(sort);
 18         print(sort);
 19     }
 20 
 21     private static void buildMaxHeapify(int[] data) {
 22         // 没有子节点的才需要创建最大堆，从最后一个的父节点开始
 23         int startIndex = getParentIndex(data.length - 1);//找到最后一个元素的父节点
 24         // 从尾端开始创建最大堆，每次都是正确的堆
 25         for (int i = startIndex; i >= 0; i--) {
 26             maxHeapify(data, data.length, i);
 27         }
 28     }
 29 
 30     /**
 31      * 创建最大堆
 32      * 
 33      * @param data
 34      * @paramheap Size需要创建最大堆的大小，一般在sort的时候用到，因为最多值放在末尾，末尾就不再归入最大堆了
 35      * @param index当前需要创建最大堆的位置
 36      */
 37     private static void maxHeapify(int[] data, int heapSize, int index) {
 38         // 当前点与左右子节点比较
 39         int left = getChildLeftIndex(index);
 40         int right = getChildRightIndex(index);
 41 
 42         int largest = index;
 43         if (left < heapSize && data[index] < data[left]) {
 44             largest = left;
 45         }
 46         if (right < heapSize && data[largest] < data[right]) {
 47             largest = right;
 48         }
 49         // 得到最大值后可能需要交换，如果交换了，其子节点可能就不是最大堆了，需要重新调整
 50         if (largest != index) {
 51             int temp = data[index];
 52             data[index] = data[largest];
 53             data[largest] = temp;
 54             maxHeapify(data, heapSize, largest);
 55         }
 56     }
 57 
 58     /**
 59      * 排序，最大值放在末尾，data虽然是最大堆，在排序后就成了递增的
 60      * 
 61      * @param data
 62      */
 63     private static void heapSort(int[] data) {
 64         // 末尾与头交换，交换后调整最大堆
 65         for (int i = data.length - 1; i > 0; i--) {
 66             int temp = data[0];
 67             data[0] = data[i];
 68             data[i] = temp;
 69             maxHeapify(data, i, 0);
 70         }
 71     }
 72 
 73     /**
 74      * 父节点位置
 75      * 
 76      * @param current
 77      * @return
 78      */
 79     private static int getParentIndex(int current) {
 80         return (current - 1) >> 1;//(current-1)/2
 81     }
 82 
 83     /**
 84      * 左子节点position注意括号，加法优先级更高
 85      * 
 86      * @param current
 87      * @return
 88      */
 89     private static int getChildLeftIndex(int current) {
 90         return (current << 1) + 1;//current *2 +1
 91     }
 92 
 93     /**
 94      * 右子节点position
 95      * 
 96      * @param current
 97      * @return
 98      */
 99     private static int getChildRightIndex(int current) {
100         return (current << 1) + 2;//current *2 +2
101     }
102 
103     private static void print(int[] data) {
104         for (int i = 0; i < data.length; i++) {
105             
106             System.out.print(data[i] + "|");
107         }
108     }
109 
110 }