Question

嗨，我看了一下，但未能找到对这个问题的任何直接讨论。大多数似乎都涵盖了时间复杂性和大O符号。

我想知道输入到heapsort算法的顺序是否以及如何影响对输入进行排序所需的比较次数。例如，采用按升序排序（从最小到最大）的堆算法....如果我输入一组已经按这种方式排序的整数（升序）与一组输入相比需要多少比较按降序排列（从大到小）？与完全随机的相同数字组相比如何？

public class Heap {
    // This class should not be instantiated.
    private Heap() {
    }

    /**
     * Rearranges the array in ascending order, using the natural order.
     * 
     * @param pq
     *            the array to be sorted
     */
    public static void sort(Comparable[] pq) {
        int N = pq.length;
        for (int k = N / 2; k >= 1; k--)
            sink(pq, k, N);
        while (N > 1) {
            exch(pq, 1, N--);
            sink(pq, 1, N);
        }
    }

    private static void sink(Comparable[] pq, int k, int N) {
        while (2 * k <= N) {
            int j = 2 * k;
            if (j < N && less(pq, j, j + 1))
                j++;
            if (!less(pq, k, j))
                break;
            exch(pq, k, j);
            k = j;
        }
    }

    private static boolean less(Comparable[] pq, int i, int j) {
        return pq[i - 1].compareTo(pq[j - 1]) < 0;
    }

    private static void exch(Object[] pq, int i, int j) {
        Object swap = pq[i - 1];
        pq[i - 1] = pq[j - 1];
        pq[j - 1] = swap;
    }

    // is v < w ?
    private static boolean less(Comparable v, Comparable w) {
        return (v.compareTo(w) < 0);
    }
}

Answer 1

堆排序与冒泡排序和快速排序不同，当输入元素以递减/递增方式排序时，不会发生最佳和最坏情况。堆排序的第一步是构建一个堆（一般来说是最大堆），可以通过使用heapify的“sift down”版本在线性时间O（n）中完成，无论初始元素的顺序是什么即可。如果输入已经是堆，它只会节省交换时间通常认为最佳和最差情况下的性能都是O（nlogn）（ the heap sort item on wiki表示最好的情况表现可以是Ω（n），并且有关于它的链接），但是big-O表示法省略了常数因子和低阶项，因此它们在大O表示法中是等价的，但它们可以通过常数因子而不同。

例如，我获得给定元素的所有720个排列：{1,2,3,4,5,6}并使用您的代码对它们进行排序，最小/最大比较数为12/17而顺序分别是{6,1,4,2,3,5} / {1,4,2,5,6,3}。最小/最大交换次数为8/15，而订单分别为{6,3,5,1,2,4} / {1,2,3,5,4,6}。 My another post是最大交换次数。

heapsort输入最多和最少的比较

1 个答案: