数据结构之排序算法(一)-堆排序

继上篇文章讲到堆的实现之后http://blog.csdn.net/tuke_tuke/article/details/50357939，下面可以使用堆来实现堆排序。

在堆的基础上实现堆排序的思路很简单：（这里使用最小堆，当然最大堆也可以）

最小堆MinHeap就是最小的数在堆的根元素的位置。首先把一组数建堆，然后再不断的移除堆的根元素，由于每次移除的根元素都是现有堆的最小元素，故可得到所有元素的从小到大的顺序。

MinHeap.java

package heapsort;

import java.util.ArrayList;

public class MinHeap <E extends Comparable>{
private ArrayList<E> list=new ArrayList<E>();//用数组实现堆

    public MinHeap(){}
    public MinHeap(E[] objects){
    	for(int i=0;i<objects.length;i++){
    		add(objects[i]);
    	}
    }
    public void add(E newObject){//添加一个元素
    	list.add(newObject);
    	int currentIndex=list.size()-1;

    	while(currentIndex>0){
    		int parentIndex=(currentIndex-1)/2;//找到该结点的父结点
    		if(list.get(currentIndex).compareTo(list.get(parentIndex))<0){
    			//如果当前结点的值小于父结点就交换位置
    			E temp=list.get(currentIndex);
    			list.set(currentIndex, list.get(parentIndex));
    			list.set(parentIndex, temp);
    		}
    		else
    			break;
    		currentIndex=parentIndex;
    	}
    }

    public E remove(){//删除并返回根结点
    	if(list.size()==0) return null;

    	E removeObject=list.get(0);
    	list.set(0, list.get(list.size()-1));//把最后一个结点放在根结点的位置
    	list.remove(list.size()-1);

    	int currentIndex=0;
    	while(currentIndex<list.size()){
    		int leftChildIndex=2*currentIndex+1;
    		int rightChildIndex=2*currentIndex+2;//左右孩子结点的坐标

    		if(leftChildIndex>=list.size())break;
    		//比较左右孩子的值，使maxIndex指向值小的结点
    		 int minIndex=leftChildIndex;
    		 if(rightChildIndex<list.size()){
    			 if(list.get(minIndex).compareTo(list.get(rightChildIndex))>0){
    				 minIndex=rightChildIndex;
    			 }
    		 }
    		 //如果当前结点的值大于其左右孩子中的大的值，就交换两个结点
    		 if(list.get(currentIndex).compareTo(list.get(minIndex))>0){
    	          E temp=list.get(minIndex);
    	          list.set(minIndex, list.get(currentIndex));
    	          list.set(currentIndex, temp);
    	          currentIndex=minIndex;
    	    	}
    		 else
    			 break;
    	}

    	return removeObject;   	

    }

    public int getSize(){
    	return list.size();
    }
}

HeapSort.java

package heapsort;

import java.awt.List;

public class HeapSort {

	public static<E extends Comparable> void heapSort(E[] list){
		MinHeap<E> heap=new MinHeap<E>();//最小堆类
		//先把数组添加到堆中，建堆
		for(int i=0;i<list.length;i++){
			heap.add(list[i]);
		}
		//然后在一次删除根结点，根结点总是最值
		/*for(int i=list.length-1;i>=0;i--){//利用最大堆排序
			list[i]=heap.remove();
		}*/
		for(int i=0;i<=list.length-1;i++){//利用最小堆排序，不断的移除堆的根元素
			list[i]=heap.remove();	//每次都会调整堆
		}
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
         Integer[] list={22,43,11,24,27,21,54,35,23};
         System.out.println("堆排序前的数组是：");
         for(int i=0;i<list.length;i++){
        	 System.out.print(list[i]+"  ");
         }
         heapSort(list);//堆排序
         System.out.println();
         System.out.println("堆排序后的数组是：");
         for(int i=0;i<list.length;i++){
        	 System.out.print(list[i]+"  ");
         }
	}

}

算法分析：

运行时间主要是消耗在初始构建堆和在重建堆时的反复筛选上。

在构建堆的过程中，因为我们是完全二叉树从最下层最右边的非终端结点开始构建，将它与其孩子进行比较和若有必要的互换，对于每个非终端结点来说，其实最多进行两次比较和互换操作，因此整个构建堆的时间复杂度为O(n)。

在正式排序时，第i次取堆顶记录重建堆需要用O(logi)的时间（完全二叉树的某个结点到根结点的距离为log2i＋1），并且需要取n-1次堆顶记录，因此，重建堆的时间复杂度为O(nlogn)。

总体来说，堆排序的时间复杂度为O(nlogn)。由于堆排序对原始记录的排序状态并不敏感，因此它无论是最好、最坏和平均时间复杂度均为O(nlogn)