# Course: Programming II - Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 1

Save this PDF as:

Size: px
Start display at page:

Download "Course: Programming II - Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 1"

## Transcription

1 Definition Course: Programming II - Abstract Data Types The ADT Stack The ADT Stack is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit insertions and deletion of items only at one end of the sequence (the top ). The stack is a list structure, sometimes called a last-in-first-out (or LIFO) list. A stack is either empty, or it consists of a sequence of items. Access is limited to the top item on the stack at all times. push pop Item 4 Item 3 Item 2 Item 1 A stack An empty stack The ADT Stack and Recursion Slide Number 1 The term stack is intended to conjure up visions of things encountered in daily life, such as a stack of dishes in a college cafeteria or a stack of books on your desk. In common English usage, stack of and pile of are synonymous. To computer scientists, however, a stack is not just any old pile. A stack has the property that the last item placed on the stack will be the first item to be removed. This property is commonly referred to as last-in-first-out or simply LIFO. The last item placed on the stack is called the top item in the stack. Access procedures for this type of Abstract Data type can therefore only examine the top item. The LIFO property of stack seems inherently unfair. How would you like to be the first person to arrive on the stack for a movie (as opposed to a line for a movie). You would be the last person to be allowed in! Stack are not especially prevalent in everyday life. The property that we usually desire in our daily lives is first-in-first-out (or FIFO). A queue, which we will study in the next lecture, is the Abstract Data Type with the FIFO property. Most people would much prefer to wait in a movie queue (or in a line) than in a movie stack! However, while the LIFO property is not very appropriate for many day-to-day situations, it is very much needed for a large number of problems that arise in computer science. The access procedures for a stack include therefore operations such as examining whether the stack is empty (but not how many items are in the stack), inspecting the top item but not others, placing an item on top of the stack, but at no other position, and removing an item from the top of the stack, but from no other position. Stacks can therefore be seen as special lists with access procedures restricted to just the top element. 1

2 Access Procedures Constructor operations to construct a stack: i. createstack( ) // post: creates an empty Stack ii. push(newitem) // post: adds newitem at the top of the stack. Predicate operations to test Stacks i. isempty( ) // post: determines whether a stack is empty Selector operations to select items of a Stack i. top( ) // post: returns the top item of the stack. It does not change the stack. ii. pop( ) // post: changes the stack by removing the top item. The ADT Stack and Recursion Slide Number 2 This slide provides the headers of the access procedures for the ADT stack, and their respective postconditions, without the exception cases. The names push and pop given here for the operations that add and remove items to the stack are the conventional names for stack operations. So far we have only given the headers of these operations and their (partial) post-conditions. Later we will give examples of implementations. In the next slide we ll see a brief example of a program application that uses this ADT. The full post-conditions for these access procedures that include also the exception cases are given here: top( ) //post: if the stack is not empty, the item on the top is returned //and the stack is left unchanged. Throws exception if the stack is empty. pop( ) //post: if the stack is not empty, the item on the top is removed from the //stack. Throws exception if the stack is empty push(item) //Pre:item is the new item to be added //Post: If insertion is successful, item is on the top of the stack. //Throws StackException if the insertion is not successful 2

3 Using a Stack: an example A method displaystack that displays the items in a stack: The pseudocode: displaystack(astack) // post: displays the items in the stack astack; while (!astack.isempty( ) ) { newchar = astack.top( )); astack.pop( ); Write newchar //end while The ADT Stack and Recursion Slide Number 3 As it is the case for an ADT list, also for stacks once the operations of the ADT stack have been satisfactorily specified, applications can be designed that access and manipulate the ADT s data, by using only the access procedures without regard for the implementation. So far, in fact, we haven t seen or used any particular implementation of stacks. A little example is considered here. Suppose that we want to display the items in a stack. The wall between the implementation of the ADT and the rest of the program prevents the program from knowing how the stack is being stored, i.e. which data structure has been used to implement the stack. The program can, however, still access the items of a stack by means of the access procedures. In this case the method displaystack, can use the operation astack.top( ) to access the top item of a stack, and the operation astack.pop() to change the stack by removing the item on the top. 3

4 Axioms for ADT Stacks The access procedures must satisfy the following axioms, where Item is an item and astack is a given stack: 1. (astack.createstack( ) ).isempty = true 2. (astack.push(item)).isempty() = false 3. (astack.createstack( )).top( ) = error 4. (astack.push(item )).top( ) = Item 5. (astack.createstack( )).pop( ) = error 6. (astack.push(item)).pop( ) = astack A stack is like a list with top( ), pop( ) and push(item) equivalent to get 1 st item, remove 1 st item and add item at the beginning of a list. The ADT Stack and Recursion Slide Number 4 In this slide I have listed the main axioms that the access procedures for an ADT stack have to satisfy. In this case, we have two axioms for each operation. Note that the access procedures for a stack are somewhat equivalent to the access procedures for a list described in the previous lecture. In particular, the top( ) procedure for a stack can be seen as equivalent to the get(1) procedure for a list, which takes the first element of a given list. In the same way, the procedure pop( ) for a stack is equivalent to the procedure remove(1), which removes the first element in a list, whereas the procedure push(item) is equivalent to the procedure add(1,item), which add the given new item to the first position in a list. In the next slides we ll look at the two different types of implementations of a stack, one based on array and the other based on linked lists. The definition of the data structure for a stack in the case of a dynamic implementation, will further illustrate the fact that stacks are essentially lists with specific use of their access procedures. 4

5 Interface StackInterface for the ADT Stack public interface StackInterface{ public boolean isempty(); //Pre: none //Post: Returns true if the stack is empty, otherwise returns false. public void push(object item) throws StackException; //Pre:item is the new item to be added //Post: If insertion is successful, item is on the top of the stack. //Post:Throw StackException if the insertion is not successful public Object top( ) throws StackException; //Pre: none //Post: If stack is not empty, the item on the top is returned. The stack is left unchanged //Post: Throws StackException if the stack is empty. public void pop( ) throws StackException; //Pre: none //Post: If stack is not empty, the item on the top is removed from the stack. //Post: Throws StackException if the stack is empty. The ADT Stack and Recursion Slide Number 5 The interface StackInterface given in this slide provides the main definition of each access procedure for the ADT stack. As in the case of the ADT list, the constructor createstack( ) is not included here as it is normally given as constructor of the particular Java class that implements the Stack. The two main types of implementation (array-based, reference-based) for a stack are classes that implement this interface. This interface provides, therefore, a common specification for the two implementations that we are going to illustrate in the next few slides. An example of the StackException for a stack can be the following: public class StackException extends java.lang.runtimeexception { public StackException(String s){ super(s); // end constructor // end StackException Note that this exception can be avoided by including in the implementation of the access procedure a check to see whether the stack is empty before calling the procedures. In the case of push(item), if the implementation is a static implementation it is also important to consider exceptions caused by the underlying array data structure being full. A private method, called isfull, can be defined for the static implementation of a stack, to check whether the underlying array is full before calling the procedure push(item). In a reference-based implementation, such exception is not necessary since the memory is dynamically allocated and not fixed. 5

6 Data structure class StackArrayBased{ final int MAX_STACK = 50; private Object items[ ]; private int top; ; Course: Programming II - Abstract Data Types Array-based Implementation of a Stack top k k MAX_STACK-1 public class StackArrayBased implements StackInterface{ final int MAX_STACK = 50; private Object items[ ]; private int top; public StackArrayBased( ){ items = new Object[MAX_STACK]; top = 1; // end default constructor; public boolean isempty( ){ return top < 0; // end isempty The ADT Stack and Recursion Slide Number 6 The data structure for a static implementation of a stack uses an array of Objects called items, to represent the items in a stack, and an index value top such that items[top] is the stack s top. When a stack is created it does not include any item at all. In this case the value of the index top is set to 1. This allows us to test in general when a stack has become empty by just checking whether the value of top is a negative integer. The partial implementation of StackArrayBased given in this slide gives the definition of the default constructor and the implementation of the method isempty. In the same way it would be possible to check whether a stack is full by testing whether the value of top has become equal to MAX_STACK-1. The addition of items in the stack, starts from position 0 in the array. Each time a push procedure is called, the value of top is incremented by 1 to point to the next top free cell in the array, and the new item is assigned to this position. Similarl;y, each time a pop( ) procedure is called, the item at the top of the stack should be removed. In this static implementation, this is simply given by decrementing the value of top by 1. The array will still include the value but no longer point to it. An example implementation for the procedure pop( ) is given here: Public void pop( ) throws StackException{ if (!isempty( ) ) { top = top 1; else { throw new StackException( Exception on pop: stack empty ); 6

7 Dynamic Implementation of a Stack 5 13 top class StackReferenceBased{ private Node top; Data structure class Node{ Object item; Node next;. 10 public class StackReferenceBased implements StackInterface{ private Node top; public StackReferenceBased( ){ top = null; // end default constructor; public boolean isempty( ){ return top == null; // end isempty The ADT Stack and Recursion Slide Number 7 Many applications require a reference-based (or dynamic) implementation of a stack so that the stack can grow and shrink dynamically. A diagrammatical representation of a dynamic implementation of a stack is given in the left-hand side of this slide. In this picture, top is a reference to the head of a linked list of items. The implementation uses the same node class used for the linked list in the previous lecture. We give here the implementation of the other access procedures: public void push(object newitem){ top = new Node(newitem, top); // end push public Object top( ) throws Stack Exception { if (! isempty) { return top.getitem( ); else throw new StackException( Stack is empty ); public void pop( ) throws StackException { if (!isempty) { top = top.getnext; 7

8 Recursion Java uses stacks to implement method activations and recursion. General criteria: A representation of each variable declared within a method is created on entry to (or activation of) that method, and destroyed on exit from it. A distinct representation of each variable is created on each re-entry to (or re-activation of) a method. In particular, these criteria enable Java to implement recursive methods, by having as many instances of the declared variables in existence as activations have been made of the method. But only the most recent are accessible to the program. The ADT Stack and Recursion Slide Number 8 In the remainder of this lecture we will have a closer look at how methods are executed in Java and in particular how recursion is handled in Java. The reason why this is given together with the introduction to the ADT Stack, is because the underlying data structure used by Java for handling both method activations and recursive calls of a method is in fact a stack. 8

9 Activation records and execution stack An activation record is a memory block created at each method activation, which includes: top Method s local variables Method s parameters Return address The return address is information about the correct location to return to after the method has been executed. An execution stack stores the collection of activation records: each activation of a method pushes the next activation record on top of the execution stack. The ADT Stack and Recursion Slide Number 9 Java keeps track of the activation of a method (say) A, in the following way. When a method A is activated (whether recursive or not) the computer temporarily stops the execution of the current method (this could well be a main program). Before actually executing the method A, some information is saved that will allow the computer to return to the correct location after the method A is completed. The computer also provides memory for the parameters and local variables that the method A uses. This memory block is called activation record and essentially provides all the important information that the method A needs to work. It also provides information as to where the method should return when it is done with its computation. Once this block is created, the method A is then executed. If the execution of method A should encounter an activation of another method, recursive or otherwise, then the first method s computation is temporarily stopped. This is because the second method must be executed first before the first method can continue. Information is saved that indicates precisely where the first method should resume when the second method is completed. An activation record for the second method is then created and placed on top pf the other existing activation records. The execution then proceeds to the second method.. When this second method is completed, its activation record provides the information as to where the computation should continue. The execution record of this second method is then removed from the top of the collection of existing activation records. All the activation records so created are stored by the program in a stack data structure called execution stack. Each newly created activation record is pushed on top of the execution stack and at the end of execution of a method, its activation record is popped off the execution stack. This mechanism is used for both recursive and non-recursive methods. We will now see, in particular, examples of recursive methods. 9

10 Iteration and Recursion Course: Programming II - Abstract Data Types Many algorithms have alternative iterative and recursive forms: E.g.: The Factorial function: int Factorial(int n){ //pre: n 0. It evaluates n! iteratively int temp=1; if (n = = 0) then return 1 else { for (int i=1; i n; i++) temp = temp*i; return temp; Iterative algorithm int Factorial(int n){ //pre: n 1. It evaluates n! recursively if (n = = 0) then return 1 else return n*factorial(n-1); Recursive algorithm The ADT Stack and Recursion Slide Number 10 Many algorithms can have either an iterative or recursive form. In this slide I have given the example of the algorithm that calculates the factorial of a natural number in both its two forms. Let s see what happens when we run for instance the recursive algorithm for the case of Factorial (3). 10

11 Executing the recursive method Factorial(3) n=3 n=2 A: factorial(2) push A: factorial(1) return =? n=1 return =? A: factorial(0) return address (A) return address return (A) =? n=0 return = 1 return address (A) return address (A) n=1 n=2 A: factorial(0)=1 n=3 A: factorial(1)=1 return =? 1 A: factorial(2)=2 return =? 2 return =? 6 return address (A) (A) return address (A) return address (A) The ADT Stack and Recursion Slide Number 11 pop This is an example run of recursive call. Note this slide is animated. At each creation of a new activation record that is pushed in the execution stack, the current activation record becomes grey, as it is temporarily stopped. At the end, on the last recursive call, the operation is a simple return instruction. The last activation record is then destroyed or popped off the stuck. And the previous activation record becomes activated (in the activation it becomes white again)... until we reach the activation record at the bottom of the stuck and the program is then completed. 11

12 Example2: The Fibonacci function int Fib(int n){ //pre: n>0. It evaluates Fib(n) recursively //post: returns the nth Fibonacci number // of order 2 if (n 2) then return 1; else return (Fib(n-1)+Fib(n-2)); // end Fib int Fib(int n){ //pre: n>0. It evaluates Fib(n) iteratively //post: returns the nth Fibonacci number // of order 2 int i, this, previous, temp; if (n 2) then return 1 else { this = 1; previous = 1; i = n; do { // end Fib while (i > 2); return this; temp = previous+this; previous = this; this=temp; i--; The ADT Stack and Recursion Slide Number 12 This is another example of an algorithm that can be executed either recursively or iteratively. The algorithm is the function that calculates the nth Fibonacci number of order 2. You should already know what the Fibonacci numbers are. These are number that form a special sequence defined as follow: Fib(1) = 1; Fib(2) = 1; Fib(n) = Fib(n-2) + Fib(n-1), for any n>2 The recursive algorithm used here is called binary recursive, because it makes two recursive calls on smaller problems (i.e. smaller numbers). There are other types of recursive algorithms, but we are not going to go into more detail in this part of the course.. If you are interested you can look at the text book on data structures for more information about recursive algorithms. 12

14 An ADT Stack is: Course: Programming II - Abstract Data Types Summary A linear sequence of arbitrary number of items, whose access procedures have a last-in, first-out (LIFO) behaviour. A strong relationship between recursion and stacks exists. Most implementations of recursion maintain an execution stack of activation records. Recursion: Is a technique that solves a problem by solving a smaller problem of the same type. Some recursive solutions are much less efficient than a corresponding iterative solution, due to the overhead of method calls. Iterative solutions can be derived from recursive solutions. The ADT Stack and Recursion Slide Number 14 14

### Course: Programming II - Abstract Data Types. The ADT Queue. (Bobby, Joe, Sue, Ellen) Add(Ellen) Delete( ) The ADT Queues Slide Number 1

Definition Course: Programming II - Abstract Data Types The ADT Queue The ADT Queue is a linear sequence of an arbitrary number of items, together with access procedures. The access procedures permit addition

### Stacks. Linear data structures

Stacks Linear data structures Collection of components that can be arranged as a straight line Data structure grows or shrinks as we add or remove objects ADTs provide an abstract layer for various operations

### Queues Outline and Required Reading: Queues ( 4.2 except 4.2.4) COSC 2011, Fall 2003, Section A Instructor: N. Vlajic

Queues Outline and Required Reading: Queues ( 4. except 4..4) COSC, Fall 3, Section A Instructor: N. Vlajic Queue ADT Queue linear data structure organized according to first-in/first-out (FIFO) principle!

### What Is Recursion? Recursion. Binary search example postponed to end of lecture

Recursion Binary search example postponed to end of lecture What Is Recursion? Recursive call A method call in which the method being called is the same as the one making the call Direct recursion Recursion

### csci 210: Data Structures Stacks and Queues

csci 210: Data Structures Stacks and Queues Summary Topics stacks and queues as abstract data types implementations arrays linked lists analysis and comparison application: searching with stacks and queues

### The Tower of Hanoi. Recursion Solution. Recursive Function. Time Complexity. Recursive Thinking. Why Recursion? n! = n* (n-1)!

The Tower of Hanoi Recursion Solution recursion recursion recursion Recursive Thinking: ignore everything but the bottom disk. 1 2 Recursive Function Time Complexity Hanoi (n, src, dest, temp): If (n >

### Stacks. The stack ADT Stack Implementation. Stack Examples. using arrays using generic linked lists using List ADT. EECS 268 Programming II 1

Stacks The stack ADT Stack Implementation using arrays using generic linked lists using List ADT Stack Examples 1 Stacks and Queues Linear data structures each item has specific first, next, and previous

### What is a Stack? Stacks and Queues. Stack Abstract Data Type. Java Interface for Stack ADT. Array-based Implementation

Stacks and Queues What is a Stack? Stores a set of elements in a particular order Accessed in Last-In In-First-Out (LIFO) fashion Real life examples: Pile of books PEZ dispenser Cup trays in cafeteria

### This lecture. Abstract data types Stacks Queues. ADTs, Stacks, Queues 1. 2004 Goodrich, Tamassia

This lecture Abstract data types Stacks Queues ADTs, Stacks, Queues 1 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure An ADT specifies: Data stored Operations

### STACKS,QUEUES, AND LINKED LISTS

STACKS,QUEUES, AND LINKED LISTS Stacks Queues Linked Lists Double-Ended Queues Case Study: A Stock Analysis Applet 1 Stacks Astack is a container of objects that are inserted and removed according to the

### Definition. E.g. : Attempting to represent a transport link data with a tree structure:

The ADT Graph Recall the ADT binary tree: a tree structure used mainly to represent 1 to 2 relations, i.e. each item has at most two immediate successors. Limitations of tree structures: an item in a tree

### St S a t ck a ck nd Qu Q eue 1

Stack and Queue 1 Stack Data structure with Last-In First-Out (LIFO) behavior In Out C B A B C 2 Typical Operations Pop on Stack Push isempty: determines if the stack has no elements isfull: determines

### DATA STRUCTURE - STACK

DATA STRUCTURE - STACK http://www.tutorialspoint.com/data_structures_algorithms/stack_algorithm.htm Copyright tutorialspoint.com A stack is an abstract data type ADT, commonly used in most programming

### Stacks. Stacks (and Queues) Stacks. q Stack: what is it? q ADT. q Applications. q Implementation(s) CSCU9A3 1

Stacks (and Queues) 1 Stacks Stack: what is it? ADT Applications Implementation(s) 2 CSCU9A3 1 Stacks and ueues A stack is a very important data structure in computing science. A stack is a seuence of

### Module 2 Stacks and Queues: Abstract Data Types

Module 2 Stacks and Queues: Abstract Data Types A stack is one of the most important and useful non-primitive linear data structure in computer science. It is an ordered collection of items into which

### CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team

CS104: Data Structures and Object-Oriented Design (Fall 2013) October 24, 2013: Priority Queues Scribes: CS 104 Teaching Team Lecture Summary In this lecture, we learned about the ADT Priority Queue. A

### MAX = 5 Current = 0 'This will declare an array with 5 elements. Inserting a Value onto the Stack (Push) -----------------------------------------

=============================================================================================================================== DATA STRUCTURE PSEUDO-CODE EXAMPLES (c) Mubashir N. Mir - www.mubashirnabi.com

### Data Structures. Topic #4

Topic #4 Today s Agenda Stack and Queue ADTs What are they Like Ordered Lists, are position oriented Use of Data Structures for Stacks and Queues arrays (statically & dynamically allocated) linear linked

### Analysis of a Search Algorithm

CSE 326 Lecture 4: Lists and Stacks 1. Agfgd 2. Dgsdsfd 3. Hdffdsf 4. Sdfgsfdg 5. Tefsdgass We will review: Analysis: Searching a sorted array (from last time) List ADT: Insert, Delete, Find, First, Kth,

### Data Structures Using C++ 2E. Chapter 5 Linked Lists

Data Structures Using C++ 2E Chapter 5 Linked Lists Doubly Linked Lists Traversed in either direction Typical operations Initialize the list Destroy the list Determine if list empty Search list for a given

### Chapter 3: Restricted Structures Page 1

Chapter 3: Restricted Structures Page 1 1 2 3 4 5 6 7 8 9 10 Restricted Structures Chapter 3 Overview Of Restricted Structures The two most commonly used restricted structures are Stack and Queue Both

### Recursion. Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive.

Recursion Definition: o A procedure or function that calls itself, directly or indirectly, is said to be recursive. Why recursion? o For many problems, the recursion solution is more natural than the alternative

### The ADT Binary Search Tree

The ADT Binary Search Tree The Binary Search Tree is a particular type of binary tree that enables easy searching for specific items. Definition The ADT Binary Search Tree is a binary tree which has an

### 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++

Answer the following 1) The postfix expression for the infix expression A+B*(C+D)/F+D*E is ABCD+*F/DE*++ 2) Which data structure is needed to convert infix notations to postfix notations? Stack 3) The

### C++ How to Program, 8/e by Pearson Education, Inc. All Rights Reserved.

C++ How to Program, 8/e 1992-2012 by Pearson Education, Inc. 1992-2012 by Pearson Education, Inc. 1992-2012 by Pearson Education, Inc. We ve studied fixed-size data structures such as one-dimensional arrays

### A binary search tree or BST is a binary tree that is either empty or in which the data element of each node has a key, and:

Binary Search Trees 1 The general binary tree shown in the previous chapter is not terribly useful in practice. The chief use of binary trees is for providing rapid access to data (indexing, if you will)

### UNIVERSITI MALAYSIA SARAWAK KOTA SAMARAHAN SARAWAK PSD2023 ALGORITHM & DATA STRUCTURE

STUDENT IDENTIFICATION NO UNIVERSITI MALAYSIA SARAWAK 94300 KOTA SAMARAHAN SARAWAK FAKULTI SAINS KOMPUTER & TEKNOLOGI MAKLUMAT (Faculty of Computer Science & Information Technology) Diploma in Multimedia

### Outline. Computer Science 331. Stack ADT. Definition of a Stack ADT. Stacks. Parenthesis Matching. Mike Jacobson

Outline Computer Science 1 Stacks Mike Jacobson Department of Computer Science University of Calgary Lecture #12 1 2 Applications Array-Based Linked List-Based 4 Additional Information Mike Jacobson (University

### QUEUES. Primitive Queue operations. enqueue (q, x): inserts item x at the rear of the queue q

QUEUES A queue is simply a waiting line that grows by adding elements to its end and shrinks by removing elements from the. Compared to stack, it reflects the more commonly used maxim in real-world, namely,

### Sequential Data Structures

Sequential Data Structures In this lecture we introduce the basic data structures for storing sequences of objects. These data structures are based on arrays and linked lists, which you met in first year

### Chapter 13. Pointers and Linked Lists

Chapter 13 Pointers and Linked Lists Overview 13.1 Nodes and Linked Lists 13.2 Stacks and Queues Slide 13-2 13.1 Nodes and Linked Lists Nodes and Linked Lists n A linked list is a list that can grow and

### Class Overview. CSE 326: Data Structures. Goals. Goals. Data Structures. Goals. Introduction

Class Overview CSE 326: Data Structures Introduction Introduction to many of the basic data structures used in computer software Understand the data structures Analyze the algorithms that use them Know

### 10CS35: Data Structures Using C

CS35: Data Structures Using C QUESTION BANK REVIEW OF STRUCTURES AND POINTERS, INTRODUCTION TO SPECIAL FEATURES OF C OBJECTIVE: Learn : Usage of structures, unions - a conventional tool for handling a

### Chapter 7: Queues and Deques

Chapter 7: Queues and Deques After the stack, the next simplest data abstraction is the queue. As with the stack, the queue can be visualized with many examples you are already familiar with from everyday

### Linked Lists Linked Lists, Queues, and Stacks

Linked Lists Linked Lists, Queues, and Stacks CSE 10: Introduction to C Programming Fall 200 Dynamic data structure Size is not fixed at compile time Each element of a linked list: holds a value points

### 16. Recursion. COMP 110 Prasun Dewan 1. Developing a Recursive Solution

16. Recursion COMP 110 Prasun Dewan 1 Loops are one mechanism for making a program execute a statement a variable number of times. Recursion offers an alternative mechanism, considered by many to be more

### Lecture 4. The Java Collections Framework

Lecture 4. The Java s Framework Chapters 6.3-6.4-1 - Outline Introduction to the Java s Framework Iterators Interfaces Classes Classes - 2 - The Java s Framework We will consider the Java s Framework as

### 1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D.

1. The memory address of the first element of an array is called A. floor address B. foundation addressc. first address D. base address 2. The memory address of fifth element of an array can be calculated

### Announcements. FINAL EXAM Monday May 21, 1:30pm Review Session. Wednesday May 16, 7-9pm

Announcements FINAL EXAM Monday May 21, 1:30pm Review Session Wednesday May 16, 7-9pm 1 Recitation 12 Root Finding, Sorting, Stacks, Queues 2 Outline Linked Lists Sorting Queues 3 Object References Let

### Common Data Structures

Data Structures 1 Common Data Structures Arrays (single and multiple dimensional) Linked Lists Stacks Queues Trees Graphs You should already be familiar with arrays, so they will not be discussed. Trees

### Stacks & Queues. Data structures and Algorithms

Stacks & Queues Data structures and Algorithms Acknowledgement: These slides are adapted from slides provided with Data Structures and Algorithms in C++ Goodrich, Tamassia and Mount (Wiley, 2004) Outline

### C++ Introduction to class and data abstraction

C++ Introduction to class and data abstraction 1 Data abstraction A data abstraction is a simplified view of an object by specifying what can be done with the object while hiding unnecessary details In

### Data Structures and Algorithms Stacks and Queues

Data Structures and Algorithms Stacks and Queues Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/23 6-0: Stacks and

### CS 2412 Data Structures. Chapter 2 Stacks and recursion

CS 2412 Data Structures Chapter 2 Stacks and recursion 1 2.1 Stacks A stack is a data structure in which all insertions and deletions of entries are made at one end, called top of the stack. Examples:

### Linked Lists, Stacks, Queues, Deques. It s time for a chainge!

Linked Lists, Stacks, Queues, Deques It s time for a chainge! Learning Goals After this unit, you should be able to... Differentiate an abstraction from an implementation. Define and give examples of problems

### 7.1 Our Current Model

Chapter 7 The Stack In this chapter we examine what is arguably the most important abstract data type in computer science, the stack. We will see that the stack ADT and its implementation are very simple.

### The first step in solving a problem recursively is to formulate a recursive definition of the problem.

Chapter 8 Recursion The subject of this chapter is recursion, an implicit application of the stack ADT. A recursive method is a method that carries out its task by making a call(s) to itself. Each recursive

### Course: Programming II - Abstract Data Types. The ADT Binary Tree

The ADT Binary Tree The Binary Tree is a more general ADT than the linear list: it allows one item to have two immediate successors. Definition The ADT Binary Tree is a finite set of nodes which is either

### Boolean Expressions, Conditions, Loops, and Enumerations. Precedence Rules (from highest to lowest priority)

Boolean Expressions, Conditions, Loops, and Enumerations Relational Operators == // true if two values are equivalent!= // true if two values are not equivalent < // true if left value is less than the

### Chapter 4: Linked Lists

Chapter 4: Linked Lists Data Abstraction & Problem Solving with C++ Fifth Edition by Frank M. Carrano Preliminaries Options for implementing an ADT List Array has a fixed size Data must be shifted during

### Introduction to Data Structures

Introduction to Data Structures Albert Gural October 28, 2011 1 Introduction When trying to convert from an algorithm to the actual code, one important aspect to consider is how to store and manipulate

### Outline. The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack. Stacks 2

Stacks Outline The Stack ADT Applications of Stacks Array-based implementation Growable array-based stack Stacks 2 Abstract Data Types (ADTs) An abstract data type (ADT) is an abstraction of a data structure

### Chapter 20 Recursion. Liang, Introduction to Java Programming, Ninth Edition, (c) 2013 Pearson Education, Inc. All rights reserved.

Chapter 20 Recursion 1 Motivations Suppose you want to find all the files under a directory that contains a particular word. How do you solve this problem? There are several ways to solve this problem.

### Introduction to Stacks

Introduction to Stacks What is a Stack Stack implementation using array. Stack implementation using linked list. Applications of Stack. What is a Stack? Stack is a data structure in which data is added

### CmpSci 187: Programming with Data Structures Spring 2015

CmpSci 187: Programming with Data Structures Spring 2015 Lecture #12 John Ridgway March 10, 2015 1 Implementations of Queues 1.1 Linked Queues A Linked Queue Implementing a queue with a linked list is

### Algorithms and Data Structures

Algorithms and Data Structures Part 2: Data Structures PD Dr. rer. nat. habil. Ralf-Peter Mundani Computation in Engineering (CiE) Summer Term 2016 Overview general linked lists stacks queues trees 2 2

Universidad Carlos III de Madrid Algorithms and Data Structures (ADS) Bachelor in Informatics Engineering Computer Science Department Lists, Stacks and Queues. Authors: Isabel Segura Bedmar April 2011

### Algorithms and recursion

Read: Chapter 13 from textbook Algorithms and recursion What programs implement is recipes for solving problems. These recipes are called algorithms. We have already seen (in the practice problems from

### Queues and Stacks. Atul Prakash Downey: Chapter 15 and 16

Queues and Stacks Atul Prakash Downey: Chapter 15 and 16 Queues Queues occur in real life a lot. Queues at checkout Queues in banks In software systems: Queue of requests at a web servers Properties of

### Algorithms and Data Structures

Basic Data Structures Page 1 BFH-TI: Softwareschule Schweiz Basic Data Structures Dr. CAS SD01 Basic Data Structures Page 2 Outline Data Structures and Abstract Data Types Linear Data Structures Implementing

### Lecture 4. The Java Collections Framework

Lecture 4. The Java s Framework Chapters 6.3-6.4-1 - The Java s Framework We will consider the Java s Framework as a good example of how apply the principles of objectoriented software engineering (see

### Programming with Recursion. What Is Recursion?

Chapter 7 Programming with Recursion Fall 2013 Yanjun Li CS2200 1 What Is Recursion? How is recursion like a set of Russian dolls? Fall 2013 Yanjun Li CS2200 2 What Is Recursion? Recursive call A method

### PES Institute of Technology-BSC QUESTION BANK

PES Institute of Technology-BSC Faculty: Mrs. R.Bharathi CS35: Data Structures Using C QUESTION BANK UNIT I -BASIC CONCEPTS 1. What is an ADT? Briefly explain the categories that classify the functions

### Data Structures, Sample Test Questions for the Material after Test 2, with Answers

Data Structures, Sample Test Questions for the Material after Test 2, with Answers 1. Recall the public interfaces of classes List and ListIterator: typedef int ListItemType; class ListIterator{ public:

### Data Structures and Data Manipulation

Data Structures and Data Manipulation What the Specification Says: Explain how static data structures may be used to implement dynamic data structures; Describe algorithms for the insertion, retrieval

### CE204 Data Structures and Algorithms Part 3

CE204 Data Structures and Algorithms Part 3 23/01/2016 CE204 Part 3 1 Trees The ADTs encountered so far have been linear; list and array implementations have been adequate. We now consider a nonlinear

### Programming with Data Structures

Programming with Data Structures CMPSCI 187 Spring 2016 Please find a seat Try to sit close to the center (the room will be pretty full!) Turn off or silence your mobile phone Turn off your other internet-enabled

### Arrays, Singly-Linked Lists, Stacks, Queues, Doubly-Linked Lists, Deques

Arrays, Singly-Linked Lists, Stacks, Queues, Doubly-Linked Lists, Deques Slide Set 5: Learning Goals Differentiate an abstraction from an implementation. Define and give examples of problems that can be

### CompSci-61B, Data Structures Final Exam

Your Name: CompSci-61B, Data Structures Final Exam Your 8-digit Student ID: Your CS61B Class Account Login: This is a final test for mastery of the material covered in our labs, lectures, and readings.

### Chapter 8: Bags and Sets

Chapter 8: Bags and Sets In the stack and the queue abstractions, the order that elements are placed into the container is important, because the order elements are removed is related to the order in which

### Data Structures Using C++ 2E. Chapter 7 Stacks

Data Structures Using C++ 2E Chapter 7 Stacks Stacks Data structure Elements added, removed from one end only Last In First Out (LIFO) FIGURE 7-1 Various examples of stacks Data Structures Using C++ 2E

### Data Structures and Algorithms

Data Structures and Algorithms CS245-2016S-04 Stacks and Queues David Galles Department of Computer Science University of San Francisco 04-0: Abstract Data Types An Abstract Data Type is a definition of

### Glossary of Object Oriented Terms

Appendix E Glossary of Object Oriented Terms abstract class: A class primarily intended to define an instance, but can not be instantiated without additional methods. abstract data type: An abstraction

### Binary Heap Algorithms

CS Data Structures and Algorithms Lecture Slides Wednesday, April 5, 2009 Glenn G. Chappell Department of Computer Science University of Alaska Fairbanks CHAPPELLG@member.ams.org 2005 2009 Glenn G. Chappell

### 12 Abstract Data Types

12 Abstract Data Types 12.1 Source: Foundations of Computer Science Cengage Learning Objectives After studying this chapter, the student should be able to: Define the concept of an abstract data type (ADT).

### CSCI 123 INTRODUCTION TO PROGRAMMING CONCEPTS IN C++

Brad Rippe CSCI 123 INTRODUCTION TO PROGRAMMING CONCEPTS IN C++ Recursion Recursion CHAPTER 14 Overview 14.1 Recursive Functions for Tasks 14.2 Recursive Functions for Values 14.3 Thinking Recursively

### Abstract Data Type. EECS 281: Data Structures and Algorithms. The Foundation: Data Structures and Abstract Data Types

EECS 281: Data Structures and Algorithms The Foundation: Data Structures and Abstract Data Types Computer science is the science of abstraction. Abstract Data Type Abstraction of a data structure on that

### Basic Data Structures and Algorithms

Tutorial 3 Basic Data Structures and Algorithms THINGS TO LOOK FOR 3.0 INTRODUCTION 3.1 Array Based Containers Definition and uses of containers. Array and list based containers. Designing and building

### LINKED DATA STRUCTURES

LINKED DATA STRUCTURES 1 Linked Lists A linked list is a structure in which objects refer to the same kind of object, and where: the objects, called nodes, are linked in a linear sequence. we keep a reference

### Data Structures and Algorithms C++ Implementation

BK TP.HCM Ho Chi Minh City University of Technology Faculty of Computer Science and Engineering BK TP.HCM Data Structures and Algorithms C++ Implementation Huỳnh Tấn Đạt Email: htdat@cse.hcmut.edu.vn Home

### Recursion vs. Iteration Eliminating Recursion

Recursion vs. Iteration Eliminating Recursion continued CS 311 Data Structures and Algorithms Lecture Slides Monday, February 16, 2009 Glenn G. Chappell Department of Computer Science University of Alaska

### Quiz 4 Solutions EECS 211: FUNDAMENTALS OF COMPUTER PROGRAMMING II. 1 Q u i z 4 S o l u t i o n s

Quiz 4 Solutions Q1: What value does function mystery return when called with a value of 4? int mystery ( int number ) { if ( number

### 1.00 Lecture 35. Data Structures: Introduction Stacks, Queues. Reading for next time: Big Java: 15.1-15.3. Data Structures

1.00 Lecture 35 Data Structures: Introduction Stacks, Queues Reading for next time: Big Java: 15.1-15.3 Data Structures Set of reusable classes used in algorithms, simulations, operating systems, applications

### Pseudo code Tutorial and Exercises Teacher s Version

Pseudo code Tutorial and Exercises Teacher s Version Pseudo-code is an informal way to express the design of a computer program or an algorithm in 1.45. The aim is to get the idea quickly and also easy

### Computer Science 211 Data Structures Mount Holyoke College Fall Topic Notes: Recursion and Mathematical Induction

Computer Science 11 Data Structures Mount Holyoke College Fall 009 Topic Notes: Recursion and Mathematical Induction Recursion An important tool when trying to solve a problem is the ability to break the

### Repetition and Loops. Additional Python constructs that allow us to effect the (1) order and (2) number of times that program statements are executed.

New Topic Repetition and Loops Additional Python constructs that allow us to effect the (1) order and (2) number of times that program statements are executed. These constructs are the 1. while loop and

### University of Illinois at Urbana-Champaign Department of Computer Science. First Examination

University of Illinois at Urbana-Champaign Department of Computer Science First Examination CS 225 Data Structures and Software Principles Fall 2007 7p-9p, Thursday, October 4 Name: NetID: Lab Section

### NIKLAUS WIRTH Algorithms + Data Structures = Programs

java04.frm Page 171 Saturday, August 26, 2000 6:03 PM 171 Linked Lists The simplest way to interrelate or link a set of elements is to line them up in a single list... For, in this case, only a single

### Recursive void Methods. Chapter 11. A recursive method is a method that includes a call to itself Recursion is based on the general problem.

Chapter 11 Recursion Recursive void Methods A recursive method is a method that includes a call to itself Recursion is based on the general problem solving technique of breaking down a task into subtasks

### DATA STRUCTURE - QUEUE

DATA STRUCTURE - QUEUE http://www.tutorialspoint.com/data_structures_algorithms/dsa_queue.htm Copyright tutorialspoint.com Queue is an abstract data structure, somewhat similar to stack. In contrast to

### Last not not Last Last Next! Next! Line Line Forms Forms Here Here Last In, First Out Last In, First Out not Last Next! Call stack: Worst line ever!

ECE 551 C++ Programming, Data structures, and Algorithms Abstract Data Type: Stack Last In First Out (LIFO) 1 2 2 1 4 3 1 3 4 Stacks in Programming Worst line ever! 5 3 1 5 Stacks are not useful for waiting

### Priority Queues. Client, Implementation, Interface. Priority Queues. Abstract Data Types

Client, Implementation, Interface Priority Queues Priority Queue ADT Binary heaps Heapsort Reference: Chapter 6, Algorithms in Java, 3 rd Edition, Robert Sedgewick. Separate interface and implementation

### Data Structure with C

Subject: Data Structure with C Topic : Tree Tree A tree is a set of nodes that either:is empty or has a designated node, called the root, from which hierarchically descend zero or more subtrees, which

### Data Structures Using Java

Data Structures Using Java D. S. Malik P. S. Nair THOMSON COURSE TECHNOLOGY Australia Canada Mexico Singapore Spain United Kingdom United States TABLE OF Contents PREFACE XXV 1.Software Engineering Principles

### Data Types. Abstract Data Types. ADTs as Design Tool. Abstract Data Types. Integer ADT. Principle of Abstraction

bstract ata Types Previous lectures: algorithms and their efficiency analysis. oming lectures: data structures In this lecture: bstract data types Ts as a design tool Examples: integer T, List T ata Types

### UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming

UIL Computer Science for Dummies by Jake Warren and works from Mr. Fleming 1 2 Foreword First of all, this book isn t really for dummies. I wrote it for myself and other kids who are on the team. Everything

### Summary of last lecture. Basics of programming II. (8th lect) C++ iterators, special data structures. Revision of List template

Summary of last lecture Basics of programming II. (8th lect) C++ iterators, special data structures Péter Dóbé BME IIT Budapesti Mőszaki Egyetem C++ programming language BME-IIT Sz.I...7

### Ordered Lists and Binary Trees

Data Structures and Algorithms Ordered Lists and Binary Trees Chris Brooks Department of Computer Science University of San Francisco Department of Computer Science University of San Francisco p.1/62 6-0: