Recursion on OOFP 2025-26

Linear recursion

Mon, 01 Jan 0001 00:00:00 +0000

Linear recursion #

Definition. A recursive function/method is linear recursive if it performs at most one recursive call each time it is executed.

Hint. In an imperative language (like Java), a linear recursive algorithm can easily be transformed into an iterative one (i.e. an algorithm that uses only loops).

Haskell does not admit loops, so linear recursion is the standard way to perform simple iterations (although list comprehensions can be used instead in certain cases). Accordingly, in this section, we will mostly use Haskell as an illustration.

Intermediate result

Mon, 01 Jan 0001 00:00:00 +0000

Recursion and intermediate result #

In some cases, we need recursive calls to return more information than what the function should compute.

Example. We want to implement a function
longestWord :: String -> Int
that maps a string to the length of its longest word.

For simplicity, we will assume that words are separated by a blank space (noted ' ' in Haskell).
For instance,
longestWord "Hi there"
should evaluate to 5.

Recall that a string in Haskell is an array of characters.

Accumulator and tail recursion

Mon, 01 Jan 0001 00:00:00 +0000

Accumulator and tail recursion #

Tail recursion #

Definition. A function/method is tail-recursive if it is:

linear recursive, and

does not perform any operation after a recursive call.

Example. The following function is tail-recursive

-- `True` iff the input string ends with an `s`
endsWithS :: String -> Bool
endsWithS [] = False               -- first base case
endsWithS ['s'] = True             -- second base case
endsWithS (_ : cs) = endsWithS cs  -- inductive case

Example. The function sum seen earlier (and reproduced here) is not tail-recursive, because the addition (Line 3) is performed after termination of the recursive call.