【排序】8.堆排序

堆排序：利用堆积树（堆）这种数据结构设计的一种排序算法，选择排序的一种

　　　　可以利用数组的特性快速定位指定索引的元素，对分为大根堆和小根堆，是完全二叉树

　　　　堆的高度为树的高度，堆结构的一些基本操作的运行时间与树的高度成正比，为O（lgn）

堆排序是不稳定的排序算法

    public static void sort(int []a){
        buildMaxHeapify(a);
        heapSort(a);
    }
    
    private static void buildMaxHeapify(int[] data){
        //从最后一个的父节点开始
        int startIndex=getParentIndex(data.length-1);
        //从尾端开始创建最大堆
        for(int i=startIndex;i>=0;i--){
        maxHeapify(data,data.length,i);
        }
    }
         
    private static void maxHeapify(int[] data,int heapSize,int index){
        //当前点与左右子节点比较
        int left=getChildLeftIndex(index);
        int right=getChildRightIndex(index);
        int largest=index;
        if(left<heapSize&&data[index]<data[left]){
            largest=left;
        }
        if(right<heapSize&&data[largest]<data[right]){
            largest=right;
        }
        //得到最大值后调整到父节点
        if(largest!=index){
            int temp=data[index];
            data[index]=data[largest];
            data[largest]=temp;
            maxHeapify(data,heapSize,largest);
        }
    }
         
        
    private static void heapSort(int[] data){
        //末尾与头交换，交换后调整最大堆
        for(int i=data.length-1;i>0;i--){
            int temp=data[0];
            data[0]=data[i];
            data[i]=temp;
            maxHeapify(data,i,0);
        }
    }
    //父节点与左右子节点
    private static int getParentIndex(int current){
        return(current-1)>>1;
    }
    private static int getChildLeftIndex(int current){
        return(current<<1)+1;
    }
    private static int getChildRightIndex(int current){
        return(current<<1)+2;
    }

堆排序的时间复杂度：O(N*logN)

堆排序的空间复杂度：O(1)