We start by making "result" equal to zero. Then we iterate through the list, adding "result" to "result" each time. Then, once we've gone through the whole list, we make "result" equal to "result" plus the number in our list. This is one way to do it.
This algorithm would not correctly sum a list. A recursive list-sum should add the first element to the sum of the remaining list, not repeatedly add `result` to itself and then add one final element.
Full reasoning
This description is not a correct way to sum a list recursively.
A standard recursive list-sum has:
- a base case: the empty list sums to
0 - a recursive case: for a non-empty list, return
first_element + sum(rest_of_list)
For example, MIT's recursion notes define recursive list summation as return x[0] + sum_list(x[1:]), and UT Austin's recursion slides likewise define sumItemsInList(L) as 0 for the empty list and otherwise L[0] + sumItemsInList(L[1:]).
By contrast, the quoted algorithm says to keep adding result to itself during iteration. If result starts at 0, then repeatedly doing result = result + result keeps it at 0. Even if interpreted differently, the final step only adds "the number in our list," which refers to a single element rather than recursively summing the remainder of the list. So the described procedure does not correctly compute the sum of all items in a list.
2 sources
- 6.101: Recursion
Under “Summing a List,” MIT gives the recursive case as `return x[0] + sum_list(x[1:])` and later simplifies the full function to `if not x: return 0 else: return x[0] + sum_list(x[1:])`.
- CS303E: Elements of Computers and Programming — Recursion
The slides state: “Base case: If L is empty, the sum is 0” and then define `sumItemsInList(L)` with `return L[0] + sumItemsInList(L[1:])` for the recursive case.