排序算法——堆排序

排序算法——堆排序(heap sort)

基本思想

堆排序是一种树形选择排序，是对直接选择排序的有效改进。

堆的定义如下：具有n个元素的序列（k1,k2,…,kn),当且仅当满足

时称之为堆。由堆的定义可以看出，堆顶元素（即第一个元素）必为最小项（小顶堆）。

对于任意一个Index为i的结点，它的下一个左子结点的Index为(2i)，右子结点为(2i+1)。

若以一维数组存储一个堆，则堆对应一棵完全二叉树，且所有非叶结点的值均不大于(或不小于)其子女的值，根结点（堆顶元素）的值是最小(或最大)的。如：

(a)大顶堆序列：（96, 83,27,38,11,09)

(b)小顶堆序列：（12,36,24,85,47,30,53,91）

初始时把要排序的n个数的序列看作是一棵顺序存储的二叉树（一维数组存储二叉树），调整它们的存储序，使之成为一个堆，将堆顶元素输出，得到n个元素中最小(或最大)的元素，这时堆的根节点的数最小（或者最大）。然后对前面(n-1)个元素重新调整使之成为堆，输出堆顶元素，得到n个元素中次小(或次大)的元素。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。称这个过程为堆排序。

算法

因此，实现堆排序需解决两个问题：

1. 如何将n 个待排序的数建成堆；
2. 输出堆顶元素后，怎样调整剩余n-1 个元素，使其成为一个新堆。

首先讨论第二个问题：输出堆顶元素后，对剩余n-1元素重新建成堆的调整过程。

调整小顶堆的方法：

1）设有m 个元素的堆，输出堆顶元素后，剩下m-1个元素。将堆底元素送入堆顶（（最后一个元素与堆顶进行交换），堆被破坏，其原因仅是根结点不满足堆的性质。

2）将根结点与左、右子树中较小元素的进行交换。

3）若与左子树交换：如果左子树堆被破坏，即左子树的根结点不满足堆的性质，则重复方法（2）.

4）若与右子树交换，如果右子树堆被破坏，即右子树的根结点不满足堆的性质。则重复方法（2）.

5）继续对不满足堆性质的子树进行上述交换操作，直到叶子结点，堆被建成。

称这个自根结点到叶子结点的调整过程为筛选。如图：

再讨论对n 个元素初始建堆的过程。

建堆方法：对初始序列建堆的过程，就是一个反复进行筛选的过程。

1）n 个结点的完全二叉树，则最后一个结点是第[n/2]个结点的子树。

2）筛选从第[n/2]个结点为根的子树开始，该子树成为堆。

3）之后向前依次对各结点为根的子树进行筛选，使之成为堆，直到根结点。

如图建堆初始过程：无序序列：（49，38，65，97，76，13，27，49）

​

​

code

JAVA

import java.util.Arrays;

public class HeapSort {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        int[] a = {49,38,65,97,76,13,27,49};
        heapSort(a);
        System.out.println(Arrays.toString(a));
    }

    public static void heapSort(int[] arr) {
        int n = arr.length;
        if (n<=1) {
            return;
        }
        buildMaxHeap(arr);//初始建堆，arr[0]为最大元素        
        for (int i=n-1;i>=1;i--) {
            //堆顶元素与堆底元素交换
            int c = arr[0];
            arr[0] = arr[i];
            arr[i] = c;
            maxHeap(arr,i,0);//将剩余元素整理成堆

        }
    }

    public static void buildMaxHeap(int[] arr) {
        int n = arr.length;
        //从最后一个节点array.length-1的父结点（array.length-1-1）/2开始，
        //直到根节点0，反复调整堆
        int h = (n-2)/2;
        for (int i =h;i>=0;i--) {
            maxHeap(arr,n,i);
        }

    }
    public static void maxHeap(int[] arr,int arrSize, int index) {
        int left = 2*index;
        int right = 2*index + 1;
        int tmp = index;
        int c = 0;
        //比较父结点与两个子结点大小并交换
        if (left < arrSize && arr[left] > arr [tmp]) {
            tmp = left;
        }
        if (right < arrSize && arr[right] > arr[tmp]) {
            tmp = right;
        }

        if (index != tmp) {
            c = arr[index];
            arr[index] = arr[tmp];
            arr[tmp] = c;
            maxHeap(arr,arrSize,tmp);
        }
    }
}

Python

a = [49,38,65,97,76,13,27,49]

def heapSort(arr):
    n = len(arr)
    if n <= 1:
        return arr
    else:
        buildMaxHeap(arr)
        tmp = n-1
        while tmp >= 1:
            arr[0],arr[tmp] = arr[tmp],arr[0]
            tmp -= 1
            arr = maxHeap(arr,tmp,0)
        return arr

def buildMaxHeap(arr):
    n = len(arr)
    h = int((n-2)/2)
    while h >= 0:
        arr = maxHeap(arr,n,h)
        h -= 1
    return arr

def maxHeap(arr,size,index):
    left = index * 2
    right = index * 2 + 1
    tmp = index
    if left<size and arr[left] > arr[tmp]:
        tmp = left
    if right<size and arr[right] > arr[tmp]:
        tmp = right
    if index != tmp:
        arr[index],arr[tmp] = arr[tmp],arr[index]
        arr = maxHeap(arr,size,tmp)
    return arr

print(heapSort(a))

时效

不稳定

最坏的时间复杂度O(nlogn)

参考

http://blog.youkuaiyun.com/hguisu/article/details/7776068/

http://blog.youkuaiyun.com/kimylrong/article/details/17150475