堆排序

堆排序

给定一个数组：

​ String[] arr = {“S”,“O”,“R”,“T”,“E”,“X”,“A”,“M”,“P”,“L”,“E”}

请对数组中的字符按从小到大排序。

AP设计：

类名

HeapSort<T extends Comparable>

成员方法

1.public static void sort(Comparable[] source)：对source数组中的数据从小到大排序 2.private static void createHeap(Comparable[] source, Comparable[] heap):根据原数组source，构造出堆heap 3.private static boolean less(Comparable[] heap, int i, int j)：判断heap堆中索引i处的元素是否小于索引j处的元素 4.private static void exch(Comparable[] heap, int i, int j):交换heap堆中i索引和j索引处的值 5.private static void sink(Comparable[] heap, int target, int range):在heap堆中，对target处的元素做下沉，范围是0~range。

实现步骤：

1.构造堆；

2.得到堆顶元素，这个值就是最大值；

3.交换堆顶元素和数组中的最后一个元素，此时所有元素中的最大元素已经放到合适的位置；

4.对堆进行调整，重新让除了最后一个元素的剩余元素中的最大值放到堆顶；

5.重复2~4这个步骤，直到堆中剩一个元素为止。

堆构造过程

​ 堆的构造，最直观的想法就是另外再创建一个和新数组数组，然后从左往右遍历原数组，每得到一个元素后，添加到新数组中，并通过上浮，对堆进行调整，最后新的数组就是一个堆。

​ 上述的方式虽然很直观，也很简单，但是我们可以用更聪明一点的办法完成它。创建一个新数组，把原数组0_{length-1的数据拷贝到新数组的1}length处，再从新数组长度的一半处开始往1索引处扫描（从右往左），然后对扫描到的每一个元素做下沉调整即可。

​ 注释：根据堆的特性可以看出，他的后一半数据都是叶子结点，叶子结点无子结点，不需要做下沉操作

堆排序过程

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

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

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

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

/**
 * 堆排序
 */
public class HeapSort {
    // 判断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;
    }

    // 根据原数组source，构造出堆heap
    private static void createHeap(Comparable[] source, Comparable[] heap) {
        // 把source中的元素拷贝到heap中，heap中的元素就形成了一个堆，为无序堆
        System.arraycopy(source, 0, heap, 1, source.length);
        // 对堆中的元素进行下沉调整，从长度的一半处开始往索引1处扫描，依次做下沉工作
        for (int i = (heap.length - 1) / 2; i >= 1; i--) {
            sink(heap, i, heap.length - 1);
        }
    }

    // 对source数组中的数据从小到大排序
    public static void sort(Comparable[] source) {
        // 创建一个比原先数组长度+1的数组为堆
        Comparable[] heap = new Comparable[source.length + 1];
        // 构建堆
        createHeap(source, heap);
        // 定义一个变量，记录未排序的元素中最大的索引
        int N = heap.length - 1;
        // 通过循环，交换1索引的元素和最大的元素
        while (N != 1) {
            // 交换元素
            exch(heap, 1, N);
            // 排除交换后最大元素所在的索引，让他不在参与堆的下沉调整
            N--;
            // 对索引1处的元素进行堆的下沉调整（1~N）
            sink(heap, 1, N);
        }
        // 将heap数组复制到原数组source中
        System.arraycopy(heap, 1, source, 0, source.length);
    }

    // 在heap堆中，对target处的元素做下沉，范围是0~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;
                } else {
                    max = 2 * target;
                }
            }
            // 比较当前结点的值和较大子结点的值
            if (less(heap, target, max)) { // 当前结点的值<较大子结点的值
                exch(heap, target, max);

            }
            // 更新target值
            target = max;
        }
    }
}