排序算法之堆排序

1、基本思想

　　堆排序是一种树形选择排序，是对直接选择排序的有效改进。堆的定义如下：具有n个元素的序列（h1,h2,…,hn),当且仅当满足（hi>=h2i,hi>=2i+1）或（hi<=h2i,hi<=2i+1）(i=1,2,…,n/2)时称之为堆。在这里只讨论满足前者条件的堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最大项（大顶堆）。完全二叉树可以很直观地表示堆的结构。堆顶为根，其它为左子树、右子树。初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。

2、代码示例

package sort;

import org.junit.Test;

/**
 * 堆排序
 */
public class HeapSort {
    
    @Test
    public void TestSort(){ 
        int a[]={49,38,65,97,76,13,56,17,18,23,34,5,53,51};  
        sort(a);  
    }
    
    public static void sort(int[] arr) {
        int temp;
        int i;
        int len=arr.length;
        if (arr == null || len <= 1) {
            return;
        }

        int half = len / 2;
        for (i = half; i >= 0; i--) {
            maxHeap(arr, len, i);
        }

        for (i = len - 1; i >= 1; i--) {
            temp = arr[0];  
            arr[0] = arr[i];  
            arr[i] = temp; 
            maxHeap(arr, i, 0);
        }
        
        for(i=0;i<len;i++){
            System.out.print(arr[i]+" ");  
        }
    }

    /*
     * 该函数假设一个元素的两个子节点都满足最大堆的性质(左右子树都是最大堆)，
     * 只有跟元素可能违反最大堆性质，那么把该元素以及左右子节点的最大元素找出来，如果该元素已经最大，那么整棵树
     * 都是最大堆，程序退出，否则交换跟元素与最大元素的位置，继续调用maxHeap原最大元素所在的子树。
     */
    private static void maxHeap(int[] arr, int heapSize, int index) {
        int temp;
        int left = index * 2 + 1;
        int right = index * 2 + 2;

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

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

        if (index != largest) {
            temp = arr[index];  
            arr[index] = arr[largest];  
            arr[largest] = temp;  
            maxHeap(arr, heapSize, largest);
        }
    }
}

3、效率分析