堆排序算法-java实现

堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法。堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

堆排序的平均时间复杂度为Ο(nlogn) 。

算法步骤：

1. 创建一个堆H[0..n-1]
2. 把堆首（最大值）和堆尾互换

3. 把堆的尺寸缩小1，并调用shift_down(0),目的是把新的数组顶端数据调整到相应位置

4. 重复步骤2，直到堆的尺寸为1

    public class HeapSort {  
        public static int heap_size;  
        //双亲编号  
        public static int parent(int i){  
            return i/2;  
        }  
        //左孩子编号  
        public static int leftChild(int i){  
            return 2*i;  
        }  
        //右孩子编号  
        public static int rightChild(int i){  
            return 2*i + 1;  
        }  
        /** 
         * 保持最大堆的性质 
         * @param a，堆中的数组元素 
         * @param i，对以该元素为根元素的堆进行调整，假设前提：左右子树都是最大堆 
         *  
         * 由于左右孩子都是最大堆，首先比较根元素与左右孩子，找出最大值，假如不是根元素，则调整两个元素的值； 
         * 由于左孩子（右孩子）的值与根元素交换，有可能打破左子树（右子树）的最大堆性质，因此继续调用，直至叶子元素。 
         */  
        public static void max_heapify(int[] a, int i){  
            int left = leftChild(i);  
            int right = rightChild(i);  
            int largest = 0;  
            if(left < heap_size && a[i]<a[left]){  
                largest = left;  
            }else{  
                largest = i;  
            }  
            if(right < heap_size && a[right] > a[largest]){  
                largest = right;  
            }  
            if(largest == i){  
                return ;  
            }else{  
                int temp = a[i];  
                a[i] = a[largest];  
                a[largest] = temp;  
                max_heapify(a, largest);  
            }  
        }  
        /** 
         * 建立最大堆。在数据中，a.length/2+1一直到最后的元素都是叶子元素，也就是平凡最大堆，因此从其前一个元素开始，一直到 
         * 第一个元素，重复调用max_heapify函数，使其保持最大堆的性质 
         * @param a 
         */  
        public static void build_max_heap(int[] a){  
            for(int i = a.length/2; i>=1; i--){  
                max_heapify(a, i);  
            }  
        }  
        /** 
         * 堆排序：首先使用建立最大堆的算法建立好最大堆，然后将堆顶元素（最大值）与最后一个值交换，同时使得 
         *              堆的长度减小1 ，调用保持最大堆性质的算法调整，使得堆顶元素成为最大值，此时最后一个元素已被排除在外、 
         */  
        public static void heapSort(int[] a){  
            build_max_heap(a);  
            for(int i = a.length - 1; i>=2; i--){  
                int temp = a[1];  
                a[1] = a[i];  
                a[i] = temp;  
                heap_size--;  
                max_heapify(a, 1);  
            }  
        }  
        public static void main(String[] args) {  
            int a[] = {0, 4, 1, 3, 2, 16, 9, 10,14, 8, 7};  
            heap_size = a.length;  
            heapSort(a);  
            for(int i = 0; i< a.length; i++){  
                System.out.print(a[i] + "  ");  
            }  
        }  
    }  

本文部分内容摘自 ：http://cricode.com/2001.html  

http://blog.csdn.net/llbupt/article/details/7419495

详情： http://cricode.com/977.html