Question

max-heap函数运行正常，但是heapsort无效。

当我运行此代码时。它显示错误的计算。

Your input is:
9 79 42 86 33 75

Your max-heap is:
86 79 42 75 33 9

Ascending numerical order:
86 79 42 75 33 9

正如你可以看到我的最后一个输出，升序数字顺序与max-heap的数值相同，但这不是我所期望的。

我的任务是我必须从max-heap中排序一个数字。另外，我必须从max-heap数组中交换第一个和最后一个元素，然后忽略最后一个元素。此外，一旦忽略了最后一个元素，我必须再次执行max-heap函数。

计算如何运作的一个例子。 max-heap是：86,79,42,75,33,9。在排序部分，我必须交换第一个和最后一个元素，然后忽略最后一个元素，因此堆排序结果应为：9,79,42 ，75,33，[86] （方括号意味着忽略或删除）。我必须从之前的排序再次执行max-heap。第二个最大堆结果将是79,75,9,42,33。当我回到排序时，我必须交换第一个和最后一个元素然后再次忽略最后一个元素，因此最大堆是79,75 ，9,42,33和堆排序结果应该是：33,75,9,42，[79]，[86]。我必须重新做同样的步骤，直到所有数字排序。

我想要显示的输出示例：

我的输入是9,79,42,86,33,75

最大堆应该是：86,79,42,75,33,9。

升序数应为：9,33,42,75,79,86。

有关更多示例，请访问网站https://en.wikipedia.org/wiki/Heapsort#Example，参见示例2 - 排序

这里是错误计算的代码：

#include "stdafx.h"
#include <iostream>

using namespace std;

int heap[30];

void main()
{
int n, index, parent, flag, dummy;
n = 7; //size of table

// user input number
for (index = 1; index < 7; index++) 
{
    cout << "Enter value " << index << ": ";
    cin >> heap[index];
}

// output for user element
cout << "\nYour input is:\n";
for (index = 1; index < 7; index++) 
{
    cout << heap[index] << " ";
}

flag = 1;

while (flag == 1)
{
    flag = 0;

    //heapify
    for (index = 7; index >1; index--)
    {
        parent = index / 2;
        if (heap[parent] < heap[index])
        {
            dummy = heap[parent];
            heap[parent] = heap[index];
            heap[index] = dummy;
            flag = 1;
        }

        // Sorting --> swap first and last of the array and then ignore the 
        //last array and reheap from above until all number sorted.

        while (heap[0] >= 1)
        {
            int last = heap[0];
            int temp1 = heap[1];
            heap[1] = heap[last - 1];
            heap[last - 1] = temp1;
            heap[0]--;
        }
    }
}

cout << "\n\nYour max-heap is:\n";
for (index = 1; index < 7; index++) // output for after heap
{
    cout << heap[index] << " ";
}

cout << "\n\nAscending numerical order:\n";
for (index = 1; index < 7; index++) //output for sorting.
{
    cout << heap[index] << " ";
}

getchar();
getchar();
}

我无法更改或替换的代码是

    while (flag == 1)
{
    flag = 0;

    //heapify
    for (index = 6; index >1; index--)
    {
        parent = index / 2;
        if (heap[parent] < heap[index])
        {
            dummy = heap[parent];
            heap[parent] = heap[index];
            heap[index] = dummy;
            flag = 1;
        }
    }

}

Answer 1

您的代码中有很多错误。

我注意到的第一个是你的while循环

while (heap[0] >= 1) //heap[0] = 0 since you declared your array statically
    {
        int last = heap[0]; // last = 0
        int temp1 = heap[1];
        heap[1] = heap[last - 1]; //trying to find element heap[-1] ERROR
        heap[last - 1] = temp1; //heap[-1] = heap[1]
        heap[0]--; //heap[0] = -1 why?
    }

第二个是你从索引1开始并在输入循环中转到索引6（首先是代码中的循环），但是当你试图在第三个for循环中在堆中产生一些差异时，你是从索引7，你去索引2.

我无法在你的代码中找到方法，所以我会发布我的。它遵循您发布的wiki页面中的算法。

#include <iostream>

using namespace std;



void build_heap(int *heap, int index)
{
    if(index>1)
    {
       int new_input = heap[index], tmp = 0;
    //since your index starts from 1 and goes up to n in heap
    //parent from index k is (k%2==1) ? (k-1)/2 : k/2
    if(index % 2 == 1)
        index--;
    if(heap[index/2] < new_input)
    {

        tmp = heap[index/2];
        heap[index/2] = new_input;
        heap[index] = tmp;
        build_heap(heap, index/2);
       }
    }
}

void make_order_in_heap(int *heap, int n)
{
if(n>1)
{
    int index = 1;
    int child_index;
    bool work = true;

    while(work && index < n)
    {
        //finding child_index
        if( index * 2 + 1 <= n)
        {
            child_index = heap[index*2] > heap[index*2+1] ? index*2 : index*2+1;
        }
        else if(index * 2 <= n)
        {
            child_index = index*2;
        }
        else
        {
            //this index has no  children
            return;
        }
        work = false;
        if(heap[child_index] > heap[index])
        {
            int tmp = heap[index];
            heap[index] = heap[child_index];
            heap[child_index] = tmp;
            index = child_index;
            work = true;
        }
    }

}
}

void swap_first_and_last(int *heap, int n)
{
if(n>1)
{
    int tmp = heap[1];
    heap[1] = heap[n];
    heap[n] = tmp;
}
}

void sort_heap(int *heap, int n)
{
if(n>1)
{
    swap_first_and_last(heap, n);
    //we swaped first and last element in heap with n elements
    //so now first element in heap of n-1 elements is not on his      possiton
    make_order_in_heap(heap, n-1);
    sort_heap(heap, n-1);
}
}

int main()
{
int heap[30];
int n, index, parent, flag, dummy;
n = 7; 

for (index = 1; index <= n; index++) 
{
    cout << "Enter value " << index << ": ";
    cin >> heap[index];
    build_heap(heap, index);
}

cout << "\nYour input is:\n";
for (index = 1; index <= n; index++) 
{
    cout << heap[index] << " ";
}


sort_heap(heap, n);

cout << "\n Sorted array is:\n";
for (index = 1; index <= n; index++) 
{
    cout << heap[index] << " ";
}
return 0;
}

堆排序不起作用或计算不正确

1 个答案: