Trying to find the smallest number in a 2D array using recursion - c++

Question

I'm trying to find the smallest number in a 2D (pointer to pointer) array using recursion, here is the code so far:
int smallest(int **arr, int row_size, int column_size)
{
if (row_size == 0 && column_size == 0)
{
return *(*(arr + 0) + 0);
}
row_size--;
column_size--;
if ((*(*(arr + 0) + 0)) < (*(*arr + row_size) + column_size))
{
return smallest(arr, row_size, column_size);
}
else
{
*(*(arr + 0) + 0) = *(*(arr + row_size) + column_size);
return smallest(arr, row_size, column_size);
}
}
This works but has 2 drawbacks:
1- Only processes square arrays.
2- Only processes indexes where row & column numbers are the same (such as 1,1 2,2 & 3,3 etc.)
I'm trying to make it process non-square arrays as well but that would require decrementing rows and column numbers at different times, I'm not sure how to go about that. Any clues?

Answer 1

Bored professionals overkill introductory problems, volume 3! This version:
Uses a secondary function to traverse each row (that might be off-limits of the question's rules, but you can combine them and switch on whether the pointers array has only one row)
Works with empty arrays (and returns the maximal value of an int)
Does not use index notation
Is purely recursive
int smallest(int const * const array, int const length) {
return length == 0
? std::numeric_limits<int>::max()
: std::min(*array, smallest(array + 1, length - 1));
}
int smallest(int const * const * const array, int const rows, int const columns) {
return rows == 0
? std::numeric_limits<int>::max()
: std::min(
smallest(*array, columns), // Minimum from the current row
smallest(array + 1, rows - 1, columns) // Minimum from the rest of the rows
);
}
See it live on Coliru

Answer 2

not tested, but I think it would work.
#include <algorithm>
#include <limits>
//call with row = row_size-1, column = column_size -1
int smallest(int **arr, int row, int column)
{
if( row<0 || column<0 )return std::numeric_limits<int>::max();
return std::min( {arr[row][column], smallest(arr,row-1,column), smallest(arr,row,column-1)} );
}
The recursion is

Answer 3

Assumed requirements:
Cannot modify function signature (can be simpler if this is not the case)
Can only have a single function (ditto)
Must be purely recursive (i.e. no loops)
Must use pointer dereferencing (*(arr + 1) instead of arr[1])
Procedure:
Recurse through the first row only (setting rows to 1)
Recurse through all other rows (decrement rows)
Code:
int smallest(int **arr, int rows, int columns)
{
// invalid input
if (rows <= 0 || columns <= 0)
return INT_MAX;
// top-left element
int m = **arr;
// single row recursion
if (rows == 1) {
*arr++; // increment the temporary pointer from below
return min(m, smallest(arr, 1, columns - 1));
}
// create a temporary pointer to the first row
// and start recursion in this single row
int* row = *arr;
m = min(m, smallest(&row, 1, columns));
// rest of array
return min(m, smallest(arr + 1, rows, columns - 1));
}
EDIT: since you are allowed to modify the function signature, you can add an extra index for looping through each row; this removes the need for that extra temporary pointer.
int smallest(int **arr, int rows, int columns, int column_index = 0)
{
// invalid input
if (rows <= 0 || column_index >= columns)
return INT_MAX;
// single row recursion
if (rows == 1)
return min(*(*arr + column_index), // first element of row
smallest(arr, 1, columns - 1,
column_index + 1)); // rest of row
// rest of array
return min(smallest(arr, 1, columns), // start on first row
smallest(arr + 1, rows - 1, columns));
}
Note that external call signatures can still be the same as before due to the default argument value.

Answer 4

You'll need to pass the matrix bounds to the function so you can "move" in one dimension when you reach the end of the other.
Something like this (I find it more natural to count upwards than downwards):
int smallest(int **arr, int row, int column, int row_last, int column_last)
{
if (row == row_last && column == column_last)
{
return arr[row][column];
}
else if (column == column_last)
{
return min(arr[row][column], smallest(arr, row+1, 0, row_last, column_last));
}
else
{
return min(arr[row][column], smallest(arr, row, column+1, row_last, column_last));
}
}
(This is one of those exercises that introduces potentially useful concepts in a situation where they don't serve any purpose. It's not a good use of either recursion or pointer arithmetic.)

Answer 5

Though you can get away without recursion, if this is a purely learning excercise for recursion you could try DFS approach.
Have an entry point to start your search (i,j), from each point exhaust all possible areas you could go, (i+1,j)(i-1,j)(i,j+1)(i,j-1). Each recursion step would also check if you are in within the limits of the array which would be i < 0 || i >= rows || j < 0 || j >= cols || visited[i][j] you would just return at this point.
Notice the visited array. So at each point in the recursion there could be a chance that you return back to the same cell right? that would make it an infinite recrusion to avoid this, you track which cells you have already visited, visited[i][j]. Mark them. Each recrusion call keep track of the minimum element recorded by reference, which will be your minimum element.
void findMinElement(vector<vector<int>>& array, int& minelement, int i, int j, vector<vector<bool>>& visited)
{
if(i < 0 || i >= array.size() || j < 0 || j >= array[0].size() || visited[i][j]) return;
minelement = min(minelement,array[i][j]); // is this the best minimum?
visited[i][j] = true; // done visiting this cell
//lets visits others
findMinElement(array, minelement, i+1, j, visited);
findMinElement(array, minelement, i-1, j, visited);
findMinElement(array, minelement, i, j+1, visited);
findMinElement(array, minelement, i, j-1, visited);
}
int main()
{
vector<vector<int>> array =
{
{9,8,6,4},
{13,4,6,11},
{3,8,3,100}
};
int minElement = INT32_MAX;
//same dimensions as array
vector<vector<bool>> visited(array.size(), vector<bool>(array[0].size(),false));
//start from (0,0)
findMinElement(array,minElement,0,0,visited);
cout << minElement;
}
This now gives you the flexibility to start searching from any location in the array as well. It might be a bit to take in, but it will help you with many problems further down the line.

Answer 6

I couldn't help myself. This is an implementation that will divide the input array into four smaller arrays and calls iself on them (unless they are zero size):
int smallest(int **arr, int row_begin, int row_end, int column_begin, int column_end)
{
if (row_end - row_begin == 1 && column_end - column_begin == 1) return *(*(arr + row_begin) + column_begin);
int row_mid = (row_begin + row_end) / 2;
int column_mid = (column_begin + column_end) / 2;
int minimum = smallest(arr, row_mid, row_end, column_mid, column_end);
if (column_mid > column_begin) {
int m = smallest(arr, row_mid, row_end, column_begin, column_mid);
if (m < minimum) minimum = m;
}
if (row_mid > row_begin) {
int m = smallest(arr, row_begin, row_mid, column_begin, column_end);
if (m < minimum) minimum = m;
}
if (column_mid > column_begin && row_mid > row_begin) {
int m = smallest(arr, row_begin, row_mid, column_begin, column_mid);
if (m < minimum) minimum = m;
}
return minimum;
}
Call it like this:
cout << smallest(test_array, 0, rows, 0, columns);

Answer 7

I would do something like:
int smallest(int **arr, int row_size, int column_size)
{
if (row_size > 0 && column_size > 0)
{
int minRow = arr[0][0];
for (int j = 0; j < row_size; ++j)
{
const int *row = arr[j];
minRow = std::min(minRow, *std::min_element(row, row + column_size));
}
return minRow;
}
else return INT_MAX;
}