I was thinking about a recursive algorithm (it's a theoretical question, so it's not important the programming language). It consists of finding the minimum of a set of numbers

I was thinking of this way: let "n" be the number of elements in the set. let's rearrange the set as:

• (a, (b, c, ..., z) ).

the function moves from left to right, and the first element is assumed as minimum in the first phase (it's, of course, the 0-th element, a). next steps are defined as follows:

• (a, min(b, c, ..., z) ), check if a is still minimum, or if b is to be assumed as minimum, then (a or b, min(c, d, ..., z) ), another check condition, (a or b or c, min(d, e, ..., z)), check condition, etc.

I think the theoretical pseudocode may be as follows:

f(x) {

// base case 
if I've reached the last element, assume it's a possible minimum, and check if y < z. then return a value to stop recursive calls.  
// inductive steps
if ( f(i-th element) < f(i 1, next element) ) { 
/* just assume the current element is the current minimum */ 
} 
} 

I'm having trouble with the base case. I don't know how to formalize it. I think I've understood the basic idea about it: it's basically what I've written in the pseudocode, right?

---

does what I've written so far make sense? Sorry if it's not clear but I'm a beginner, and I'm studying recursion for the first time, and I personally find it confusing. So, I've tried my best to explain it. If it's not clear, let me know, and I'll try to explain it better with different words.

CodePudding user response：

To me, it's more like this:

int f(int[] x)
{
    var minimum = head of X;
    if (x has tail)
    {
        var remainder = f(tail of x);
        if (remainder < minimum)
        {
            minimum = remainder;
        }
    }
    return minimum;
}

CodePudding user response：

You have the right idea.

You've correctly observed that

min_recursive(array) = min(array[0], min_recursive(array[1:]))

The function doesn't care about who's calling it or what's going on outside of it -- it just needs to return the minimum of the array passed in. The base case is when the array has a single value. That value is the minimum of the array so it should just return it. Otherwise find the minimum of the rest of the array by calling itself again and compare the result with the head of the array.

The other answers show some coding examples.

CodePudding user response：

This is a recursive solution to the problem that you posed, using JavaScript:

a = [5,12,3,5,34,12]

const min = a => {
  if (!a.length) { return 0 }
    if (a.length === 1) { return a[0] }
    return Math.min(a[0], min(a.slice(1)))
}

min(a)

Note the approach which is to first detect the simplest case (empty array), then a more complex case (single element array), then finally a recursive call which will reduce more complex cases to functions of simpler ones.

However, you don't need recursion to traverse a one dimensional array.

CodePudding user response：

Recursive problems can be hard to visualize. Let's take an example : arr = [3,5,1,6]

This is a relatively small array but still it's not easy to visualize how recursion will work here from start to end.

Tip : Try to reduce the size of the input. This will make it easy to visualize and help you with finding the base case. First decide what our function should do. In our case it finds the minimum number from an array. If our function works for array of size n then it should also work for array of size n-1 (Recursive leap of faith). Now using this we can reduce the size of input until we cannot reduce it any further, which should give us our base case.

Let's use the above example: arr = [3,5,1,6]

Let create a function findMin(arr, start) which takes an array and a start index and returns the minimum number from start index to end of array.

1st Iteration : [3,5,1,6]
// arr[start] = 3, If we can somehow find minimum from the remaining array,
// then we can compare it with current element and return the minimum of the two.
// so our input is now reduced to the remaining array [5,1,6]

2nd Iteration : [5,1,6]
// arr[start] = 5, If we can somehow find minimum from the remaining array,
// then we can compare it with current element and return the minimum of the two.
// so our input is now reduced to the remaining array [1,6]

3rd Iteration : [1,6]
// arr[start] = 1, If we can somehow find minimum from the remaining array,
// then we can compare it with current element and return the minimum of the two.
// so our input is now reduced to the remaining array [6]

4th Iteration : [6]
// arr[start] = 6, Since it is the only element in the array, it is the minimum.
// This is our base case as we cannot reduce the input any further.
// We will simply return 6.

------------ Tracking Back ------------

3rd Iteration : [1,6]
// 1 will be compared with whatever the 4th Iteration returned (6 in this case).
// This iteration will return minimum(1, 4th Iteration) => minimum(1,6) => 1 

2nd Iteration : [5,1,6]
// 5 will be compared with whatever the 3th Iteration returned (1 in this case).
// This iteration will return minimum(5, 3rd Iteration) => minimum(5,1) => 1 

1st Iteration : [3,5,1,6]
// 3 will be compared with whatever the 2nd Iteration returned (1 in this case).
// This iteration will return minimum(3, 2nd Iteration) => minimum(3,1) => 1 

Final answer = 1

function findMin(arr, start) {
  if (start === arr.length - 1) return arr[start];
  return Math.min(arr[start], findMin(arr, start   1));
}

const arr = [3, 5, 1, 6];
const min = findMin(arr, 0);
console.log('Minimum element = ', min);

This is a good problem for practicing recursion for beginners. You can also try these problems for practice.

1. Reverse a string using recursion.
2. Reverse a stack using recursion.
3. Sort a stack using recursion.