Recursion - 1. Recursion. Recursion - 2. A Simple Recursive Example

Transcription

1 Recursion - 1 Only looping method in pure Lisp is recursion Recursion Based on Chapter 6 of Wilensky Recursive function f includes calls to f in its definition For a recursive function to eventually terminate the size of the arguments of recursive function calls need to be smaller than the original call LP-1 LP-2 Recursion - 2 A Simple Recursive Example Calculate n th power of some number m (i.e. m n ) Recursive programming involves:» Identifying how the task at hand can be solved by solving a simpler version of the same task» Specify a way to combine solutions to simpler versions to solve the original problem» Identify a base case (and its value) Base case: n = 0 which returns a result of 1 Recursive case: m n = m x m n-1 n > 0 (defun my_exp( m n ) (if ( zerop n ) 1 ( * m ( my_exp m ( - n 1 ) ) ) ) ) LP-3 LP-4

2 Recursion a general template ( defun recursive (thelist otherparameters) (cond ( (null thelist) (first base case) )... ( (pred1) (last base case) ) Recursion in General Base case: atom, nil, 0, 1, Reduction Operator: car, cdr, -1, +2, Composition Operator: cons, append, +, *, identity function, )) ( (pred2) (first nonbase case) )... ( t (last nonbase case) ) For example in function my_exp» Base case: n = 0» Reduction operator: -1» Composition Operator: * LP-5 LP-6 Recursion on Lists car recursion» Reduction by car: base case is typically an atom cdr recursion» Reducton by cdr: base case is typically the empty list car/cdr recursion» Reduction by car and cdr. Base case is an atom or the empty list car Recursion - Example ( very-first x ) finds the first atom of an s-expression. > (very-first a) A > (very-first ( ( b ) ( a c ) ) ) B > (very-first ( ( ) ( ( ( r ) v ) ) ) ) Base case: atom Reduction operator: car Composition operator: identity function ( defun very-first ( x ) ( cond ( ( atom x ) x ) LP-7 ( t ( very-first ( car x ) ) ) ) ) LP-8

3 cdr Recursion - Example car/cdr Recursion - Example ( my_append l1 l2 ) joins the contents of two lists together expression. > ( my_append ( a b c ) ( d e ) ) ( A B C D E ) > ( my_append ( ) ( x y ) ) ( X Y ) > (my_append ( ( a ) b ) ( ) ) ( ( A ) B ) Base case: If l1 is empty list result is l2 Composition operator: cons ( defun my_append ( l1 l2 ) ( cond ( ( null l1 ) l2 ) ( t ( cons ( car l1 ) ( my_append ( cdr l1 ) l2 ) ) ) ) ) LP-9 ( my_equal s1 s2 ) returns true if s1 and s2 have the same structure (same as Lisp built-in function equal ) Base case: atom or empty list Reduction operator: car or cdr Composition operator: and ( defun my_equal ( s1 s2 ) ( cond ( ( atom s1 ) ( and ( atom s2 ) ( eq s1 s2 ) ) ( (atom s2 ) nil ) ( t ( and ( my_equal (car s1 ) ( car s2 ) ) ( my_equal ( cdr s1 ) ( cdr s2 ) ) ) ) ) ) LP-10 Single / Double Recursion Tail Recursion When the function only calls itself once referred to as singly recursive» car recursion is singly recursive» cdr recursion is singly recursive When the value returned by the internal recursive call is the same as the value returned by the outer call tail recursion The composition function is the identity function When the function calls itself twice referred to as doubly recursive» car/cdr recursion is doubly recursive Tail recursion is more efficient LP-11 LP-12

4 Recursion - Example 1 ( my-length l ) is a function that counts the number of top-level elements in the list l ( Lisp has a built-in function length that does this ) > (my-length ( a ( b ) c ) ) 3 > ( my-length ( ) ) 0 > ( my-length ( ( ) ) ) 1 Recursion - Example 1 ( defun my-length ( l ) ( if ( null l ) 0 ( 1+ (my-length ( cdr l ) ) ) ) ) Composition Operator: 1+ IS THERE A MORE EFFICIENT WAY TO DO THIS??? LP-13 LP-14 Recursion - Example 1 - Revisited Recursion - Example 2 Use tail recursion to make function my-length more efficient ( reverse l ) is a function that returns the top-level elements of list l in reverse order ( defun my-length ( l ) ( my-length-aux l 0 ) ) > ( reverse ( a b c ) ) ( C B A ) > ( reverse ( a ( b c ) d ) ) ( defun my-length-aux ( l result ) ( if ( null l ) result ( my-length-aux ( cdr l ) ( 1+ result ) ) ) ) ( D ( B C ) A ) > ( reverse ( ) ) LP-15 LP-16

5 Recursion - Example 2 Recursion - Example 2 - Revisited ( defun reverse ( l ) ( cond ( null l ) nil Use tail recursion to make function reverse more efficient ( t ( append ( reverse ( cdr l ) ) ( list ( car l ) ) ) ) ) ( defun tail-reverse ( l ) ( tail-reverse-aux l ( ) ) ) Composition Operator: append ( defun tail-reverse-aux ( l result ) ( cond ( ( null l ) result ) IS THERE A MORE EFFICIENT WAY TO DO THIS??? ) ) ) ( t ( tail-reverse-aux ( cdr l ) ( cons (car l ) result ) ) LP-17 LP-18 Recursion - Example 2 Recursion- Example 3 In case you were wondering. (remove-top list item ) removes item from list only at the top level > ( remove-top '( ) 'a ) Tail recursion can be much more efficient Complexity of reverse: O(n 2 ) Complexity of tail-reverse: O(n) > ( remove-top '( a b c ) 'a ) ( B C ) > ( remove-top '( a ( b c ) b ) 'b ) ( A ( B C ) ) Composition operator: cons LP-19 LP-20

6 Recursion- Example 3 Recursion- Example 4 (remove-all list item ) removes item from list at any level (defun remove-top (list item) (cond ( ( null list ) nil ) ( ( equal ( car list ) item ) ( remove-top ( cdr list ) item ) ) ( t ( cons ( car list ) ( remove-top ( cdr list ) item ) ) ) )) > ( remove-all ( ) a ) > ( remove-all ( a b c ) a ) ( B C ) > ( remove-all ( a ( ( b ) c ) b ) b ) ( A ( C ) ) Composition operator: cons LP-21 LP-22 Recursion - Example 4 (defun remove-all (list item) )) (cond ( ( null list ) nil ) ( ( equal ( car list ) item ) ( remove-all ( cdr list ) item ) ) ( ( atom ( car list ) ) ( cons ( car list ) ( remove-all ( cdr list ) item ) ) ) ( t ( cons ( remove-all ( car list ) item ) ( remove-all ( cdr list ) item ) ) ) LP-23