数据结构基础之堆排序（Java 实现）

总结

本文地址 /article/3605317.html

最近做到一道笔试题百度笔试题 有20个数组，每个有500个元素，升序排列，找出前500的数，复习了一下堆排序，总结一下，附带了实现的源代码。

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。

堆

看到书上和其他博客都说堆排序是就地排序，所以空间复杂度是 O（1）。一点疑惑，比如我有一个数组，建立一个最小堆，然后每次取出最小堆的顶点。建立最小堆需要额外空间？

不深究了，与堆排序比较，归并排序需要额外空间。

堆是完全二叉树，所以可以用数组表示。普通的二叉树需要用链表表示。

完全二叉树不等于满二叉树。下图是一个完全二叉树。



我们数组下标从0开始。

我们可以得到父节点和子节点之前的坐标公式。

[code]leftChild = 2*parent+1;
rightChild = 2*parent +2;
parent = (child-1)/2;//child 为 leftChild  或 rightChild

插入堆

从书上截取的图片，注意，书上描述的是最大堆，我们代码实现的是最小堆。

插入堆后，保存父节点>子节点的性质。



代码算法怎么实现呢？我们需要保持最大堆的性质，插入元素后必然需要移动数组。

下面的方法是先把元素插到数组的末尾，然后比较该元素和父亲元素，判断是否需要交换。重复上述步骤，知道遍历完成或者堆已经是最大堆了。




代码

[code]    /**
     * 增加一个新元素，步骤是 1. 先把元素插入到 list 的末尾 2. 比较末尾元素和它的父元素，若小于，交换两者 3.
     * 重复上述步骤，直到到顶点位置或者子元素大于父元素 4. 不一定要遍历堆所有的元素，达到堆的性质后会提前结束
     * 
     * @param array
     */
    public void add(E array) {

        data.add(array);

        int child = data.size() - 1;
        int parent = (child - 1) / 2;

        // 判断是否到达顶点
        while (child > 0) {
            // 父元素大于子元素，交换，保持父是小的
            if (data.get(parent).compareTo(array) > 0) {
                data.set(child, data.get(parent));
                data.set(parent, array);

                child = parent;
                parent = (child - 1) / 2;
            } else {
                // 已经是最小堆了，无需再比较
                break;
            }
        }
    }

上面使用的是插入的方法，充分利用原有最大堆的性质。思路很棒！！

删除顶点元素

删除元素，我自己想的时候也想不到好方法。看书上的才明白，也是利用交换的思路。

删除顶点元素，然后将最后一个元素移动到顶点处。再从上往下遍历，判断顶点元素和它子节点是否满足堆的性质，不满足则交换。重复上述步骤，知道遍历完成或者堆已经是最大堆。

Note 删除和插入元素，不一定需要遍历二叉树的所有层，当已经满足最大堆的性质时候，就可以结束。






代码

[code]    /**
     * 删除顶点处的元素，步骤是： 1. 把末尾的元素复制到顶点处 2. 然后比较此时顶点的值和左右子树，保持最小堆的性质 3.
     * 交换顶点和左右子树较小的值 4. 重复上述步骤，直到已经成了最小堆或者遍历完 5. 注意可能存在左子树存在，右子树不存在情况 6.
     * 不一定要遍历堆所有的元素，达到堆的性质后会提前结束
     * 
     * @return 返回被删除的元素
     */
    public E removeTop() {
        if (data.isEmpty())
            return null;

        E removed = data.get(0);

        // 因为一直交换的是最后的元素，这儿将其保存
        E last = data.get(data.size() - 1);
        data.set(0, last);
        data.remove(data.size() - 1);

        int parent = 0;
        int leftChild = parent * 2 + 1;
        int rightChild = parent * 2 + 2;

        while (leftChild <= data.size() - 1) {

            int minIndex = leftChild;
            // 右子树存在，判断左右子树哪个小，保存坐标
            // 如果不存在，那么使用左子树的坐标
            // 保存较小元素的坐标，可以省去考虑左右子树都存在，只有左存在的情况
            if (rightChild <= data.size() - 1) {
                if (data.get(rightChild).compareTo(data.get(leftChild)) < 0) {
                    minIndex = rightChild;
                }
            }

            if (data.get(minIndex).compareTo(last) < 0) {
                data.set(parent, data.get(minIndex));
                data.set(minIndex, last);
                parent = minIndex;
                leftChild = parent * 2 + 1;
                rightChild = parent * 2 + 2;
            } else {
                break; // 已经达到了最小堆的性质
            }
        }

        return removed;
    }

注意：代码需要考虑左右子树都存在、只有左子树存在的情景。（只有右子树存在是不可能的）。 那么parent需要和left还是right交换呢？

我本来是用了一大堆if判断。

看书上的很简洁，先设置

minIndex = leftChild;

（因为左子树是肯定存在的），然后如果右子树存在的情况下 比较左子树和右子树。如果右子树小，

minIndex = rightChild;

否则

minIndex

不变。然后就可以比较

minIndex

和

parent

了。

而我以前的方法是 先对左右子树的情况比较。找出较小的树，然后和parent比较。 再考虑左子树的情况，比较左子树和parent。这个方法就很冗余。

利用堆进行排序

先将原来的数据入堆，然后依次取出顶点元素。注意，如果是最大堆，得到的降序。如果是最小堆，得到的是升序。

时间复杂度

堆是有二叉树实现的，对于n个元素，建立二叉树的话，数的深度是log(n)。

add方法会追踪顶点到最下边叶子节点的路径，这个路径的长度就是树的深度，log(n)。

对于建立一个二叉树，添加一个元素最多需要log(n)步。所以所以元素添加需要nlog(n)步。

注意如果原来数据是升序的，对于建立一个最小堆是最好情景，对于建立一个最大堆时间是最差情景。

进行对排序，也需要调用n次remove方法，每次remove方法最多需要log(n)步骤。需要的总时间的nlog(n)。

全部代码

[code]/**
 * 最小堆和堆排序, 最小堆，顶点的元素是最小值， 根据《Java 语言程序设计 进阶篇》 p83 改写， 书上是最大堆. 堆排序
 * 将元素都存入最小堆中，从最小堆里面每次取出顶点元素
 * 
 * @author tomchen
 *
 * @param <E>
 */
public class MinHeap<E extends Comparable> {

    // 测试程序
    public static void main(String[] args) {
        Random r = new Random(System.currentTimeMillis());

        // 测试10次
        for (int t = 0; t < 10; t++) {
            MinHeap<Integer> heap = new MinHeap<Integer>();

            int mSize = r.nextInt(15);

            Integer[] original = new Integer[mSize];

            // 堆的长度和元素都是随机
            for (int i = 0; i < mSize; i++) {
                original[i] = r.nextInt(100);
            }

            //copy 数组，调用标准库的方法
            Integer[] copy = Arrays.copyOf(original, mSize);
            Arrays.sort(copy);

            //这儿输出 original 还是乱序的，证明 copy 的排序并无影响
            System.out.println("original data:     " + Arrays.toString(original));

            System.out.println("other sorted data: " + Arrays.toString(copy));

            // 调用 heap 排序
            heapSort(original);

            System.out.println("sorted data:       " + Arrays.toString(original));

            System.out.println("two sort eqyal :   " + Arrays.equals(copy,original));

            System.out.println("-----------------------------------------");
        }

    }

    public static <E extends Comparable> void heapSort(E[] array) {
        MinHeap<E> heap = new MinHeap<E>();
        for (int i = 0; i < array.length; i++) {
            heap.add(array[i]);
        }

        System.out.println("Debug: heap is     " + heap);

        for (int i = 0; i < array.length; i++) {
            array[i] = heap.removeTop();
        }
    }

    private ArrayList<E> data = new ArrayList<E>();

    public MinHeap() {
    }

    /**
     * 增加一个新元素，步骤是 1. 先把元素插入到 list 的末尾 2. 比较末尾元素和它的父元素，若小于，交换两者 3.
     * 重复上述步骤，直到到顶点位置或者子元素大于父元素 4. 不一定要遍历堆所有的元素，达到堆的性质后会提前结束
     * 
     * @param array
     */
    public void add(E array) {

        data.add(array);

        int child = data.size() - 1;
        int parent = (child - 1) / 2;

        // 判断是否到达顶点
        while (child > 0) {
            // 父元素大于子元素，交换，保持父是小的
            if (data.get(parent).compareTo(array) > 0) {
                data.set(child, data.get(parent));
                data.set(parent, array);

                child = parent;
                parent = (child - 1) / 2;
            } else {
                // 已经是最小堆了，无需再比较
                break;
            }
        }
    }

    /**
     * 删除顶点处的元素，步骤是： 1. 把末尾的元素复制到顶点处 2. 然后比较此时顶点的值和左右子树，保持最小堆的性质 3.
     * 交换顶点和左右子树较小的值 4. 重复上述步骤，直到已经成了最小堆或者遍历完 5. 注意可能存在左子树存在，右子树不存在情况 6.
     * 不一定要遍历堆所有的元素，达到堆的性质后会提前结束
     * 
     * @return 返回被删除的元素
     */
    public E removeTop() {
        if (data.isEmpty())
            return null;

        E removed = data.get(0);

        // 因为一直交换的是最后的元素，这儿将其保存
        E last = data.get(data.size() - 1);
        data.set(0, last);
        data.remove(data.size() - 1);

        int parent = 0;
        int leftChild = parent * 2 + 1;
        int rightChild = parent * 2 + 2;

        while (leftChild <= data.size() - 1) {

            int minIndex = leftChild;
            // 右子树存在，判断左右子树哪个小，保存坐标
            // 如果不存在，那么使用左子树的坐标
            // 保存较小元素的坐标，可以省去考虑左右子树都存在，只有左存在的情况
            if (rightChild <= data.size() - 1) {
                if (data.get(rightChild).compareTo(data.get(leftChild)) < 0) {
                    minIndex = rightChild;
                }
            }

            if (data.get(minIndex).compareTo(last) < 0) {
                data.set(parent, data.get(minIndex));
                data.set(minIndex, last);
                parent = minIndex;
                leftChild = parent * 2 + 1;
                rightChild = parent * 2 + 2;
            } else {
                break; // 已经达到了最小堆的性质
            }
        }

        return removed;
    }

    @Override
    public String toString() {
        return data.toString();
    }

}

参考文章

http://bubkoo.com/2014/01/14/sort-algorithm/heap-sort/