# Effectively Using "return" in a Recursive Function

Recursion, a fascinating technique in programming, allows a function to call itself to solve complex problems by breaking them into smaller sub-problems. One aspect that demands careful consideration in recursive functions is the strategic use of the `return` statement. Let's delve into scenarios where `return` is essential, where it can be optional, and how it impacts the behaviour of recursive functions.

## Using `return` in Recursion

### 1\. Base Case

Consider a classic example: calculating the factorial of a number using recursion.

```python
def factorial(n):
    if n <= 1:
        return 1
    else:
        return n * factorial(n - 1)
```

In this scenario, the base case is when `n` is 1 or less. Here, the `return` statement is crucial to halt the recursion and provide an immediate result.

### 2\. Returning Recursive Results

Imagine summing the elements of a list using recursion:

```python
def sum_list_recursive(arr):
    if not arr:
        return 0
    else:
        return arr[0] + sum_list_recursive(arr[1:])
```

The `sum_list_recursive` function employs a `return` statement to convey the sum of the current element (`arr[0]`) along with the result of the recursive call (`sum_list_recursive(arr[1:])`).

## When Not to Use `return` in Recursion

### 1\. Void Functions

Void functions are those that don't necessarily return a value but perform an action. For instance, consider a function that prints numbers in descending order:

```python
def print_numbers(n):
    if n <= 0:
        return
    else:
        print(n)
        print_numbers(n - 1)
```

In this case, the `return` statement serves to halt the recursion when `n` reaches 0 or a negative value.

### **2\. Exploration: Printing List Elements**

Consider a function that prints the elements of a list using recursion:

```python
def print_list_elements(arr, index):
    if index < len(arr):
        print(arr[index])
        print_list_elements(arr, index + 1)
```

In this case, the function explores the list and prints each element. The primary goal is to traverse the list and perform an action (printing), so the `return` statement is not necessary for this specific purpose.

### **3\. Accumulating State: Counting Odd Numbers**

Imagine a scenario where you want to count the number of odd elements in a list using recursion:

```python
def count_odd_numbers(arr, index):
    if index >= len(arr):
        return 0
    else:
        current_number = arr[index]
        is_odd = current_number % 2 != 0
        return is_odd + count_odd_numbers(arr, index + 1)
# Usage
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]
odd_count = count_odd_numbers(numbers, 0)
print("Number of odd elements:", odd_count)
```

In this example, the function `count_odd_numbers` traverses the list and counts the number of odd elements. The key point here is to accumulate the count, and the `return` statement is used to propagate the count value through the recursive calls.

### **Key Takeaway:**

1. **Base Case:** Always ensure that base cases have `return` statements to halt the recursion.
    
2. **Returning Results:** When calculating and propagating results based on recursive calls, employ `return` to pass these results.
    
3. **Void Functions:** For functions with side effects or exploration, where returning values isn't the primary focus, the use of `return` might not be obligatory.
    
4. **Exploration:** When exploring a data structure (like traversing a list or tree) without returning specific values from each recursive call, the `return` statement can be omitted in those calls.
    
5. **Accumulating State:** When the primary goal of a recursive function is to accumulate a count or perform a specific action based on the recursion (like counting odd numbers or updating values), using the `return` statement helps in aggregating the desired result.
    

Recall that the decision to utilize `return` in recursion hinges on the specific problem at hand and the intended behavior of your function. By understanding the context and purpose of your recursive function, you can navigate the realm of `return` with finesse and elevate your mastery of recursive problem-solving.