Methods of tracking pointer objects through functions in C

Question

I'm stuck trying to implement pseudocode from an algorithm book. My code compiles and prints out the correct answer, except some of the information I want to print out is not displaying correctly. Here's what the console output looks like:

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

The first three values printed are the correct results arrived by brute implementation of one part of the algorithm. In the code, this is the function "findMaxCrossingSubarray" all by itself. The second part printed out is when I execute the full algorithm "findMaximumSubarray". I believe it should be printing out results that show approaching the solution. The final answer given by the variable "sum_full" appears to be correct since it matches the brute force solution which the book says is the correct answer.

I've been trying to find how I can print the correct max_left_full and max_right_full values and not what I believe is the memory address. I'm at a point where if I change a pointer in one place it makes the solution incorrect or print out a memory address as well.

Is there a simple way to find where I may be dropping the ball?

#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;
}

@Groo Thanks! That makes sense of it. – Jacob Breckenridge Nov 13 '18 at 23:35 — Jacob Breckenridge, Nov 13 '18 at 23:35

score 1 · Accepted Answer · answered Nov 13 '18 at 23:35

You cannot return tuples from functions in C. When you separate values using a comma in C, the whole expression simply evaluates to the last member.

So when you write:

a, b, c = some_function();

It really means:

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

If you want to return a composite data structure, use a struct, i.e.

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

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

If the struct is small and you are using a modern compiler, and not running on an embedded system, then you can also return the struct by value:

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

The latter syntax simplifies usage, but it can become an issue if you start returning huge structs this way.

Methods of tracking pointer objects through functions in C

1 Answers1