堆排序-java语言版

堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加 到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。 上述的方式虽然很直观，也很简单，但是我们可以用更聪明一点的办法完成它。创建一个新数组，把原数组 0length-1的数据拷贝到新数组的1length处，再从新数组长度的一半处开始往1索引处扫描（从右往左），然后 对扫描到的每一个元素做下沉调整即可。

// 根据原数组source，构造处堆heap
private static void createHeap(Comparable[] source,Comparable[] heap) {
    // 把source数组中的数据拷贝到heap中，从heap的1索引处开始填充
    System.arraycopy(source,0,heap,1,source.length);
    // 从heap堆中索引的一半开始倒叙，对得到的每一个元素进行下沉操作
    for(int i = (heap.length - 1) / 2;i > 0;i--) {
        sink(heap,i,heap.length-1);
    }
}

对构造好的堆，我们只需要做类似于堆的删除操作，就可以完成排序。

1.将堆顶元素和堆中最后一个元素交换位置；

2.通过对堆顶元素下沉调整堆，把最大的元素放到堆顶(此时最后一个元素不参与堆的调整，因为最大的数据已经到 了数组的最右边)

3.重复1~2步骤，直到堆中剩最后一个元素

// 对source数组中的数据从小到大进行排序
public static void sort(Comparable[] source) {
    // 创建一个比原数组大1的数组
    Comparable[] heap = new Comparable[source.length+1];
    // 构建堆
    createHeap(source,heap);
    // 保存heap中未排序的最大索引
    int N = heap.length - 1;
    // 开始进行排序
    while (N != 1) {
        // 交换1索引处和N索引处的元素
        exch(heap,1,N);
        // 将最大值，从未排序中排除
        N--;
        // 对1索引处的元素进行下沉操作
        sink(heap,1,N);
    }
    // 这时候heap堆中的数据已经有序，将有序数据拷贝到source中
    System.arraycopy(heap,1,source,0,source.length);
}

-- API设计：

-- 代码：

/**
 * 堆排序
 */
public class HeapSort {
    // 对source数组中的数据从小到大进行排序
    public static void sort(Comparable[] source) {
        // 创建一个比原数组大1的数组
        Comparable[] heap = new Comparable[source.length+1];
        // 构建堆
        createHeap(source,heap);
        // 保存heap中未排序的最大索引
        int N = heap.length - 1;
        // 开始进行排序
        while (N != 1) {
            // 交换1索引处和N索引处的元素
            exch(heap,1,N);
            // 将最大值，从未排序中排除
            N--;
            // 对1索引处的元素进行下沉操作
            sink(heap,1,N);
        }
        // 这时候heap堆中的数据已经有序，将有序数据拷贝到source中
        System.arraycopy(heap,1,source,0,source.length);
    }

    // 根据原数组source，构造处堆heap
    private static void createHeap(Comparable[] source,Comparable[] heap) {
        // 把source数组中的数据拷贝到heap中，从heap的1索引处开始填充
        System.arraycopy(source,0,heap,1,source.length);
        // 从heap堆中索引的一半开始倒叙，对得到的每一个元素进行下沉操作
        for(int i = (heap.length - 1) / 2;i > 0;i--) {
            sink(heap,i,heap.length-1);
        }
    }

    // 在堆heap中，对target索引处元素做下沉操作，范围是target~range
    private static void sink(Comparable[] heap,int target,int range) {
        // 如果没有子结点，就不需要循环了
        while (2 * target <= range) {
            // 找到子结点中比较大的那个值,先假定左结点是最大值
            int max = 2 * target;
            if(2 * target + 1 <= range) {   // 如果有右子结点
               if(less(heap,2 * target,2 * target + 1)) {
                   // 右结点比较大
                   max = 2 * target + 1;
               }
            }
            // 如果当前结点比较大的子结点小，则交换
            if(less(heap,target,max)) {
                exch(heap,target,max);
            }
            // 更新target索引位置
            target = max;
        }
    }

    // 判断heap堆中索引i处的元素是否小于索引j处的元素
    private static boolean less(Comparable[] heap,int i,int j) {
        return heap[i].compareTo(heap[j]) < 0;
    }

    // 交换heap堆中索引i处的元素和索引j处的元素
    private static void exch(Comparable[] heap,int i,int j) {
        Comparable temp = heap[i];
        heap[i] = heap[j];
        heap[j] = temp;
    }
}

-- 测试代码：

public class HeapSortTest {
    public static void main(String[] args) throws Exception {
        String[] arr = {"S", "O", "R", "T", "E", "X", "A", "M", "P", "L", "E"};
        HeapSort.sort(arr);
        System.out.println(Arrays.toString(arr));
    }
}

-- 运行结果图：

@ 以上内容属于个人笔记