码迷,mamicode.com
首页 > 编程语言 > 详细

堆排序算法详解

时间:2015-11-19 10:46:50      阅读:207      评论:0      收藏:0      [点我收藏+]

标签:

1、堆排序概述

堆排序(Heapsort)是指利用堆积树(堆)这种数据结构所设计的一种排序算法,它是选择排序的一种。可以利用数组的特点快速定位指定索引的元素。堆分为大根堆和小根堆,是完全二叉树。大根堆的要求是每个节点的值都不大于其父节点的值,即A[PARENT[i]] >= A[i]。在数组的非降序排序中,需要使用的就是大根堆,因为根据大根堆的要求可知,最大的值一定在堆顶。

2、堆排序思想(大根堆)

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

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

3)由于交换后新的根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]调整为堆。这样直到无序区中剩余一个元素为止。

3、堆排序的基本操作

1)建堆,建堆是不断调整堆的过程,从len/2处开始调整,一直到第一个节点,此处len是堆中元素的个数。建堆的过程是线性的过程,从len/2到0处一直调用调整堆的过程,相当于o(h1)+o(h2)…+o(hlen/2) 其中h表示节点的深度,len/2表示节点的个数,这是一个求和的过程,结果是线性的O(n)。

2)调整堆:调整堆在构建堆的过程中会用到,而且在堆排序过程中也会用到。利用的思想是比较节点i和它的孩子节点left(i),right(i),选出三者最大者,如果最大值不是节点i而是它的一个孩子节点,那边交互节点i和该节点,然后再调用调整堆过程,这是一个递归的过程。调整堆的过程时间复杂度与堆的深度有关系,是lgn的操作,因为是沿着深度方向进行调整的。

3)堆排序:堆排序是利用上面的两个过程来进行的。首先是根据元素构建堆。然后将堆的根节点取出(一般是与最后一个节点进行交换),将前面len-1个节点继续进行堆调整的过程,然后再将根节点取出,这样一直到所有节点都取出。堆排序过程的时间复杂度是O(nlgn)。因为建堆的时间复杂度是O(n)(调用一次);调整堆的时间复杂度是lgn,调用了n-1次,所以堆排序的时间复杂度是O(nlgn)

4、堆排序的实现(java)

  1 package com.arithmetic.demo;
  2 
  3 public class HeapSort {
  4     //交换元素
  5     public static void exchange(int[] array,int i,int j)
  6     {
  7         int temp = array[i];
  8         array[i] = array[j];
  9         array[j] = temp;        
 10     }
 11     //获得父节点
 12     public static int parentNode(int i)
 13     {
 14         return (i - 1)/2;
 15     }
 16     //获得左节点
 17     public static int leftNode(int i)
 18     {
 19         return 2*i + 1;
 20     }
 21     //获得右节点
 22     public static int rightNode(int i)
 23     {
 24         return 2*i + 2;
 25     }
 26     //最大堆
 27     public static void maxHeap(int[] array,int heapSize,int index)
 28     {
 29         int left = leftNode(index);
 30         int right = rightNode(index);
 31         int largeNode = index;
 32         if(left < heapSize && array[left] > array[largeNode])
 33         {
 34             largeNode = left;
 35         }
 36         if(right < heapSize && array[right] > array[largeNode])
 37         {
 38             largeNode = right;
 39         }
 40         if(index != largeNode)
 41         {
 42             exchange(array, index, largeNode);
 43             maxHeap(array,heapSize,largeNode);
 44         }
 45     }
 46     public static void buildHeap(int[] array)
 47     {
 48         if(array == null || array.length <= 1){
 49             return;
 50         }
 51         int half = array.length/2;
 52         for(int i=half;i>=0;i--)
 53         {
 54             maxHeap(array,array.length,i);
 55         }
 56     }
 57     public static void heapSort(int[] array)
 58     {
 59         if(array == null || array.length <= 1)
 60         {
 61             return;
 62         }
 63         buildHeap(array);
 64         for(int i=array.length -1;i>=1;i--)
 65         {            
 66             exchange(array,0,i);
 67             maxHeap(array,i,0);
 68         }
 69     }
 70     public static void printHeapTree(int[] array)
 71     {
 72         for(int i=1;i<=array.length;i=i*2)
 73         {
 74             for(int k=i-1;k<2*i-1 && k<array.length;k++)
 75             {
 76                 System.out.print(array[k]+" ");
 77             }
 78             System.out.println();
 79         }
 80     }
 81     public static void printHeap(int[] array)
 82     {
 83         for(int i=0;i<array.length;i++)
 84         {
 85             System.out.print(array[i]+" ");
 86         }
 87     }
 88     public static void main(String[] args)
 89     {
 90         int[] array = {7,4,5,3,2,6,9,1};
 91         System.out.println("执行最大堆化前,堆结构:");
 92         printHeapTree(array);
 93         
 94         buildHeap(array);
 95         
 96         System.out.println("执行最大堆化后,堆结构:");
 97         printHeapTree(array);
 98         
 99         heapSort(array);
100         
101         System.out.println("堆排序结果:");
102         printHeap(array);
103     }
104 
105 }

5、算法分析

堆排序的时间,主要由建立初始堆和反复重建堆这两部分的时间开销构成,它们均是通过调用buildHeap实现的。它是不稳定的排序方法。平均性能:O(N*logN)。

 

堆排序算法详解

标签:

原文地址:http://www.cnblogs.com/fxust/p/4976680.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!