Presentation is loading. Please wait.

Presentation is loading. Please wait.

How do visitors work? This set of slides traces through the execution of a visitor we’ve seen before (the lengthVisitor) on a short list. It shows how.

Published by Modified over 9 years ago

Similar presentations

Presentation on theme: "How do visitors work? This set of slides traces through the execution of a visitor we’ve seen before (the lengthVisitor) on a short list. It shows how."— Presentation transcript:

1 How do visitors work? This set of slides traces through the execution of a visitor we’ve seen before (the lengthVisitor) on a short list. It shows how the runtime stack makes recursion possible. First let’s recall: –how the visitor is defined –how ‘execute’ is defined in the two list state classes

2 Length visitor in the empty case the answer is zero in the non-empty case the answer is one more than the length of the rest of the list public Object emptyCase(LRS host, Object _){ return 0; } public Object nonEmptyCase(LRS host, Object _){ return 1 + host.getRest().execute(this,_); }

3 ‘execute’ definition in states Empty state: public Object execute(LRS host, IAlgo visitor, Object input){ return visitor.emptyCase(host, input); } NonEmpty state: public Object execute(LRS host, IAlgo visitor, Object input){ return visitor.nonEmptyCase(host, input); }

4 Now let’s trace execution of the visitor LRStruct list = new LRStruct (); list.insertFront(“Wilma”).insertFront(“Fred”); LengthVisitor visitor = new LengthVisitor (); int len = list.execute(visitor,null); System.out.println(“Length is ” + length); Focus on the evaluation of: list.execute(visitor,null)

5 list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

6 algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…}  space for return value visitor inp (null) this Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

7 algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…}  space for return value visitor inp (null) this Polymorphi c method call Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

8 algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

9 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

10 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

11 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this Polymorphi c method call Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

12 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

13 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

14 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

15 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this Polymorphi c method call Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

16 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

17 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner 0 host _ (null) this Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

18 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner 0 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

19 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) algo inp (null) this 0 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

20 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) 0 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

21 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner this host _ (null) 0 1 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

22 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this algo input (null) owner 0 1 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

23 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) algo inp (null) this 0 1 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

24 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) 0 1 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

25 this algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner this host _ (null) 0 1 2 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

26 algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…} visitor inp (null) this algo input (null) owner 0 1 2 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

27 algo list Tracing the execution of a visitor _state _datum _rest “Fred” _state _datum _rest “Wilma” _state public Object emptyCase(…){…} public Object nonEmptyCase(…){…}  space for return value visitor inp (null) this 0 1 2 Driver: int len = list.execute(visitor, null); LRS: public Object execute(IAlgo algo, Object inp){ return _state.execute(algo, inp, this); } EmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.emptyCase(host, arg); } NonEmptyState: public O execute(IAlgo algo, LRStruct host, I arg) { return algo.nonEmptyCase(host, arg); } LengthVisitor: public Integer emptyCase(LRStruct host, Object _) { return 0; // isn't autoboxing cool :-) } public Integer nonEmptyCase(LRStruct host, Object _) { return 1 + host.getRest().execute(this, _); }

28 That’s it! Questions?

29 Exercise Assume you are given an LRS containing Integer objects (all non-null). Write a visitor which traverses the list structure and calculates the sum of all the int values. Ex: If the list contains Integers for 1, 2, 3, 4 and 5, the visitor must return an Integer containing 15.

30 A solution public class SumVisitor implements IAlgo { // The answer in the case of an empty list is zero // (because zero is the identity element of addition). public Integer emptyCase(LRStruct host, Object _) { return 0; } // The answer in the case of a non-empty list is the sum of // the first item in the list and the sum of the rest of the // items in the list. public Integer nonEmptyCase(LRStruct host, Object _) { return host.getDatum() + host.getRest().execute(this, _); }

31 Additional exercises Write a visitor for an LRS of Integers which returns the largest Integer. Write a visitor for an LRS of Integers, which you can assume appear in order from smallest to largest, which inserts its input in the correct (in order) position within the LRS.

Download ppt "How do visitors work? This set of slides traces through the execution of a visitor we’ve seen before (the lengthVisitor) on a short list. It shows how."

Similar presentations

Haskell Lets review some of the Haskell concepts you have been learning on your own. The answers are included, but try it yourself first.

Haskell Lets review some of the Haskell concepts you have been learning on your own. The answers are included, but try it yourself first.
Data Structures Lecture 13: QUEUES Azhar Maqsood NUST Institute of Information Technology (NIIT)

Data Structures Lecture 13: QUEUES Azhar Maqsood NUST Institute of Information Technology (NIIT)
Stacks & Their Applications COP 3502. Stacks  A stack is a data structure that stores information arranged like a stack.  We have seen stacks before.

Stacks & Their Applications COP Stacks  A stack is a data structure that stores information arranged like a stack.  We have seen stacks before.
Programming Recursion.

Programming Recursion.
A list = a Linear Recursive Structure (LRS or LRStruct) What is a list? 1.the empty list is a list 2.a pair whose tail is a list is itself a list This.

A list = a Linear Recursive Structure (LRS or LRStruct) What is a list? 1.the empty list is a list 2.a pair whose tail is a list is itself a list This.
Preliminaries Attendance sheets –I remembered! Survey links –HW1 time survey –Anonymous feedback survey HW discussion (4PM, Commons 9)

Preliminaries Attendance sheets –I remembered! Survey links –HW1 time survey –Anonymous feedback survey HW discussion (4PM, Commons 9)
Talk tonight Richard Stallman Norton 112 6:00 PM.

Talk tonight Richard Stallman Norton 112 6:00 PM.
Preliminaries Stage 1 due tonight by 9:00 PM HW1 discussion (4PM, Commons 9) –may try for next week? HW2 available later today, due Monday by 9:00 PM.

Preliminaries Stage 1 due tonight by 9:00 PM HW1 discussion (4PM, Commons 9) –may try for next week? HW2 available later today, due Monday by 9:00 PM.
Map, filter and reduce Programming by composition.

Map, filter and reduce Programming by composition.
No homework this week Stage 2 starts next week. Code review Team with N members is assigned N submissions to review Discuss submissions within team Everyone.

No homework this week Stage 2 starts next week. Code review Team with N members is assigned N submissions to review Discuss submissions within team Everyone.
Lists We’ve seen an array-based list implementation, the ArrayList. Advantage of an array-based implementation: –fast access to a specific index –typically.

Lists We’ve seen an array-based list implementation, the ArrayList. Advantage of an array-based implementation: –fast access to a specific index –typically.
Imperative programming public int factorial (int N){ int F = 1; for(X=N; X>1; X-- ){ F= F*X; } return F; } Functional programming (defun factorial(N) (cond.

Imperative programming public int factorial (int N){ int F = 1; for(X=N; X>1; X-- ){ F= F*X; } return F; } Functional programming (defun factorial(N) (cond.
Lists We’ve seen an array-based list implementation, the ArrayList.

Lists We’ve seen an array-based list implementation, the ArrayList.
1 Chapter 18 Recursion Dale/Weems/Headington. 2 Chapter 18 Topics l Meaning of Recursion l Base Case and General Case in Recursive Function Definitions.

1 Chapter 18 Recursion Dale/Weems/Headington. 2 Chapter 18 Topics l Meaning of Recursion l Base Case and General Case in Recursive Function Definitions.
Lecture 4 Sept 4 Goals: chapter 1 (completion) 1-d array examples Selection sorting Insertion sorting Max subsequence sum Algorithm analysis (Chapter 2)

Lecture 4 Sept 4 Goals: chapter 1 (completion) 1-d array examples Selection sorting Insertion sorting Max subsequence sum Algorithm analysis (Chapter 2)
Revision Using Recursion1 Recursion. Revision Using Recursion2 Recall the Recursion Pattern Recursion: when a method calls itself Classic example--the.

Revision Using Recursion1 Recursion. Revision Using Recursion2 Recall the Recursion Pattern Recursion: when a method calls itself Classic example--the.
Starting Out with C++: Early Objects 5/e © 2006 Pearson Education. All Rights Reserved Starting Out with C++: Early Objects 5 th Edition Chapter 17 Linked.

Starting Out with C++: Early Objects 5/e © 2006 Pearson Education. All Rights Reserved Starting Out with C++: Early Objects 5 th Edition Chapter 17 Linked.
Unit 7 1 Unit 7: Recursion H Recursion is a fundamental programming technique that can provide an elegant solution to a certain kinds of problems H In.

Unit 7 1 Unit 7: Recursion H Recursion is a fundamental programming technique that can provide an elegant solution to a certain kinds of problems H In.
Recursion. Definitions I A recursive definition is a definition in which the thing being defined occurs as part of its own definition Example: A list.

Recursion. Definitions I A recursive definition is a definition in which the thing being defined occurs as part of its own definition Example: A list.
Binary Trees Like a list, a (binary) tree can be empty or non-empty. In class we will explore a state-based implementation, similar to the LRS You are.

Binary Trees Like a list, a (binary) tree can be empty or non-empty. In class we will explore a state-based implementation, similar to the LRS You are.

Similar presentations

Ads by Google