Leetcode Compiler error of the control reaching end of non-void function

I am a newbie programmer, trying to go through questions on leetcode. I understand the logic, I know how the main function is in the back end of leetcode & about returning in a particular instructed way. But every time I write a code it throws a compiler error about the control reaching end of non-void function and I can't seem to figure out how to counter this error. Please help me out.

The code I have written and have been trying to run on leetcode (It is the problem 74: Search a 2-D matrix):

bool searchMatrix(int** matrix, int matrixSize, int* matrixColSize, int target){
    int x;
    for(int i=0;i<matrixSize;i++){
        if(target<=matrix[i][*matrixColSize-1])
           x=i;
    }
    if(target>matrix[matrixSize-1][*matrixColSize-1])
           return false;
    for(int j=0;j<*matrixColSize;j++){
        if(matrix[x][j]==target)
            return true;
        if(j==*matrixColSize-1 && matrix[x][j]!=target)
            return false;
    }
}

I can't seem to find what is wrong with the code. Even if I try to move the return command out of if loop, it just keeps returning false for every

If *matrixColSize is 0 (or worse, negative) the for loop will never execute, and you'll fall through to the end of the function without executing one of the return statements.

Even if the loop does execute, checking every time to see if it's the last iteration is a confusing way to write the function. Just let it finish the loop, and if it hasn't found a match, there's no match, so you can return false by default.

    for(int j=0;j<*matrixColSize;j++){
        if(matrix[x][j]==target)
            return true;
    }
    return false;

After executing this for loop

for(int j=0;j<*matrixColSize;j++){
if(matrix[x][j]==target)
return true;
if(j==*matrixColSize-1 && matrix[x][j]!=target)
return false;
}

the function returns nothing. You need to place a return statement after the for loop.

Or you need to rewrite the loop such a way that the result would be returned after the loop.

For example there could be used while loop as

int j = 0;
while ( j < *matrixColSize && matrix[x][j] != target ) ++j;
return j != *matrixColSize; 

Also it is unclear why the third parameter has pointer type

int* matrixColSize

Pay attention to that in C you can use variable length arrays that could be used instead of dynamically allocated arrays.

Another remark is that instead of this for loop

for(int i=0;i<matrixSize;i++){
if(target<=matrix[i][*matrixColSize-1])
x=i;
}

that searches the rows sequantially you could implement the binary search methid as the upper bound method because accirding to the description of the task each first element of the row is greater than the last element of the previous row. And then for the selected row you could use standard C function bsearch.

Here is a C++ program shown as a pseudo-code that demonstrates ideas how the function can be implemented based on the binary search method applied to rows of the matrix and then to the selected row.

#include <iostream>
#include <vector>
#include <iterator>
#include <algorithm>
bool searchMatrix( const std::vector<std::vector<int>> &matrix, int target )
{
std::vector<int> value = { target };
auto row = std::upper_bound( std::begin( matrix ), std::end( matrix ), value,
[]( const auto &row1, const auto &row2 ) { return row1[0] < row2[0]; } );
bool success = row != std::begin( matrix );
if (success)
{
std::advance( row, -1 );
size_t size = row->size();
success = !( ( *row )[size - 1] < target ) &&
std::binary_search( std::begin( *row ), std::end( *row ), target );
}
return success;
}
int main()
{
std::vector<std::vector<int>> matrix =
{
{  1,  3,  5,  7 },
{ 10, 11, 16, 20 },
{ 23, 30, 34, 60 }
};
std::cout << std::boolalpha;
std::cout << "searchMatrix( matrix, 0 )  is " << searchMatrix( matrix, 0 )  << '\n';
std::cout << "searchMatrix( matrix, 8 )  is " << searchMatrix( matrix, 8 )  << '\n';
std::cout << "searchMatrix( matrix, 3 )  is " << searchMatrix( matrix, 3 )  << '\n';
std::cout << "searchMatrix( matrix, 13 ) is " << searchMatrix( matrix, 13 ) << '\n';
std::cout << "searchMatrix( matrix, 60 ) is " << searchMatrix( matrix, 60 ) << '\n';
std::cout << "searchMatrix( matrix, 61 ) is " << searchMatrix( matrix, 61 ) << '\n';
}

The program output is

searchMatrix( matrix, 0 )  is false
searchMatrix( matrix, 8 )  is false
searchMatrix( matrix, 3 )  is true
searchMatrix( matrix, 13 ) is false
searchMatrix( matrix, 60 ) is true
searchMatrix( matrix, 61 ) is false

That is in your function implementation instead of the first for loop

for(int i=0;i<matrixSize;i++){
if(target<=matrix[i][*matrixColSize-1])
x=i;
}

you should use the binary search method (written by you yourself) to find the target row. In the shown C++ program above it is the standard algorithm std::upper_bound.

And then instead of the second for loop you should use standard C function bsearch because as it is written in the assignment

> You must write a solution in O(log(m * n)) time complexity.

It is the main requirement of the assignment. That is you shall not use the sequential search within the function.

Update. I would write the function in C the following way

bool searchMatrix( int **matrix, int matrixSize, int *matrixColSize, int target ) 
{
bool success = matrixSize > 0 && *matrixColSize > 0;
if (success)
{
int target_row = 0, last_row = matrixSize;
while (target_row < last_row)
{
int middle_row = target_row + ( last_row - target_row ) / 2;
if (target < matrix[middle_row][0])
{
last_row = middle_row;
}
else
{
target_row = middle_row + 1;
}
}
success = target_row != 0;
if ( success )
{
--target_row;
success = !( matrix[target_row][*matrixColSize - 1] < target ) &&
bsearch( &target, matrix[target_row], *matrixColSize, sizeof( int ), cmp ) != NULL;
}
}
return success;
}

I used the declaration presented in the site though as I already pointed out there is neither sense to pass the number of columns through a pointer to it.

The function cmp can look the following way

int cmp( const void *p1, const void *p2 )
{
int x = *( const int * )p1;
int y = *( const int * )p2;
return ( y < x ) - ( x < y );
}