数据结构排序序列-堆排序

堆排序

堆排序的思想

堆排序从所周知是用堆对学知识进行处理排序。

具体方法

1.先要根据输进来的数组进行进行建立大堆。
2.大堆建立完成之后要考虑进行多少次循环array.length-1（需要考虑无序区间[0,array.length-i)）。
(1). 将下标为[0]位置的值与无序区间最后一个位置[array.length-i-1]进行交换。
（2).对[0]处继续进行向下调整。
总结思想：堆排序即就是将数组首先进行一次大堆的建立，然后对下标为0的位置的值与无序区间最后一个元素进行交换，这要循环下去每次都能确定一个有序的数。直至无序区间无元素为止。

代码实现

import java.util.Arrays;

public class HeapSort1 {
    public static void heapSort(long[]array){
        //1.根据数组建大堆
        createHeap(array,array.length);
        //2.要进行array.length-1次循环
        for (int i=0;i<array.length-1;i++){
            //无序区间[0，array.length-i）
            //2.1 将下标为[0]位置的值与无序区间最后一个位置[array.length-i-1]进行交换
            swap(array,0,array.length-i-1);
            //2.2对[0]处进行向下调整
            int size = array.length - i - 1;
            adjustDown(array,size,0);
        }
    }
    private static void createHeap(long[]array,int size){
        int lastIndex=size-1;
        int lastParentIndex=(lastIndex-1)/2;
        for (int i=lastParentIndex;i>=0;i--){
            adjustDown(array,size,i);
        }
    }
    //向下调整
    private static void adjustDown(long []array,int size,int index) {
        while (true) {
            //判断index是不是叶子节点
            int leftIndex = index * 2 + 1;
            if (leftIndex > size - 1) {
                return;
            }
            //找最大孩子
            int maxIndex = leftIndex;
            int rightIndex = leftIndex + 1;
            if (rightIndex < size - 1 && array[rightIndex] > array[maxIndex]) {
                maxIndex = rightIndex;
            }
            //比较最大孩子及index值的大小
            if (array[maxIndex] <= array[index]) {
                return;
            }
            //交换
            swap(array, maxIndex, index);
            index = maxIndex;
        }
    }
    private static void swap(long []array,int index1,int index2){
        long t=array[index1];
        array[index1]=array[index2];
        array[index2]=t;
    }

    public static void main(String[] args) {
        //long []array={5,4,7,1,2,8,3,9,6,0};
        //System.out.println(Arrays.toString(array));
        //HeapSort1.heapSort(array);
        //System.out.println(Arrays.toString(array));
    }
}

复杂度

稳定性：不具备
空间复杂度：最好/最坏/平均 O（1）
空间复杂度：最好/最坏/平均 O(n*log n)