How does this recursive algorithm work?

Question

One question from the Grokking Algorithms book:

Implement a max([]int) function, returning the biggest element in the array.

Here's my solution in Golang (adapted from the Python solution in the book):

func maxNumber(arr []int) (r int) {
 // base case
 if len(arr) == 2 {
 if arr[0] > arr[1] {
 return arr[0]
 } else {
 return arr[1]
 }
 }
 // recursive case
 subMax := maxNumber(arr[1:])
 if arr[0] > subMax {
 fmt.Println("arr[0] > subMax")
 return arr[0]
 } else {
 fmt.Println("arr[0] < subMax")
 return subMax
 }
}

It works, but I can wrap my head around it. How is the third block called if every time maxNumber(arr[1:]) is called it executes the function again, passing the array with one last element? If so, at some point in time it will hit the first block (base case) and return or the first element or the second.

I know the function works, but I'm missing the how.

Could someone help me around, explain like I'm 5 styles haha

Thanks!

• gandalf61: arr[1:] is the list arr without its first element. So the array argument becomes shorter at each level of recursion, until finally it has only two elements, which is the base case. Does that help ?
• user555045: By the way it doesn't work for an array of length 1, and making it work would make the algorithm simpler

Answer 1

The base case works because, if the array contains only 2 elements, it compares them and return the biggest. Starting from this assumption, the recursive call to the function maxNumber compare the maxnumber of the precedent call to the next element in the array. when the list has been read all the way to the end, the algorithm will return the max number of the whole list.

• jonatasbaldin: Thanks it helped a lot! Also I used Python Visualizer (and Python code), which helped me even more ✨ tinyurl.com/y6lg85qj