排序算法之堆排序

堆排序

【1】堆排序的思想

        堆排序的思想是指利用堆数据结构所设计的一种数据排序算法。

        堆：堆是一种特殊的完全二叉树，最大堆的特点是它的结点的值总是不小于它的父节点的值（也就是说其父节点的值总是大于它的子节点的值），总是一颗完全二叉树结构。

【2】堆排序过程

A:有输入的无序数组构成一个完全二叉树结构

B：先由此完全二叉树构成一个最大堆，作为初始堆（一直交换查询找到最大值放到根节点）

C：将堆顶元素和堆尾的元素交换（此时已经找出了最大值）

D：将堆尾元素从堆中撇开，剩下的的堆尺寸减一，此时的新堆继续构成一个最大堆

E：一直重复BCD，直到堆的元素只剩一个

【3】堆的数据结构是数组

【4】堆排序的稳定性：不稳定，发生在在堆顶元素和其它元素进行交换的时候

【5】堆排序的时间复杂度：O(nlogn)

     刚开始建堆的时间复杂度是O（n）

     在建立新堆并向下进行堆调整的时候，时间复杂度是O（logn）

堆排序代码如下：

package Collection;

import java.util.Arrays;
public class HeapSort {
    public static void main(String[] args) {
        int[] arr={5,2,9,4,7,6,1,3,8};
        int n=arr.length;
        heapsort(arr,n); //调用堆排序函数
        System.out.println(Arrays.toString(arr));
    }
    public static void heapsort(int[] arr, int n){
        int heap_size=buildheap(arr,n);//建立一个最大堆
        while(heap_size>1){      //当堆内元素个数>1的时候
            //这步操作很可能把后面元素的稳定性打乱，因此堆排序是不稳定的排序算法
            Swap(arr,0,-- heap_size);//将堆顶的元素和堆的最后一个元素互换（此时交换后的最后一个元素就是这个堆里的最大元素）
            heapify(arr,0,heap_size);//在出过最后一个元素（最大值）之外重新排序（递归调用）
        }
    }
    public static int buildheap(int[] arr, int n){
        int heap_size=n;
        for(int i=heap_size/2-1;i>=0;i--)
            //从最后一个非叶子结点开始向下进行堆调整
            heapify(arr,i,heap_size);
        return heap_size;
    }
    public static void heapify(int[] arr, int i, int size){
        int left_child=2*i+1;//第i结点的左孩子结点
        int right_child=2*i+2;
        int max=i;
        //接下来找出此节点，此节点的左孩子，此节点的右孩子这三者之间谁最大
        if(left_child<size&&arr[left_child]>arr[max])
            max=left_child;
        if(right_child<size&&arr[right_child]>arr[max])
            max=right_child;
        if(max!=i)
        {
            Swap(arr,i,max);//将最大值和当前结点交换
            heapify(arr,max,size);//递归：从当前结点向下调整
        }
    }
    public static void Swap(int[] arr, int x, int y){
        int temp=arr[x];
        arr[x]=arr[y];
        arr[y]=temp;
    }
}