Download presentation

Presentation is loading. Please wait.

1
CS 206 Introduction to Computer Science II 10 / 15 / 2008 Instructor: Michael Eckmann

2
Michael Eckmann - Skidmore College - CS 206 - Fall 2008 Today’s Topics Questions? Divide & Conquer –finish solution to the maximum contiguous subsequence problem

3
Recursion 1. have at least one base case that is not recursive 2. recusive case(s) must progress towards the base case 3. trust that your recursive call does what it says it will do (without having to unravel all the recursion in your head.) 4. try not to do redundant work. That is, in different recursive calls, don't recalculate the same info.

4
Divide and Conquer The divide and conquer technique is a way of converting a problem into smaller problems that can be solved individually and then combining the answers to these subproblems in some way to solve the larger problem DIVIDE = solve smaller problems recursively, except the base case(s) CONQUER = compute the solution to the overall problem by using the solutions to the smaller problems solved in the DIVIDE part.

5
Divide and Conquer Divide the sequence in half. Solve each half individually then combine. If we divide the sequence in half and work on the left side, independently from the right side, what do we need to consider when combining?

6
Divide and Conquer Divide the sequence in half. Solve each half individually then combine. If we divide the sequence in half and work on the left side, independently from the right side, there are three cases to consider: –either the maximum contiguous subsequence lives wholly within the left side –or it lives wholly within the right side –or it lives partially in the left and partially in the right if this is the case, then we are guaranteed that the sequence contains the last element of the left side and the first element of the right side. Right?

7
Divide and Conquer Maximum sum of a contiguous subsequence of –seq[left.. right ] Conquer part: –compute the maxLeftBorderSum –compute the maxRightBorderSum –decide which is larger maxLeft or maxRight or maxLeftBorderSum + maxRightBorderSum

8
Divide and Conquer Maximum sum of a contiguous subsequence of –seq[left.. right ] Base case: –if (left == right) return the larger of 0 or seq[left] Let's code this thing.

9
Queues and Stacks A queue is a data structure that has the following characteristics – It is linear – Uses FIFO (first in, first out) processing Queue operations – Enqueue – add an item to the rear of the queue – Dequeue – remove an item from the front of the queue – Empty – returns true if the queue is empty What's significant about a queue is that there are no insert in anywhere or remove from anywhere in the queue. The only place to add something to the queue is the rear, and the only place to remove something from the queue is the front.

10
Queues and Stacks A stack is a data structure that has the following characteristics – It is linear – Uses LIFO (last in, first out) processing Stack operations – Push – add an item to the top of the stack – Pop – remove an item from the top of the stack – Empty – returns true if the stack is empty – Peek – retrieve information about the item on top of the stack without removing it The only allowable ways to put an item into and to get an item from the stack is via push and pop. There are no insert in anywhere or remove from anywhere in the stack. What if there was no peek? Is it redundant --- could a series of the existing operations achieve the same functionality.

11
Queues and Stacks Can anyone think of real world examples that are naturally modeled by queues? Can anyone think of a real world example that is naturally modeled by a stack? Let's see visual representations of a queue and a stack on the board.

12
Queues and Stacks Can anyone think of real world examples that are naturally modeled by queues? – Line of people at grocery store checkout – Line of airplanes waiting for takeoff Can anyone think of a real world example that is naturally modeled by a stack? – Plates at a salad bar A customer takes the top plate (pop) When new plates come out, they are “pushed” to the top of the stack. – Why is this example not a queue?

13
Queues and Stacks Recursive method calls A new call to the method causes it's local data and other state information (where in the method does it return to, etc.) to be pushed onto the stack The method calls finish in reverse order, so when a method call ends, it's local data & state is popped off the stack

14
Queues and Stacks Could we implement a Queue with – a linked list – an array Could we implement a Stack with – a linked list – an array

15
Queues and Stacks Let's implement a stack with an array –what will be our instance variables? Let's implement a queue with an array –what will be our instance variables?

16
Queues and Stacks Applications of stacks –balancing symbols. e.g. curly braces (left { ) and (right }) compilers need to figure out if there are the same number of lefts as there are rights. a stack is handy for this how?

17
Queues and Stacks Applications of stacks –balancing symbols. e.g. curly braces (left { ) and (right }) compilers need to figure out if there are the same number of lefts as there are rights. a stack is handy for this –when see a left curly, push it on the stack –when see a right curly try to pop the stack --- there should be a left curly to pop, otherwise it's an error –when get to the end of the source code, if the stack is empty (and we haven't run into the error above) then the curly braces are balanced.

18
Queues and Stacks Applications of stacks –postfix expressions (reverse Polish notation) infix (what we're used to) is like: 1.07*3.85 + 14.05 + 1.07*8.75 postfix is like: 1.07, 8.75, *, 14.05, +, 1.07, 3.85, *, + infix result requires us to do the multiplies first and then store the intermediate values and then to the 2 adds. postfix operates in the following way: –when see a number, push it –when see an operator, perform it to the two top numbers on the stack and push the result final result in our example is: 27.532

19
Queues and Stacks Applications of stacks –converting from infix (with only +, *, (, ) ) to postfix expressions infix example (assume normal precedence): a + b*c + ( d*e + f ) * g postfix for our example could be: a b c * + d e * f + g * + –let's look at the algorithm to do this using a stack

20
Queues and Stacks converting infix to postfix –when an operand (a, b, c, etc.) is read write it to the output –if we see a ) then we pop the stack and write to output until a left paren is on top of the stack --- at which point we pop the left paren but do not output it. –when a + or * is read, examine the top of the stack – if top is of lower precedence than the one just read, then push the operator –when a + or * is read – if top is of the stack does not have lower precedence than the one just read, then pop the operator and write to output –when a ( is read push it –Let's try this algorithm with our example: infix: a + b*c + ( d*e + f ) * g postfix (expected output): a b c * + d e * f + g * +

Similar presentations

© 2021 SlidePlayer.com Inc.

All rights reserved.

To make this website work, we log user data and share it with processors. To use this website, you must agree to our Privacy Policy, including cookie policy.

Ads by Google