1. Self-Reference - Recursion Cmput 115 - Lecture 6 Department of Computing Science University of Alberta ©Duane Szafron 1999 Some code in this lecture is based on code from the book: Java Structures by Duane A. Bailey or the companion structure package Revised 1/2/00

2. ©Duane Szafron 1999 2 About This Lecture In this lecture we will learn about self- reference. This powerful idea allows us to: –Write self-referencing algorithms. –Construct self-referencing objects. –Prove properties about algorithms using mathematical induction. In this lecture we will focus on self- referencing Algorithms

3. ©Duane Szafron 1999 3Outline Self-reference Recursive methods Computing the sum 1 + 2 + … n recursively Inserting an element in a vector recursively Stack frames A trace of recursion

4. ©Duane Szafron 1999 4 Self-Reference Self-reference occurs when object refers to itself or more generally to another object from the same class. Self-reference also occurs when a method (or algorithm) calls itself. Such a method is called a recursive method. Self-reference also occurs when the proof of a theorem relies on the application of the same theorem to a simpler case. This situation is called mathematical induction.

5. ©Duane Szafron 1999 5 Recursive Methods Recursion occurs when a method calls itself, either directly or indirectly. For recursion to terminate, two conditions must be met: –the recursive call must somehow be simpler than the original call. –there must be one or more simple cases that do not make recursive calls (basis steps).

6. ©Duane Szafron 1999 6 Recursive Sum Example Write a method that computes the sum of the integers from 1 to n. Note that: 1 + 2 + … + n = (1 + 2 + … + n-1) + n public static int sum(int n) { // post: return the sum of ints from 1 to the given value if (n < 1) return 0; else return sum(n - 1) + n; } code based on Bailey pg. 59

7. ©Duane Szafron 1999 7 Vector Element Insertion Recall the iterative implementation : public void insertElementAt(Object object, int index) { //pre: 0 <= index <= size() //post: inserts the given object at the given index, // moving elements from index to size()-1 to the right int i; this.ensureCapacity(this.elementCount + 1); for (i = this.elementCount; i > index; i--) this.elementData[i] = this.elementData[i - 1]; this.elementData[index] = object; this.elementCount++; } code based on Bailey pg. 39 index

8. ©Duane Szafron 1999 8 Recursive Element Insertion Here is a recursive implementation: public void insertElementAt(Object object, int index) { //pre: 0 <= index <= size() //post: inserts the given object at the given index, // moving elements from index to size()-1 to the right Object previous; if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1); setElementAt(object, index); } code based on Bailey pg. 60 Basis step Recurring step

9. ©Duane Szafron 1999 9 Trace of Recursive Insert 12345 index=3 ins 2.5 this 12345 index=4 ins 3 this ins 4 12345 index=5 this (index=size(this)=5) add 5 12345 index=5 this 5 set 4 index=5 12344 this 5 index=4 set 3 12334 this ’ 5 set 2.5 12 34 this 5 index=3

10. ©Duane Szafron 1999 10 Direct References in Methods When a method is executing it can access some objects and some values. The receiver object can be referenced directly using the pseudo-variable this. Other objects and values can be referenced directly using method parameters and local variables. Still other objects and values can only be accessed indirectly by sending messages that return references to them.

11. ©Duane Szafron 1999 11 Method Activations and Frames A method can only access objects while it is executing or active. The collection of all direct references in a method is called the frame or stack frame of a method. The frame is created when the method is invoked, and destroyed when the method finishes. If a method is invoked again, a new frame is created for it.

12. ©Duane Szafron 1999 12 Multiple Activations of a Method When we invoke a recursive method on an object, the method becomes active. Before it is finished, it makes a recursive call to the same method. This means that when recursion is used, there is more than one copy of the same method active at once. Therefore, each active method has its own frame which contains independent copies of its direct references.

13. ©Duane Szafron 1999 13 Stack Frames for InsertElementAt Each frame has its own pseudo-variable, this, bound to a different receiver object. Each frame has two parameters, object and index. Each frame has its local variable, previous, bound to a different object. These frames all exist at the same time.

14. ©Duane Szafron 1999 14 Recursive Vector Insertion Example For example, insert “Wilma” at index 1. “Wilma” aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty”null 3

15. ©Duane Szafron 1999 15 Calling insertElementAt(“Wilma”, 1) if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1);....} this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty”null 3 “Wilma” 1 code based on Bailey pg. 60

16. ©Duane Szafron 1999 16 Calling insertElementAt(“Barney”, 2) this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty”null 3 “Wilma” 1 this object index previous 2 code based on Bailey pg. 60 if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1);....}

17. ©Duane Szafron 1999 17 Calling insertElementAt(“Betty”, 3) this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty”null 3 “Wilma” 1 2 this object index previous this object index previous 3 4 code based on Bailey pg. 60 if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1);....}

18. ©Duane Szafron 1999 18 Returning insertElementAt(“Betty”, 3) if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1); this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty” 4 “Wilma” 1 2 this object index previous this object index previous 3 code based on Bailey pg. 60

19. ©Duane Szafron 1999 19 Returning insertElementAt(“Barney”, 2) if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1); setElementAt(object, index); } this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty” 4 “Wilma” 1 this object index previous 2 code based on Bailey pg. 60

20. ©Duane Szafron 1999 20 Returning insertElementAt(“Wilma”, 1) this object index previous aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty” 4 “Wilma” 1 code based on Bailey pg. 60 if (index >= this.size()) this.addElement(object); else { previous = this.elementAt(index); this.insertElementAt(previous, index + 1); setElementAt(object, index); }

21. ©Duane Szafron 1999 21 Recursive Vector Insertion Done After, inserting “Wilma” at index 1. “Wilma” aVector elementData elementCount anArray 0123 “Fred”“Barney”“Betty” 4 “Wilma”

22. ©Duane Szafron 1999 22 Some Principles from the Textbook 7. Recursive structures must make “progress” towards a principles from Bailey ch. 4 “base case”.