Методы отслеживания объектов указателя через функции в C

Question

Я застрял, пытаясь реализовать псевдокод из книги алгоритмов. Мой код компилирует и печатает правильный ответ, за исключением того, что некоторая информация, которую я хочу распечатать, отображается неправильно. Вот как выглядит вывод консоли:

Correct Solution Tested: 
max_left= 7 
max_right= 10 
sum= 43


Failing Outputs:
curr_cross_low = 17; curr_cross_high = -1; curr_cross_sum = 38
curr_cross_low = -1; curr_cross_high = -1; curr_cross_sum = 18
curr_cross_low = 32766; curr_cross_high = -272632720; curr_cross_sum = 43

max_left_full= 32766 
max_right_full= -272632512
sum_full= 43

Program ended with exit code: 0

Первые три напечатанных значения - это правильные результаты, полученные при грубой реализации одной части алгоритма. В коде это функция "findMaxCrossingSubarray" сама по себе. Вторая часть распечатывается, когда я выполняю полный алгоритм "findMaximumSubarray". Я считаю, что это должна быть распечатка результатов, которые показывают приближение к решению. Окончательный ответ, заданный переменной «sum_full», представляется правильным, поскольку он соответствует решению о грубой силе, которое, как говорится в книге, является правильным ответом.

Я пытался найти способ печати правильных значений max_left_full и max_right_full, а не того, что я считаю адресом памяти. Я нахожусь в точке, где, если я изменю указатель в одном месте, это делает решение неправильным или распечатывает адрес памяти также.

Есть ли простой способ узнать, где я могу сбросить мяч?

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

//returns a pointer to a value equal to the set of changes
int * returnPriceChanges(int sz, int A[]){
    int MAX_SIZE = 256;
    static int* C;
    C =  malloc(MAX_SIZE *sizeof(int));
    int i;
    for(i=0;i<sz-1;i++){
        C[i]=A[i+1]-A[i];
    }
    return C;
}

int findMaxCrossingSubarray(int A[], int low, int mid, int high, int* max_left, int* max_right){
    double left_sum = -INFINITY;
    int sum = 0;
    for(int i=mid;i>=low;i--){
        sum=sum+A[i];
        if(sum > left_sum){
            left_sum = sum;
            *max_left = i;
        }
    }
    double right_sum = -INFINITY;
    sum = 0;
    for(int j=mid+1; j<=high;j++){
        sum=sum+A[j];
        if(sum > right_sum){
            right_sum = sum;
            *max_right = j;
        }
    }
    return (*max_left, *max_right, left_sum+right_sum);
}

int findMaximumSubarray(int A[], int low, int high){
    int curr_left_low, curr_left_high, curr_left_sum;
    int curr_right_low, curr_right_high, curr_right_sum;
    int curr_cross_low, curr_cross_high, curr_cross_sum;
    int mid = 0;
    int* temp_max_left, temp_max_right;
    if(high==low){
        return(low, high, A[low]);
    }
    else{
        mid =floor((high+low)/2);
        curr_left_low, curr_left_high, curr_left_sum = findMaximumSubarray(A, low, mid);
        curr_right_low, curr_right_high, curr_right_sum = findMaximumSubarray(A, mid+1,high);
        curr_cross_low, curr_cross_high, curr_cross_sum = findMaxCrossingSubarray(A, low, mid, high, &temp_max_left, &temp_max_right);
        if(curr_left_sum>=curr_right_sum && curr_left_sum>=curr_cross_sum){
            return (curr_left_low, curr_left_high, curr_left_sum);
        }
        else if(curr_right_sum>= curr_left_sum && curr_right_sum>=curr_cross_sum){
            return (curr_right_low, curr_right_high, curr_right_sum);
        }
        else{
            printf("curr_cross_low = %d; curr_cross_high = %d; curr_cross_sum = %d\n", curr_cross_low, curr_cross_high, curr_cross_sum);
            return (curr_cross_low, curr_cross_high, curr_cross_sum);
        }
    }
}

int main(){
    int prices[] = {100,113,110,85,105,102,86,63,81,101,94,106,101,79,94,90,97};
    int szPrices = sizeof(prices)/sizeof(prices[0]);
    int changes[szPrices-1];
    int *P;
    P = returnPriceChanges(szPrices,prices);
    //set C = to list of changes
    for(int i=0; i<szPrices-1; i++){
        changes[i]=*(P+i);
    }
    int max_left, max_right, sum;
    max_left, &max_right, sum = findMaxCrossingSubarray(changes, 0, 8, 16, &max_left, &max_right);
    printf("\nCorrect Solution Tested: \nmax_left= %d \nmax_right= %d \nsum= %d\n\n", max_left, max_right, sum);
    printf("\nFailing Outputs:\n");
    int max_left_full, max_right_full, sum_full;
    max_left_full, &max_right_full, sum_full = findMaximumSubarray(changes, 0, 16);
    printf("\nmax_left_full= %d \nmax_right_full= %d\nsum_full= %d\n\n", max_left_full, max_right_full, sum_full);
    return 0;
}

Answer 1

Невозможно вернуть кортежи из функций в C. Когда вы разделяете значения с помощью запятой в C, все выражение просто вычисляется до последнего члена.

Итак, когда вы пишете:

a, b, c = some_function();

Это действительно означает:

/* do nothing */, /* do nothing */, c = some_function();

Если вы хотите вернуть составную структуру данных, используйте struct, т.е.

struct subarray
{
    int low;
    int high;
    int sum;
};

void findMaximumSubarray(int A[], int low, int high, struct subarray * result);

Если структура небольшая и вы используете современный компилятор и не работаете во встроенной системе, вы также можете вернуть структуру по значению:

struct subarray findMaximumSubarray(int A[], int low, int high);

Последний синтаксис упрощает использование, но может стать проблемой, если вы начнете , возвращая таким образом огромные структуры .