Recursion (Part 2) 1
|
|
|
- Brianna Kelly
- 5 years ago
- Views:
Transcription
1 1 Recursion (Part 2)
2 What Happens During Recursion? a simplified model of what happens during a recursive method invocation is the following: whenever a method is invoked that method runs in a new block of memory when a method recursively invokes itself, a new block of memory is allocated for the newly invoked method to run in consider a slightly modified version of the powerof10 method 2
3 public static double powerof10(int n) { double result; if (n < 0) { result = 1.0 / powerof10(-n); else if (n == 0) { result = 1.0; else { result = 10 * powerof10(n - 1); return result; 3
4 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) 4
5 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result 600 powerof10 method n 3 a stack frame methods occupy space in a region of memory called the call stack information regarding the state of the method is stored in a stack frame the stack frame includes information such as the method parameters, local variables of the method, where the return value of the method should be copied to, where control should flow to after the method completes,... stack memory can be allocated and deallocated very quickly, but this speed is obtained by restricting the total amount of stack memory if you try to solve a large problem using recursion you can exceed the available amount of stack memory which causes your program to crash 5
6 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result 600 powerof10 method n 3 10 * powerof10(2) 6
7 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 result 7
8 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) 8
9 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) result 800 powerof10 method n 1 10 * powerof10(0) 9
10 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) result 800 powerof10 method n 1 10 * powerof10(0) result 950 powerof10 method n 0 10
11 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) result 800 powerof10 method n 1 10 * powerof10(0) 950 powerof10 method n 0 result 1 11
12 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) 800 powerof10 method n 1 result 10 * powerof10 method n 0 result 1 12
13 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 10 * powerof10(1) 800 powerof10 method n 1 result 10 13
14 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 result 10 * powerof10 method n 1 result 10 14
15 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) result 600 powerof10 method n 3 10 * powerof10(2) 750 powerof10 method n 2 result
16 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) 600 powerof10 method n 3 result 10 * powerof10 method n 2 result
17 double x = Recursion.powerOf10(3); x 100 main method powerof10(3) 600 powerof10 method n 3 result
18 double x = Recursion.powerOf10(3); 100 main method x powerof10 method n 3 result
19 double x = Recursion.powerOf10(3); 100 main method x
20 Recursion and Collections consider the problem of searching for an element in a list searching a list for a particular element can be performed by recursively examining the first element of the list if the first element is the element we are searching for then we can return true otherwise, we recursively search the sub-list starting at the next element 20
21 The List method sublist List has a very useful method named sublist: List<E> sublist(int fromindex, int toindex) Returns a view of the portion of this list between the specified fromindex, inclusive, and toindex, exclusive. (If fromindex and toindex are equal, the returned list is empty.) The returned list is backed by this list, so nonstructural changes in the returned list are reflected in this list, and vice-versa. The returned list supports all of the optional list operations supported by this list. 21
22 sublist examples the sub-list excluding the first element of the original list t t.sublist(1, t.size()) 22
23 sublist examples the sub-list excluding the last element of the original list t t.sublist(0, t.size() - 1) 23
24 Recursively Search a List contains("x", ["Z", "Q", "B", "X", "J"]) "X".equals("Z") == false contains("x", ["Q", "B", "X", "J"]) recursive call "X".equals("Q") == false contains("x", ["B", "X", "J"]) recursive call "X".equals("B") == false contains("x", ["X", "J"]) recursive call "X".equals("X") == true done! 24
25 Recursively Search a List base case(s)? recall that a base case occurs when the solution to the problem is known 25
26 public class Week10 { public static <T> boolean contains(t element, List<T> t) { boolean result; if (t.size() == 0) { // base case result = false; else if (t.get(0).equals(element)) { // base case result = true; else { // recursive call result = Day25.contains(element, t.sublist(1, t.size())); return result; 26
27 Recursively Search a List recursive call? to help deduce the recursive call assume that the method does exactly what its API says it does e.g., contains(element, t) returns true if element is in the list t and false otherwise use the assumption to write the recursive call or calls 27
28 public class Week10 { public static <T> boolean contains(t element, List<T> t) { boolean result; if (t.size() == 0) { // base case result = false; else if (t.get(0).equals(element)) { // base case result = true; else { // recursive call result = Week10.contains(element, t.sublist(1, t.size())); return result; 28
29 Recursion and Collections consider the problem of moving the smallest element in a list of integers to the front of the list 29
30 Recursively Move Smallest to Front 30
31 Recursively Move Smallest to Front 31
32 Recursively Move Smallest to Front base case? recall that a base case occurs when the solution to the problem is known 32
33 Recursively Move Smallest to Front public class Week10 { public static void mintofront(list<integer> t) { if (t.size() < 2) { return; Day25.minToFront(t.subList(1, t.size())); int first = t.get(0); int second = t.get(1); if (second < first) { t.set(0, second); t.set(1, first); 33
34 Recursively Move Smallest to Front recursive call? to help deduce the recursive call assume that the method does exactly what its API says it does e.g., movetofront(t) moves the smallest element in t to the front of t use the assumption to write the recursive call or calls 34
35 Recursively Move Smallest to Front public class Week10 { public static void mintofront(list<integer> t) { if (t.size() < 2) { return; Week10.minToFront(t.subList(1, t.size())); int first = t.get(0); int second = t.get(1); if (second < first) { t.set(0, second); t.set(1, first); 35
36 Recursively Move Smallest to Front compare and update? 36
37 Recursively Move Smallest to Front public class Week10 { public static void mintofront(list<integer> t) { if (t.size() < 2) { return; Week10.minToFront(t.subList(1, t.size())); int first = t.get(0); int second = t.get(1); if (second < first) { t.set(0, second); t.set(1, first); 37
38 Sorting the List observe what happens if you repeat the process with the sublist made up of the second through last elements: mintofront
39 Sorting the List observe what happens if you repeat the process with the sublist made up of the third through last elements: mintofront
40 Sorting the List observe what happens if you repeat the process with the sublist made up of the fourth through last elements: mintofront
41 Sorting the List if you keep calling mintofront until you reach a sublist of size two, you will sort the original list: mintofront this is the selection sort algorithm 41
42 Selection Sort public class Sort { // mintofront not shown public static void selectionsort(list<integer> t) { if (t.size() > 1) { Sort.minToFront(t); Sort.selectionSort(t.subList(1, t.size())); 42
43 Jump It board of n squares, n >= 2 start at the first square on left on each move you can move 1 or 2 squares to the right each square you land on has a cost (the value in the square) costs are always positive goal is to reach the rightmost square with the lowest cost 43
44 Jump It solution for example: move 1 square move 2 squares move 2 squares total cost = = 19 can the problem be solved by always moving to the next square with the lowest cost? 44
45 Jump It no, it might be better to move to a square with higher cost because you would have ended up on that square anyway move to next square with lowest cost cost = optimal strategy cost =23 45
46 Jump It sketch a small example of the problem it will help you find the base cases it might help you find the recursive cases 46
47 Jump It base case(s): board.size() == 2 no choice of move (must move 1 square) cost = board.get(0) + board.get(1); board.size() == 3 move 2 squares (avoiding the cost of 1 square) cost = board.get(0) + board.get(2); 47
48 Jump It public static int cost(list<integer> board) { if (board.size() == 2) { return board.get(0) + board.get(1); if (board.size() == 3) { return board.get(0) + board.get(2); List<Integer> afteronestep = board.sublist(1, board.size()); List<Integer> aftertwostep = board.sublist(2, board.size()); int c = board.get(0); return c + Math.min(cost(afterOneStep), cost(aftertwostep)); 48
49 Jump It recursive case(s): compute the cost of moving 1 square compute the cost of moving 2 squares return the smaller of the two costs 49
50 Jump It public static int cost(list<integer> board) { if (board.size() == 2) { return board.get(0) + board.get(1); if (board.size() == 3) { return board.get(0) + board.get(2); List<Integer> afteronestep = board.sublist(1, board.size()); List<Integer> aftertwostep = board.sublist(2, board.size()); int c = board.get(0); return c + Math.min(cost(afterOneStep), cost(aftertwostep)); 50
51 Jump It can you modify the cost method so that it also produces a list of moves? e.g., for the following board the method produces the list [1, 2, 2] consider using the following modified signature public static int cost(list<integer> board, List<Integer> moves) 51
52 the Jump It problem has a couple of nice properties: the rules of the game make it impossible to move to the same square twice the rules of the games make it impossible to try to move off of the board consider the following problem 52
53 given a list of non-negative integer values: starting from the first element try to reach the last element (whose value is always zero) you may move left or right by the number of elements equal to the value of the element that you are currently on you may not move outside the bounds of the list 53
54 Solution
55 Solution
56 Solution
57 Solution
58 Solution
59 Solution
60 Solution
61 Solution
62 Solution
63 Solution
64 Solution
65 Solution
66 Solution
67 Cycles it is possible to find cycles where a move takes you back to a square that you have already visited
68 Cycles using a cycle, it is easy to create a board where no solution exists
69 Cycles on the board below, no matter what you do, you eventually end up on the 1 which leads to a cycle
70 No Solution even without using a cycle, it is easy to create a board where no solution exists
71 unlike Jump It, the board does not get smaller in an obvious way after each move but it does in fact get smaller (otherwise, a recursive solution would never terminate) how does the board get smaller? how do we indicate this? 71
72 Recursion recursive cases: can we move left without falling off of the board? if so, can the board be solved by moving to the left? can we move right without falling off of the board? if so, can the board be solved by moving to the right? 72
73 /** * Is a board is solvable when the current move is at location * index of the board? The method does not modify the board. * index * the current location on the board board * the board true if the board is solvable, false otherwise */ public static boolean issolvable(int index, List<Integer> board) { 73
74 public static boolean issolvable(int index, List<Integer> board) { // base cases here return false; int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 74
75 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 75
76 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 76
77 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 77
78 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 78
79 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; 79
80 public static boolean issolvable(int index, List<Integer> board) { // base cases here ) < 0) { int value = board.get(index); List<Integer> copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winleft = false; if ((index - value) >= 0) { winleft = issolvable(index - value, copy); copy = new ArrayList<Integer>(board); copy.set(index, -1); boolean winright = false; if ((index + value) < board.size()) { winright = issolvable(index + value, copy); return winleft winright; works, but does a lot of unnecessary computation; can you improve on this solution? 80
81 Base Cases base cases: we ve reached the last square board is solvable we ve reached a square whose value is -1 board is not solvable 81
82 public static boolean issolvable(int index, List<Integer> board) { if (board.get(index) < 0) { return false; if (index == board.size() - 1) { return true; // recursive cases go here... 82
83 Towers of Hanoi a problem easily solved using recursion A B C move the stack of n disks from A to C can move one disk at a time from the top of one stack onto another stack cannot move a larger disk onto a smaller disk 83
84 Towers of Hanoi legend says that the world will end when a 64 disk version of the puzzle is solved several appearances in pop culture Doctor Who Rise of the Planet of the Apes Survior: South Pacific 84
85 Towers of Hanoi n = 1 A B C move disk from A to C 85
86 Towers of Hanoi n = 1 A B C 86
87 Towers of Hanoi n = 2 A B C move disk from A to B 87
88 Towers of Hanoi n = 2 A B C move disk from A to C 88
89 Towers of Hanoi n = 2 A B C move disk from B to C 89
90 Towers of Hanoi n = 2 A B C 90
91 Towers of Hanoi n = 3 A B C move disk from A to C 91
92 Towers of Hanoi n = 3 A B C move disk from A to B 92
93 Towers of Hanoi n = 3 A B C move disk from C to B 93
94 Towers of Hanoi n = 3 A B C move disk from A to C 94
95 Towers of Hanoi n = 3 A B C move disk from B to A 95
96 Towers of Hanoi n = 3 A B C move disk from B to C 96
97 Towers of Hanoi n = 3 A B C move disk from A to C 97
98 Towers of Hanoi n = 3 A B C 98
99 Towers of Hanoi n = 4 A B C move (n 1) disks from A to B using C 99
100 Towers of Hanoi n = 4 A B C move disk from A to C 100
101 Towers of Hanoi n = 4 A B C move (n 1) disks from B to C using A 101
102 Towers of Hanoi n = 4 A B C 102
103 base case n = 1 1. move disk from A to C recursive case 1. move (n 1) disks from A to B 2. move 1 disk from A to C 3. move (n 1) disks from B to C 103
104 Towers of Hanoi public static void move(int n, String from, String to, String using) { if(n == 1) { System.out.println("move disk from " + from + " to " + to); else { move(n - 1, from, using, to); move(1, from, to, using); move(n - 1, using, to, from); 104
Recursion and collections
1 Recursion and collections Recursion and Collections consider the problem of searching for an element in a list searching a list for a particular element can be performed by recursively examining the
Recursion. notes Chapter 8
Recursion notes Chapter 8 1 Tower of Hanoi A B C move the stack of n disks from A to C can move one disk at a time from the top of one stack onto another stack cannot move a larger disk onto a smaller
Recursion. notes Chapter 8
Recursion notes Chapter 8 1 Tower of Hanoi A B C move the stack of n disks from A to C can move one disk at a time from the top of one stack onto another stack cannot move a larger disk onto a smaller
Bisection method. we can implement the bisection method using: a loop to iterate until f(c) is close to zero a function handle to the function f
Bisection method we can implement the bisection method using: a loop to iterate until f(c) is close to zero a function handle to the function f 1 function [root] = bisect(f, a, b, tol) %BISECT Root finding
Recursion (Part 3) 1
1 Recursion (Part 3) Computational complexity computational complexity is concerned with describing the amount of resources needed to run an algorithm for our purposes, the resource is time complexity
Recursive Definitions
Recursion Objectives Explain the underlying concepts of recursion Examine recursive methods and unravel their processing steps Explain when recursion should and should not be used Demonstrate the use of
www.thestudycampus.com Recursion Recursion is a process for solving problems by subdividing a larger problem into smaller cases of the problem itself and then solving the smaller, more trivial parts. Recursion
CSC 1351: Quiz 6: Sort and Search
CSC 1351: Quiz 6: Sort and Search Name: 0.1 You want to implement combat within a role playing game on a computer. Specifically, the game rules for damage inflicted by a hit are: In order to figure out
CSE 373: Data Structures and Algorithms
CSE 373: Data Structures and Algorithms Lecture 4: Asymptotic Analysis part 3 Code Style, Recurrence Relations, Formal Big-O & Cousins Instructor: Lilian de Greef Quarter: Summer 2017 Today: Code Style
CmpSci 187: Programming with Data Structures Spring 2015
CmpSci 187: Programming with Data Structures Spring 2015 Lecture #9 John Ridgway February 26, 2015 1 Recursive Definitions, Algorithms, and Programs Recursion in General In mathematics and computer science
Recursion Chapter 17. Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013
Recursion Chapter 17 Instructor: Scott Kristjanson CMPT 125/125 SFU Burnaby, Fall 2013 2 Scope Introduction to Recursion: The concept of recursion Recursive methods Infinite recursion When to use (and
CSE 2123 Recursion. Jeremy Morris
CSE 2123 Recursion Jeremy Morris 1 Past Few Weeks For the past few weeks we have been focusing on data structures Classes & Object-oriented programming Collections Lists, Sets, Maps, etc. Now we turn our
Data Structures And Algorithms
Data Structures And Algorithms Recursion Eng. Anis Nazer First Semester 2016-2017 Recursion Recursion: to define something in terms of itself Example: factorial n!={ 1 n=0 n (n 1)! n>0 Recursion Example:
Recursion. move(64, 1, 2, 3);
Recursion Divide and conquer. One of the uses that we make of recursion of the form called divide and conquer, which can be defined generally as the method of solving a problem by dividing it into two
Recursion. Thinking Recursively. Tracing the Recursive Definition of List. CMPT 126: Lecture 10. Recursion
Recursion CMPT 126: Lecture 10 Recursion Tamara Smyth, tamaras@cs.sfu.ca School of Computing Science, Simon Fraser University October 25, 2007 Recursion is the process of defining something in terms of
CMSC 132: Object-Oriented Programming II. Recursive Algorithms. Department of Computer Science University of Maryland, College Park
CMSC 132: Object-Oriented Programming II Recursive Algorithms Department of Computer Science University of Maryland, College Park Recursion Recursion is a strategy for solving problems A procedure that
1 Dynamic Memory continued: Memory Leaks
CS104: Data Structures and Object-Oriented Design (Fall 2013) September 3, 2013: Dynamic Memory, continued; A Refresher on Recursion Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we continue
Recursion. EECS2030: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG
Recursion EECS2030: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG Recursion: Principle Recursion is useful in expressing solutions to problems that can be recursively defined: Base Cases:
We cover recursion in 150. Why do it again in 151?
Recursion We cover recursion in 150. Why do it again in 151? First, good solutions to problems are often recursive. Here is a quick way to sort a list of objects: split the list in half, recursively sort
Experiment: The Towers of Hanoi. left middle right
Experiment: The Towers of Hanoi 1 Experiment: The Towers of Hanoi 1 Die Türme von Hanoi - So gehts! 2 Die Türme von Hanoi - So gehts! 2 Die Türme von Hanoi - So gehts! 2 Die Türme von Hanoi - So gehts!
Recursion. Let s start by looking at some problems that are nicely solved using recursion. First, let s look at generating The Fibonacci series.
Recursion The programs we have discussed so far have been primarily iterative and procedural. Code calls other methods in a hierarchical manner. For some problems, it is very useful to have the methods
CMPSCI 187: Programming With Data Structures. Lecture #15: Thinking Recursively David Mix Barrington 10 October 2012
CMPSCI 187: Programming With Data Structures Lecture #15: Thinking Recursively David Mix Barrington 10 October 2012 Thinking Recursively Recursive Definitions, Algorithms, and Programs Computing Factorials
Recursion. Dr. Jürgen Eckerle FS Recursive Functions
Recursion Dr. Jürgen Eckerle FS 2008 Recursive Functions Recursion, in mathematics and computer science, is a method of defining functions in which the function being defined is applied within its own
Recursion. Tracing Method Calls via a Stack. Beyond this lecture...
Recursion EECS2030 B: Advanced Object Oriented Programming Fall 2018 CHEN-WEI WANG Recursion: Principle Recursion is useful in expressing solutions to problems that can be recursively defined: Base Cases:
Chapter 10: Recursive Problem Solving
2400 COMPUTER PROGRAMMING FOR INTERNATIONAL ENGINEERS Chapter 0: Recursive Problem Solving Objectives Students should Be able to explain the concept of recursive definition Be able to use recursion in
COMP 202 Recursion. CONTENTS: Recursion. COMP Recursion 1
COMP 202 Recursion CONTENTS: Recursion COMP 202 - Recursion 1 Recursive Thinking A recursive definition is one which uses the word or concept being defined in the definition itself COMP 202 - Recursion
Recursion: Factorial (1) Recursion. Recursion: Principle. Recursion: Factorial (2) Recall the formal definition of calculating the n factorial:
Recursion EECS2030: Advanced Object Oriented Programming Fall 2017 CHEN-WEI WANG Recursion: Factorial (1) Recall the formal definition of calculating the n factorial: 1 if n = 0 n! = n (n 1) (n 2) 3 2
from inheritance onwards but no GUI programming expect to see an inheritance question, recursion questions, data structure questions
Exam information in lab Tue, 18 Apr 2017, 9:00-noon programming part from inheritance onwards but no GUI programming expect to see an inheritance question, recursion questions, data structure questions
Recursive Thinking. Chapter 8: Recursion. Recursive Definitions. Recursion. Java Software Solutions for AP* Computer Science A 2nd Edition
Chapter 8: Recursion Presentation slides for Recursive Thinking Recursion is a programming technique in which a method can call itself to solve a problem Java Software Solutions for AP* Computer Science
Recursion. Chapter 7. Copyright 2012 by Pearson Education, Inc. All rights reserved
Recursion Chapter 7 Contents What Is Recursion? Tracing a Recursive Method Recursive Methods That Return a Value Recursively Processing an Array Recursively Processing a Linked Chain The Time Efficiency
Week - 03 Lecture - 18 Recursion. For the last lecture of this week, we will look at recursive functions. (Refer Slide Time: 00:05)
Programming, Data Structures and Algorithms in Python Prof. Madhavan Mukund Department of Computer Science and Engineering Indian Institute of Technology, Madras Week - 03 Lecture - 18 Recursion For the
Computer Science CS221 Test 2 Name. 1. Give a definition of the following terms, and include a brief example. a) Big Oh
Computer Science CS221 Test 2 Name 1. Give a definition of the following terms, and include a brief example. a) Big Oh b) abstract class c) overriding d) implementing an interface 10/21/1999 Page 1 of
Searching & Sorting in Java Bubble Sort
With the bubble sort, the basic idea is to compare adjacent values and exchange them if they are not in order. Consider the following example which shows the first pass through the algorithm. 1. Compare
CSE Data Structures and Introduction to Algorithms... In Java! Instructor: Fei Wang. Mid-Term Exam. CSE2100 DS & Algorithms 1
CSE 2100 Data Structures and Introduction to Algorithms...! In Java!! Instructor: Fei Wang! Mid-Term Exam CSE2100 DS & Algorithms 1 1. True or False (20%=2%x10)! (1) O(n) is O(n^2) (2) The height h of
12/30/2013 S. NALINI,AP/CSE
12/30/2013 S. NALINI,AP/CSE 1 UNIT I ITERATIVE AND RECURSIVE ALGORITHMS Iterative Algorithms: Measures of Progress and Loop Invariants-Paradigm Shift: Sequence of Actions versus Sequence of Assertions-
Lecture Notes 4 More C++ and recursion CSS 501 Data Structures and Object-Oriented Programming Professor Clark F. Olson
Lecture Notes 4 More C++ and recursion CSS 501 Data Structures and Object-Oriented Programming Professor Clark F. Olson Reading for this lecture: Carrano, Chapter 2 Copy constructor, destructor, operator=
COMP-202. Recursion. COMP Recursion, 2013 Jörg Kienzle and others
COMP-202 Recursion Recursion Recursive Definitions Run-time Stacks Recursive Programming Recursion vs. Iteration Indirect Recursion Lecture Outline 2 Recursive Definitions (1) A recursive definition is
(3-2) Basics of a Stack. Instructor - Andrew S. O Fallon CptS 122 (January 26, 2018) Washington State University
(3-2) Basics of a Stack Instructor - Andrew S. O Fallon CptS 122 (January 26, 2018) Washington State University What is a Stack? A finite sequence of nodes, where only the top node may be accessed Insertions
Basic data types. Building blocks of computation
Basic data types Building blocks of computation Goals By the end of this lesson you will be able to: Understand the commonly used basic data types of C++ including Characters Integers Floating-point values
ArrayList. Introduction. java.util.arraylist
ArrayList Introduction In this article from my free Java 8 course, I will be giving you a basic overview of the Java class java.util.arraylist. I will first explain the meaning of size and capacity of
Programming and Data Structures in C Instruction for students
Programming and Data Structures in C Instruction for students Adam Piotrowski Dariusz Makowski Wojciech Sankowski 11 kwietnia 2016 General rules When writing programs please note that: Program must be
Massachusetts Institute of Technology Department of Mechanical Engineering
Massachusetts Institute of Technology Department of Mechanical Engineering 2.003J/1.053J Dynamics & Control I Fall 2007 Homework 5 Solution Problem 5.1 : Calculating the factorial of non-negative integer
8/5/10 TODAY'S OUTLINE. Recursion COMP 10 EXPLORING COMPUTER SCIENCE. Revisit search and sorting using recursion. Recursion WHAT DOES THIS CODE DO?
8/5/10 TODAY'S OUTLINE Recursion COMP 10 EXPLORING COMPUTER SCIENCE Revisit search and sorting using recursion Binary search Merge sort Lecture 8 Recursion WHAT DOES THIS CODE DO? A function is recursive
Recursively Enumerable Languages, Turing Machines, and Decidability
Recursively Enumerable Languages, Turing Machines, and Decidability 1 Problem Reduction: Basic Concepts and Analogies The concept of problem reduction is simple at a high level. You simply take an algorithm
CISC220 Lab 2: Due Wed, Sep 26 at Midnight (110 pts)
CISC220 Lab 2: Due Wed, Sep 26 at Midnight (110 pts) For this lab you may work with a partner, or you may choose to work alone. If you choose to work with a partner, you are still responsible for the lab
11/2/2017 RECURSION. Chapter 5. Recursive Thinking. Section 5.1
RECURSION Chapter 5 Recursive Thinking Section 5.1 1 Recursive Thinking Recursion is a problem-solving approach that can be used to generate simple solutions to certain kinds of problems that are difficult
COMP-202. Recursion. COMP Recursion, 2011 Jörg Kienzle and others
COMP-202 Recursion Recursion Recursive Definitions Run-time Stacks Recursive Programming Recursion vs. Iteration Indirect Recursion Lecture Outline 2 Recursive Definitions (1) A recursive definition is
Search and Optimization
Search and Optimization Search, Optimization and Game-Playing The goal is to find one or more optimal or sub-optimal solutions in a given search space. We can either be interested in finding any one solution
Stack. 4. In Stack all Operations such as Insertion and Deletion are permitted at only one end. Size of the Stack 6. Maximum Value of Stack Top 5
What is Stack? Stack 1. Stack is LIFO Structure [ Last in First Out ] 2. Stack is Ordered List of Elements of Same Type. 3. Stack is Linear List 4. In Stack all Operations such as Insertion and Deletion
Counting Problems; and Recursion! CSCI 2824, Fall 2012!
Counting Problems; and Recursion! CSCI 2824, Fall 2012!!! Assignments To read this week: Sections 5.5-5.6 (Ensley/Crawley Problem Set 3 has been sent out today. Challenge problem today!!!!! So, to recap
Java Classes and Objects
Table of contents 1 Introduction Case Study - Stack 2 3 Integer String Case Study - Stack Introduction Case Study - Stack Classes Template for creating objects Definition of State (What it knows) Definition
Recursion is a fundamental programming technique that can provide an elegant solution certain kinds of problems. COMP Week 8 & 9 1
Recursion is a fundamental programming technique that can provide an elegant solution certain kinds of problems COMP 202 - Week 8 & 9 1 A recursive definition is one which uses the word or concept being
Kent State University
CS 4/56101 Design and Analysis of Algorithms Kent State University Dept. of Math & Computer Science LECT-3 2 What did we learned in the last class? Flashback: Two versions of Game of Life.. LECT-03, S-3
CMSC 150 LECTURE 7 RECURSION
CMSC 150 INTRODUCTION TO COMPUTING ACKNOWLEDGEMENT: THESE SLIDES ARE ADAPTED FROM SLIDES PROVIDED WITH INTRODUCTION TO PROGRAMMING IN JAVA: AN INTERDISCIPLINARY APPROACH, SEDGEWICK AND WAYNE (PEARSON ADDISON-WESLEY
CSE 143 Section Handout #13 Practice Midterm #5
Practice Midterm #5 1. ArrayList Mystery. Consider the following method: public static void mystery5(arraylist list) { for (int i = 0; i < list.size(); i++) { int element = list.get(i); list.remove(i);
APCS Semester #1 Final Exam Practice Problems
Name: Date: Per: AP Computer Science, Mr. Ferraro APCS Semester #1 Final Exam Practice Problems The problems here are to get you thinking about topics we ve visited thus far in preparation for the semester
Taking Stock. IE170: Algorithms in Systems Engineering: Lecture 5. The Towers of Hanoi. Divide and Conquer
Taking Stock IE170: Algorithms in Systems Engineering: Lecture 5 Jeff Linderoth Department of Industrial and Systems Engineering Lehigh University January 24, 2007 Last Time In-Place, Out-of-Place Count
Divide & Conquer. 2. Conquer the sub-problems by solving them recursively. 1. Divide the problem into number of sub-problems
Divide & Conquer Divide & Conquer The Divide & Conquer approach breaks down the problem into multiple smaller sub-problems, solves the sub-problems recursively, then combines the solutions of the sub-problems
Sorting. Task Description. Selection Sort. Should we worry about speed?
Sorting Should we worry about speed? Task Description We have an array of n values in any order We need to have the array sorted in ascending or descending order of values 2 Selection Sort Select the smallest
Exceptions and Design
Exceptions and Exceptions and Table of contents 1 Error Handling Overview Exceptions RuntimeExceptions 2 Exceptions and Overview Exceptions RuntimeExceptions Exceptions Exceptions and Overview Exceptions
CS205: Scalable Software Systems
CS205: Scalable Software Systems Lecture 3 September 5, 2016 Lecture 3 CS205: Scalable Software Systems September 5, 2016 1 / 19 Table of contents 1 Quick Recap 2 Type of recursive solutions 3 Translating
Fun facts about recursion
Outline examples of recursion principles of recursion review: recursive linked list methods binary search more examples of recursion problem solving using recursion 1 Fun facts about recursion every loop
RECURSIVE FUNCTIONS ON STACK
Debugging with Visual Studio & GDB OCTOBER 31, 2015 BY CSC 342 FALL 2015 Prof. IZIDOR GERTNER 1 Table of contents 1. Objective... pg. 2 2. Overview... pg. 3 3. Microsoft s Visual Studio Debugger... pg.
Q1: /8 Q2: /30 Q3: /30 Q4: /32. Total: /100
ECE 2035(A) Programming for Hardware/Software Systems Fall 2013 Exam Three November 20 th 2013 Name: Q1: /8 Q2: /30 Q3: /30 Q4: /32 Total: /100 1/10 For functional call related questions, let s assume
LIFO : Last In First Out
Introduction Stack is an ordered list in which all insertions and deletions are made at one end, called the top. Stack is a data structure that is particularly useful in applications involving reversing.
Repetition Through Recursion
Fundamentals of Computer Science I (CS151.02 2007S) Repetition Through Recursion Summary: In many algorithms, you want to do things again and again and again. For example, you might want to do something
APCS-AB: Java. Recursion in Java December 12, week14 1
APCS-AB: Java Recursion in Java December 12, 2005 week14 1 Check point Double Linked List - extra project grade Must turn in today MBCS - Chapter 1 Installation Exercises Analysis Questions week14 2 Scheme
Unit-2 Divide and conquer 2016
2 Divide and conquer Overview, Structure of divide-and-conquer algorithms, binary search, quick sort, Strassen multiplication. 13% 05 Divide-and- conquer The Divide and Conquer Paradigm, is a method of
Recursion. Chapter 5
Recursion Chapter 5 Chapter Objectives To understand how to think recursively To learn how to trace a recursive method To learn how to write recursive algorithms and methods for searching arrays To learn
Computer Science 1 Ah
UNIVERSITY OF EDINBURGH course CS0077 COLLEGE OF SCIENCE AND ENGINEERING SCHOOL OF INFORMATICS Computer Science 1 Ah Resit Examination Specimen Solutions Date: Monday 1st September 2003 Time: 09:30 11:00
Big Java, Late Objects, Cay Horstmann, Copyright 2013 John Wiley and Sons, Inc. All rights reserved. Towers of Hanoi
Towers of Hanoi WE5 W o r k e d E x a m p l e 1 3.2 Towers of Hanoi The Towers of Hanoi puzzle has a board with three pegs and a stack of disks of decreasing size, initially on the first peg (see Figure
Solutions to Quiz 2 (April 27, 2018)
MIT 6.031: Software Construction Prof. Rob Miller & Max Goldman revised Tuesday 1 st May, 2018, 11:59 This quiz uses the same abstract data type as Quiz 1. Solutions to Quiz 2 (April 27, 2018) In sciences
CS18000: Problem Solving and Object-Oriented Programming
CS18000: Problem Solving and Object-Oriented Programming Recursion 28 March 2011 Prof. Chris Clifton Recursion Idea: break a problem down into small, similar sub-problems Write a method to solve first
Sorting & Searching (and a Tower)
Sorting & Searching (and a Tower) Sorting Sorting is the process of arranging a list of items into a particular order There must be some value on which the order is based There are many algorithms for
Solving problems by recursion
Solving problems by recursion How can you solve a complex problem? Devise a complex solution Break the complex problem into simpler problems Sometimes, the simpler problem is similar to (but smaller than)
COMP Data Structures
COMP 2140 - Data Structures Shahin Kamali Topic 5 - Sorting University of Manitoba Based on notes by S. Durocher. COMP 2140 - Data Structures 1 / 55 Overview Review: Insertion Sort Merge Sort Quicksort
Solutions to Problem 1 of Homework 3 (10 (+6) Points)
Solutions to Problem 1 of Homework 3 (10 (+6) Points) Sometimes, computing extra information can lead to more efficient divide-and-conquer algorithms. As an example, we will improve on the solution to
DO NOT. UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division. P. N.
CS61B Fall 2011 UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division Test #2 Solutions P. N. Hilfinger 1. [3 points] Consider insertion sort, merge
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division. P. N. Hilfinger
UNIVERSITY OF CALIFORNIA Department of Electrical Engineering and Computer Sciences Computer Science Division CS61B Fall 2011 P. N. Hilfinger Test #2 (with corrections) READ THIS PAGE FIRST. Please do
Announcements. Recursion and why study it. Recursive programming. Recursion basic idea
Announcements Recursion and why study it Tutoring schedule updated Do you find the sessions helpful? Midterm exam 1: Tuesday, April 11, in class Scope: will cover up to recursion Closed book but one sheet,
Recursive Problem Solving
Recursive Problem Solving Objectives Students should: Be able to explain the concept of recursive definition. Be able to use recursion in Java to solve problems. 2 Recursive Problem Solving How to solve
Odds and Ends. Think about doing research Programming grading. Assignment 3 due Tuesday
Odds and Ends Think about doing research Programming grading Correctness, Documentation, Style, Testing Working in pairs/groups; acknowledge accordingly Assignment 3 due Tuesday ...? Questions on HW Review
Pace University. Fundamental Concepts of CS121 1
Pace University Fundamental Concepts of CS121 1 Dr. Lixin Tao http://csis.pace.edu/~lixin Computer Science Department Pace University October 12, 2005 This document complements my tutorial Introduction
CS 2505 Computer Organization I
Instructions: Print your name in the space provided below. This examination is closed book and closed notes, aside from the permitted one-page formula sheet. No calculators or other computing devices may
Advanced Object Oriented Programming EECS2030Z
Advanced Object Oriented Programming EECS2030Z 1 Academic Support Programs: Bethune having trouble with your FSC and LSE courses? consider using the Academic Support Programs at Bethune College PASS free,
recursive algorithms 1
COMP 250 Lecture 11 recursive algorithms 1 Oct. 2, 2017 1 Example 1: Factorial (iterative)! = 1 2 3 1 factorial( n ){ // assume n >= 1 result = 1 for (k = 2; k
Chapter 19 Recursion and Method Redefinition
Exposure Java Multiple Choice Test Chapter 19 Recursion and Method Redefinition DO NOT WRITE ON THIS TEST This test includes program segments, which are not complete programs. Answer such questions with
CMPSCI 187: Programming With Data Structures. Lecture #11: Implementing Stacks With Arrays David Mix Barrington 28 September 2012
CMPSCI 187: Programming With Data Structures Lecture #11: Implementing Stacks With Arrays David Mix Barrington 28 September 2012 Implementing Stacks With Arrays The Idea of the Implementation Data Fields
Programming via Java Recursion
Programming via Java Recursion We saw how to create methods in Chapter 12. Inside their bodies, we can include invocations of other methods. It may not have occurred to you, but you might reasonably wonder:
Linear Data Structure
Linear Data Structure Definition A data structure is said to be linear if its elements form a sequence or a linear list. Examples: Array Linked List Stacks Queues Operations on linear Data Structures Traversal
Arrays. Chapter Arrays What is an Array?
Chapter 8 Arrays 81 Arrays 811 What is an Array? To motivate why we might be interested in using arrays, let us implement an app that creates a collection of doubles We will keep track of the number of
NCS 301 DATA STRUCTURE USING C
NCS 301 DATA STRUCTURE USING C Unit-1 Part-2 Recursion Hammad Mashkoor Lari Assistant Professor Allenhouse Institute of Technology www.ncs301ds.wordpress.com Introduction Recursion is defined as defining
Recursive Algorithms II
Recursive Algorithms II Margaret M. Fleck 23 October 2009 This lecture wraps up our discussion of algorithm analysis (section 4.4 and 7.1 of Rosen). 1 Recap Last lecture, we started talking about mergesort,
Recursion Chapter 4 Self-Reference. Recursive Definitions Inductive Proofs Implementing Recursion
Recursion Chapter 4 Self-Reference Recursive Definitions Inductive Proofs Implementing Recursion Imperative Algorithms Based on a basic abstract machine model - linear execution model - storage - control
CS18000: Programming I
CS18000: Programming I Linked Data Structures 5 April 2010 Prof. Chris Clifton Multiple Items: Beyond Arrays interface Set { boolean contains(e item); /* true iff x s.t. item.equals(x) */ void add(e
Programming Assignment 2
CS 122 Fall, 2004 Programming Assignment 2 New Mexico Tech Department of Computer Science Programming Assignment 2 CS122 Algorithms and Data Structures Due 11:00AM, Wednesday, October 13th, 2004 Objectives:
def F a c t o r i a l ( n ) : i f n == 1 : return 1 else : return n F a c t o r i a l ( n 1) def main ( ) : print ( F a c t o r i a l ( 4 ) )
116 4.5 Recursion One of the most powerful programming techniques involves a function calling itself; this is called recursion. It is not immediately obvious that this is useful; take that on faith for
Lecture 24 Tao Wang 1
Lecture 24 Tao Wang 1 Objectives Introduction of recursion How recursion works How recursion ends Infinite recursion Recursion vs. Iteration Recursion that Returns a Value Edition 2 Introduction If we
CS 211: Recursion. Chris Kauffman. Week 13-1
CS 211: Recursion Chris Kauffman Week 13-1 Front Matter Today P6 Questions Recursion, Stacks Labs 13: Due today 14: Review and evals Incentive to attend lab 14, announce Tue/Wed End Game 4/24 Mon P6, Comparisons
COSC 2P95. Procedural Abstraction. Week 3. Brock University. Brock University (Week 3) Procedural Abstraction 1 / 26
COSC 2P95 Procedural Abstraction Week 3 Brock University Brock University (Week 3) Procedural Abstraction 1 / 26 Procedural Abstraction We ve already discussed how to arrange complex sets of actions (e.g.