＜算法＞堆排序(java实现)

首先先看什么是大顶堆、小顶堆

大顶堆：每个结点的值都大于或等于其左右子结点的值

小顶堆：每个结点的值都小于或等于其左右子结点的值

如图：

那么大顶堆对应的数组就是：
[50,45,40,20,25,35,30,10,15]

小顶堆对应的数组就是：
[10,20,15,25,50,30,40,35,45]

我们知道，数组中，下标为i的元素的左子节点（如果存在）为下标2*i+1的元素，右子节点（如果存在）为下标2*i+2的元素（i从0开始）

1、思路

(1)将无序序列构建成一个大顶堆（小顶堆）

(2)将堆顶元素与末尾元素进行交换，即将最大元素与数组最后一个元素进行交换

(3)重新调整使其成为大顶堆（小顶堆），然后继续交换堆顶元素与当前末尾元素

(4)反复执行（2）（3）步直至完成排序

2、代码实现

思路：

最重要的代码部分就是实现堆的维护，这里以大顶堆为例：

（1）维护大顶堆

从最后一个非叶子结点开始，自左向右，自下而上进行调整，每次都完成局部大顶堆的调整直至到根结点（最后一个非叶子结点下标为：arr.length/2-1）

    /**
     *功能：将数组调整为大顶堆
     * @param arr   待排序数组
     * @param i      i表示非叶子结点在数组索引
     * @param len   len表示对多少个元素继续调整，len会逐渐减少
     */
    public static void adjustHeap(int arr[],int i,int len)
    {
        int tmp=arr[i];  //保存当前元素的值

        //调整过程，
        //每次都是查看左子节点，因为右子节点可以根据左子节点找到
        //之所以需要循环是因为：如果元素进行了交换，可能原来的局部大顶堆就不满足了
        for(int k=2*i+1;k<len;k=k*2+1)
        {
            //找出左右子结点较大者
            if(k+1<len && arr[k]<arr[k+1])
            {
                k=k+1;
            }
            //判断当前结点是否需要与左右节点较大者进行交换
            if(tmp<arr[k])
            {
                arr[i]=arr[k];

                arr[k]=tmp;
                i=k;  //!!!!!继续循环比较
            }
            else
            {
                break;
            }
        }
        //循环结束后，以i为父节点的局部大顶堆已完成
    }

（2）堆排序

• 第一个for循环中的adjustHeap是自下而上构建大顶堆，每次都完成局部大顶堆的构建直到最后完成整个大顶堆的构建

• 第二个for循环中的adjustHeap是自上而下维护大顶堆，因为进行交换后根结点及其左右子结点不满足大顶堆的性质，但是其余局部大顶堆仍然满足，因此不必自下而上维护大顶堆，而是自上而下维护大顶堆

    public static void heapSort(int arr[])
    {
    	//自左向右，自下而上构建大顶堆
        for(int i=arr.length/2-1;i>=0;i--)
        {
            adjustHeap(arr,i,arr.length);
        }
		
        for(int j=arr.length-1;j>0;j--)
        {
            int tmp=arr[j];
            arr[j]=arr[0];
            arr[0]=tmp;
            //由于这里只是影响了根结点的大顶堆，因此这里是自定向下调整大顶堆
            adjustHeap(arr,0,j);
        }
        //System.out.println(Arrays.toString(arr));
        
    }

3、完整代码

import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class HeapSort {
    public static void main(String[] args) {
//        int arr[]={4,6,8,5,9,-1,90,89,56};
//        heapSort(arr);
        int testArr[]=new int[8];
        for(int i=0;i<8;i++)
        {
            testArr[i]=(int)(Math.random()*8000000);
        }


        Date date1=new Date();
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("HH:mm:ss:sss");
        String date1str=simpleDateFormat.format(date1);
        System.out.println(Arrays.toString(testArr));
        System.out.println("排序前时间:"+date1str);

        heapSort(testArr);
        Date date2=new Date();
        String date2str=simpleDateFormat.format(date2);
        System.out.println("排序后时间:"+date2str);
        System.out.println(Arrays.toString(testArr));
    }

    public static void heapSort(int arr[])
    {
//        adjustHeap(arr,1,arr.length);
//        System.out.println(Arrays.toString(arr));
//        adjustHeap(arr,0,arr.length);
//        System.out.println(Arrays.toString(arr));
        for(int i=arr.length/2-1;i>=0;i--)
        {
            adjustHeap(arr,i,arr.length);
        }

        for(int j=arr.length-1;j>0;j--)
        {
            int tmp=arr[j];
            arr[j]=arr[0];
            arr[0]=tmp;
            adjustHeap(arr,0,j);
        }
        //System.out.println(Arrays.toString(arr));

    }

    /**
     *功能：将数组调整为大顶堆
     * @param arr   待排序数组
     * @param i      i表示非叶子结点在数组索引
     * @param len   len表示对多少个元素继续调整，len逐渐减少
     */
    public static void adjustHeap(int arr[],int i,int len)
    {
        int tmp=arr[i];  //保存当前元素的值

        //调整过程，
        //每次都是查看左子节点，因为右子节点可以根据左子节点找到
        for(int k=2*i+1;k<len;k=k*2+1)
        {
            //找出左右子结点较大者
            if(k+1<len && arr[k]<arr[k+1])
            {
                k=k+1;
            }
            //判断当前结点是否需要与左右节点较大者进行交换
            if(tmp<arr[k])
            {
                arr[i]=arr[k];

                arr[k]=tmp;
                i=k;  //!!!!!继续循环比较
            }
            else
            {
                break;
            }
        }

        //循环结束后，以i为父节点的局部大顶堆已完成
    }
}

运行结果

4、性能分析

时间复杂度是O(nlogn)，是不稳定的排序

八百万条数据排序只花了2s