Question

我注意到一件非常奇怪的事情。

在完成这个lecture之后，我在C ++中实现了一些用于堆排序的代码。

代码如下。

    template<typename T> void min_heapify(std::vector<T> &vec, int i, int size)
    {
        int left  = (2*i); //left child of a zero-indexed heap (array)
        int right = (2*i)+1; //right child.
        int min;

        min = ( (left<size) && (vec[left] < vec[i]) ) ? left : i;
        min = ( (right<size) && (vec[right] < vec[min]) ) ? right : min;

        if (min!= i)
        {
            swapper(vec[i],vec[min]);
            min_heapify(vec, min, size);
        }
    }
    template<typename T> void build_min_heap(std::vector<T> &vec, int size)
    {
        int i = size/2;
        while(i--)
        {
            min_heapify(vec, i, size);

        }
    }
    template<typename T> void heap_sort(std::vector<T> &vec, int size)
    {
        // build min heap
        build_min_heap(vec, size);
        // then extract min repeatedly.
        while(size>0)
        {
            size--;
            swapper(vec[0],vec[size]);
            min_heapify(vec,0,size);
        }
    }

   int main()
   {
        vector<int> v{14,-1,1000, -999, 3,2,5,10};
        heap_sort(v, v.size());

        return 0;
   }

奇怪的是，对我来说这是有道理的 - 建立一个最小堆 - 提取min（或在构建最小堆后在根处执行min-heapify）应该导致升序。但是，在执行此代码并打印出结果向量后，我明白了：

1000 14 10 5 3 2 -1 -999

在尝试弄清楚发生了什么时，我改变了

min = ( (left<size) && (vec[left] < vec[i]) ) ? left : i;
min = ( (right<size) && (vec[right] < vec[min]) ) ? right : min;

到

min = ( (left<size) && (vec[left] > vec[i]) ) ? left : i;
min = ( (right<size) && (vec[right] > vec[min]) ) ? right : min;

实际上最终会选择较大（或最大）的父节点和子节点，结果向量为：

-999 -1 2 3 5 10 14 1000

我做错了什么或者我对堆/堆排序的理解不清楚？我在这里缺少什么？

Answer 1

是swapper(vec[0],vec[size]);是提取。您将第一个元素提取到向量的最后一个元素中。因此获得相反的结果。

堆最小元素是vec[0]。将其交换到最后位置将在该向量内创建最大到最小排序。

如果您实施类似

的内容

result.push_back(heap.pop_min());

您将获得您期望的订单。

堆排序 - 用于升序和降序排序的堆（最小/最大）？

1 个答案: