Question

功能1

void min_heapify(int arr[],int n, int i){
    int j, temp;
    temp = arr[i];
    j = 2 * i;

    while (j <= n)
    {
        if (j < n && arr[j+1] < arr[j])
            j = j + 1;
        if (temp < arr[j])
            break;
        else if (temp >= arr[j])
        {
            arr[j/2] = arr[j];
            j = 2 * j;
        }
    }

    arr[j/2] = temp;
}

功能2

void max_heapify(int arr[], int n, int i)    
{
    int largest = i;  // Initialize largest as root
    int l = 2*i + 1;  // left = 2*i + 1
    int r = 2*i + 2;  // right = 2*i + 2

    // If left child is larger than root
    if (l < n && arr[l] < arr[largest])
        largest = l;

    // If right child is larger than largest so far
    if (r < n && arr[r] < arr[largest])
        largest = r;

    // If largest is not root
    if (largest != i)
    {
        swap(arr[i], arr[largest]);

        // Recursively heapify the affected sub-tree
        heapify(arr, n, largest);
    }
}

问题详情

这里的堆化工作方式与制作min_heap的方法相同，但问题是，我在下面的问题中使用堆来解决它但不幸的是我通过观看MIT讲座实现的功能2并没有解决这个问题，在网上看了一段时间之后，我找到了第一个能够无缝地解决这个问题的功能。我只是困惑他们不是同一个功能？ ------

问题

烨!!问题名称反映了您的任务;只需添加一组数字。但你可能觉得自己屈服了，编写一个C / C ++程序只是为了添加一组数字。这样的问题只会质疑你的博学。所以，让我们为它添加一些独创性。

现在增加操作需要成本，而成本是要添加的两者的总和。因此，要添加1和10，您需要11的成本。如果您想添加1,2和3.有几种方法 -

1 + 2 = 3, cost = 3
1 + 3 = 4, cost = 4
2 + 3 = 5, cost = 5
3 + 3 = 6, cost = 6
2 + 4 = 6, cost = 6
1 + 5 = 6, cost = 6
Total = 9
Total = 10
Total = 11

我希望你已经理解了你的使命，添加一组整数，以便降低成本。

输入

每个测试用例将以正数开始，N（2≤N≤5000），然后是N个正整数（均小于100000）。输入以N的值为零的情况终止。不应处理此案例。

输出

对于每个案例，在一行中打印最低总加成费。

SampleInput

SampleOutput

9
19

Answer 1

function2中的swap函数存在问题。

C是按值调用，所以

swap(arr[i], arr[largest]);

无法交换数组中的值。

交换函数需要交换值的地址：

swap(int *v1, int *v2) {
    int tmp = *v1;
    *v1 = *v2;
    *v2 = tmp;
}

电话会是：

swap(&arr[i], &arr[largest]);

Answer 2

好的我发现解决方案在条件检查中有一个错误，在if条件下我们检查if（left＆lt; = n）这是先前的（左＆lt; n）这就是为什么它不起作用那个问题。好的，谢谢你。

void min_heapify(int arr[],int n, int i){    
    int lowest = i; // Initialize lowest as root
    int left = 2*i ;
    int right = 2*i + 1;



 // If child is lower than root
    if(left <= n && arr[left] < arr[lowest]){
        lowest = left;
    }

    // If right child is lower than lowest
    if(right <= n && arr[right] < arr[lowest]){
        lowest = right;
    }
    // If lowest is not root
    if(lowest != i){ // also break condition
        swap(arr[i], arr[lowest]);

        //Recursively heapify
        min_heapify(arr, n, lowest);

    }

困惑于两个不同的堆实现

2 个答案: