堆排序

堆排序：

堆积排序(Heapsort)是指利用堆积树（堆）这种资料结构所设计的一种排序算法，可以利用数组的特点快速定位指定索引的元素。

堆排序原理及分析

起源

　　1991年计算机先驱奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德(Robert W．Floyd)和威廉姆斯(J．Williams)在1964年共同发明了著名的堆排序算法( Heap Sort )

“堆”定义

　　n个关键字序列Kl，K2，…，Kn称为(Heap)，当且仅当该序列满足如下性质(简称为堆性质)：

　　(1)ki<=k(2i)且ki<=k(2i+1)(1≤i≤n),当然，这是小根堆，大根堆则换成>=号。 //k(i)相当于二叉树的非叶结点，K(2i)则是左孩子，k(2i+1)是右孩子

　　若将此序列所存储的向量R[1..n]看做是一棵完全二叉树的存储结构，则堆实质上是满足如下性质的完全二叉树：

　　树中任一非叶结点的关键字均不大于(或不小于)其左右孩子(若存在)结点的关键字。

　　【例】关键字序列(10，15，56，25，30，70)和(70，56，30，25，15，10)分别满足堆性质(1)和(2)，故它们均是堆，其对应的完全二叉树分别如小根堆示例和大根堆示例所示。

大根堆和小根堆：根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最小者的堆称为小根堆，又称最小堆。根结点(亦称为堆顶)的关键字是堆里所有结点关键字中最大者，称为大根堆，又称最大堆。注意：①堆中任一子树亦是堆。②以上讨论的堆实际上是二叉堆(BinaryHeap)，类似地可定义k叉堆。

堆的高度

　　堆可以被看成是一棵树，结点在堆中的高度可以被定义为从本结点到叶子结点的最长简单下降路径上边的数目；定义堆的高度为树根的高度。我们将看到，堆结构上的一些基本操作的运行时间至多是与树的高度成正比，为O（lgn）。

堆排序

　　堆排序利用了大根堆(或小根堆)堆顶记录的关键字最大(或最小)这一特征，使得在当前无序区中选取最大(或最小)关键字的记录变得简单。

　　（1）用大根堆排序的基本思想

　　① 先将初始文件R[1..n]建成一个大根堆,此堆为初始的无序区

　　② 再将关键字最大的记录R[1](即堆顶)和无序区的最后一个记录R[n]交换，由此得到新的无序区R[1..n-1]和有序区R[n]，且满足R[1..n-1].keys≤R[n].key

　　③由于交换后新的根R[1]可能违反堆性质，故应将当前无序区R[1..n-1]调整为堆。然后再次将R[1..n-1]中关键字最大的记录R[1]和该区间的最后一个记录R[n-1]交换，由此得到新的无序区R[1..n-2]和有序区R[n-1..n]，且仍满足关系R[1..n-2].keys≤R[n-1..n].keys，同样要将R[1..n-2]调整为堆。

　　……

　　直到无序区只有一个元素为止。

　　（2）大根堆排序算法的基本操作：

　　① 初始化操作：将R[1..n]构造为初始堆；

　　② 每一趟排序的基本操作：将当前无序区的堆顶记录R[1]和该区间的最后一个记录交换，然后将新的无序区调整为堆(亦称重建堆)。

　　注意：

　　①只需做n-1趟排序，选出较大的n-1个关键字即可以使得文件递增有序。

　　②用小根堆排序与利用大根堆类似，只不过其排序结果是递减有序的。堆排序和直接选择排序相反：在任何时刻堆排序中无序区总是在有序区之前，且有序区是在原向量的尾部由后往前逐步扩大至整个向量为止

特点

　　堆排序(HeapSort)是一树形选择排序。堆排序的特点是：在排序过程中，将R[l..n]看成是一棵完全二叉树的顺序存储结构，利用完全二叉树中双亲结点和孩子结点之间的内在关系(参见二叉树的顺序存储结构)，在当前无序区中选择关键字最大(或最小)的记录

堆排序与直接选择排序的区别

　　直接选择排序中，为了从R[1..n]中选出关键字最小的记录，必须进行n-1次比较，然后在R[2..n]中选出关键字最小的记录，又需要做n-2次比较。事实上，后面的n-2次比较中，有许多比较可能在前面的n-1次比较中已经做过，但由于前一趟排序时未保留这些比较结果，所以后一趟排序时又重复执行了这些比较操作。

　　堆排序可通过树形结构保存部分比较结果，可减少比较次数。

算法分析

　　

        堆[排序的时间，主要由建立初始]堆和反复重建堆这两部分的时间开销构成，它们均是通过调用Heapify实现的。

　　堆排序的最坏时间复杂度为O(nlogn)。堆序的平均性能较接近于最坏性能。

        由于建初始堆所需的比较次数较多，所以堆排序不适宜于记录数较少的文件。

       所需辅助空间最少：堆排序

       简单选择排序、堆排序和归并排序的时间性能不随记录序列中关键字的分布而改变。

　　堆排序是就地排序，辅助空间为O(1)，

　　它是不稳定的排序方法。

算法描述

         因为构造初始堆必须使用到调整堆的操作，先讨论Heapify的实现，再讨论如何构造初始堆(即BuildHeap的实现)Heapify函数思想方法

　　每趟排序开始前R[l..i]是以R[1]为根的堆，在R[1]与R交换后，新的无序区R[1..i-1]中只有R[1]的值发生了变化，故除R[1]可能违反堆性质外，其余任何结点为根的子树均是堆。因此，当被调整区间是R[low..high]时，只须调整以R[low]为根的树即可。

　　"筛选法"调整堆

　　R[low]的左、右子树(若存在)均已是堆，这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字最大的结点。若R[low].key不小于这两个孩子结点的关键字，则R[low]未违反堆[性质，以R[low]为根的树已是堆，无须调整；否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换，即R[low]与R[large](R[large].key=max(R[2low].key，R[2low+1].key))交换。交换后又可能使结点R[large]违反堆性质，同样由于该结点的两棵子树(若存在)仍然是堆，故可重复上述的调整过程，对以R[large]为根的树进行调整。此过程直至当前被调整的结点已满足性质，或者该结点已是叶子为止。上述过程就象过筛子一样，把较小的关键字逐层筛下去，而将较大的关键字逐层选上来。因此，有人将此方法称为"筛选法"。

BuildHeap的实现

　　要将初始文件R[l..n]调整为一个大根堆，就必须将它所对应的完全二叉树中以每一结点为根的子树都调整为堆。

显然只有一个结点的树是堆，而在完全二叉树中，所有序号大于n/2的结点都是叶子，因此以这些结点为根的子树均已是堆。这样，我们只需依次将以序号为n/2，…，1的结点作为根的子树都调整为堆即可。

JAVA描述

第一种使用方法:

　packagecom.test.sort;

 

 

public class HeapSortTest {

 

    /*

     * 将数组调整为小根堆，即由小到大排序

     */

    public static int[]heap = new int[] { 26, 5, 77, 1, 61, 11, 59, 15, 48, 19 };

 

    public static voidmain(String[] args) {

        Long beginTime= System.currentTimeMillis();

        int temp;

        /*

         * 创建堆(对该堆进行简单的排序)

         */

        CreateHeap();

        for (int j = 0;j < heap.length; j++) {

           System.out.print(heap[j] + " ");

        }

       System.out.println();// 换行

       System.out.println("============================");

        for (int i =heap.length - 1; 0 < i; i--) {

            temp =heap[0];

            heap[0] =heap[i];

            heap[i] =temp;

            /*

             * 从堆顶进行调整，使未排序堆中最大关键字到堆顶

             */

           AdjustHeap(0, i);

        }

        /*

         * 展示每次排序后的结果

         */

        for (int j = 0;j < heap.length; j++) {

           System.out.print(heap[j] + " ");

        }

       System.out.println();// 换行

        Long endTime =System.currentTimeMillis();

       System.out.println("TotalTime:" + (endTime - beginTime));

    }

 

    /*

     * 调整堆使其堆顶为未排序堆中最大关键字

     */

    public static voidAdjustHeap(int location, int unSortlength) {

        int temp;

        int tempLoc;

        /*

         * 确保左右节点存在

         */

        if ((tempLoc =(location + 1) * 2) < unSortlength) {

            /*

             * 判断左右节点大小

             */

            if(heap[tempLoc] >= heap[tempLoc - 1]) {

                /*

                 * 判断父节点与子节点的大小，若父节点小，则与大的子节点换位

                 */

                if(heap[location] < heap[tempLoc]) {

                    temp = heap[location];

                   heap[location] = heap[tempLoc];

                   heap[tempLoc] = temp;

                    /*

                     * 递归法对换位后的子节点及其子节点进行调整

                     */

                   AdjustHeap(tempLoc, unSortlength);

                }

            } else {

                /*

                 * 左节点大于右节点

                 */

                if(heap[location] < heap[tempLoc - 1]) {

                   temp = heap[location];

                   heap[location] = heap[tempLoc - 1];

                   heap[tempLoc - 1] = temp;

                    /*

                     * 递归法对换位后的子节点及其子节点进行调整

                     */

                   AdjustHeap(tempLoc - 1, unSortlength);

                }

            }

        }

        /*

         * 确保左节点存在

         */

        else if((tempLoc = (location + 1) * 2 - 1) < unSortlength) {

            /*

             * 与左节点进行比较

             */

            if(heap[location] < heap[tempLoc]) {

                /*

                 * 左子节点大于父节点，将两者进行换位

                 */

                temp =heap[location];

               heap[location] = heap[tempLoc];

               heap[tempLoc] = temp;

               AdjustHeap(tempLoc, unSortlength);

            }

        }

    }

 

    /*

     * 创建堆(对该堆进行简单的排序)

     */

    public static voidCreateHeap() {

        for (int i =heap.length - 1; i >= 0; i--) {

           AdjustHeap(i, heap.length);

        }

    }

}

第二种使用方法:

package com.test.sort;

 

public class HeapSort {

 

    public staticvoid main(String[] args) {

        LongbeginTime = System.currentTimeMillis();

        int[] a = {26, 5, 77, 1, 61, 11, 59, 15, 48, 19 };

 

        Sort(a);

        LongendTime = System.currentTimeMillis();

        System.out.println("TotalTime:"+ (endTime - beginTime));

    }

 

    public staticvoid Sort(int[] a) {

        int n =a.length;

        int temp =0;

 

        Display(a,"Before sort : ");

        // R[low]的左、右子树(若存在)均已是堆，这两棵子树的根R[2low]和R[2low+1]分别是各自子树中关键字最大的结点。<br>

        // 若R[low].key不小于这两个孩子结点的关键字，则R[low]未违反堆[性质，以R[low]为根的树已是堆，无须调整；

        //<br>否则必须将R[low]和它的两个孩子结点中关键字较大者进行交换，即R[low]与R[large](R[large].key=max(R[2low].key，R[2low+1].key))交换。

        //<br>交换后又可能使结点R[large]违反堆性质，同样由于该结点的两棵子树(若存在)仍然是堆，故可重复上述的调整过程，对以R[large]为根的树进行调整。

        //<br>此过程直至当前被调整的结点已满足性质，或者该结点已是叶子为止。上述过程就象过筛子一样，把较小的关键字逐层筛下去，而将较大的关键字逐层选上来。因此，有人将此方法称为"筛选法"。

        // 77 61 5948 19 11 26 15 1 5

        // 显然只有一个结点的树是堆，而在完全二叉树中，所有序号大于n/2的结点都是叶子，

        //<br>因此以这些结点为根的子树均已是堆。这样，我们只需依次将以序号为n/2，…，1的结点作为根的子树都调整为堆即可。

        for (int i= n / 2; i > 0; i--) {

           Adjust(a, i - 1, n);

        }

        //System.out.println("=========================================");

        // 这个地方是反向比较顶层节点，然后依次排序它的子节点，形成一颗小根堆排序

        // 每次循环都满足从后到前的层级关系。

        for (int i= n - 2; i >= 0; i--) {

            temp =a[i + 1];

            a[i +1] = a[0];

            a[0] =temp;

 

           Adjust(a, 0, i + 1);

        }

 

        Display(a,"After  sort : ");

    }

 

    public staticvoid Adjust(int[] a, int i, int n) {

        int j = 0;

        int temp =0;

 

        temp =a[i];

        j = 2 * i +1;

        // 这里的while循环是为了满足k(2i)<k(2i+1) andki<=k(2i)且ki<=k(2i+1)(1≤i≤ n)。

        // 如果不满足，则会查找它的每个子节点的子节点的值，然后移动，最终满足这个条件。

        while (j<= n - 1) {

            if (j< n - 1 && a[j] < a[j + 1]) j++;

 

            if(temp >= a[j]) break;

 

            a[(j -1) / 2] = a[j];

 

            j = 2 *j + 1;

        }

 

        a[(j - 1) /2] = temp;

      //  Display(a, "every sort : ");

    }

 

    public staticvoid Display(int[] a, String str) {

       System.out.println(str);

 

        for (int i= 0; i < a.length; i++)

           System.out.print(a[i] + " ");

 

       System.out.println();

    }

}

资料参考:http://baike.baidu.com/view/157305.htm