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

Save this PDF as:

Size: px
Start display at page:

## Transcription

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 only at the back of the queue and deletion of items only at the front of the queue. The queue is a list structure sometimes called a first-in-first-out (or FIFO) list. A queue is either empty, or it consists of a sequence of items. Manipulations or accesses to these items are only permitted at the two ends of the queue. front (Bobby, Joe, Sue) Add(Ellen) Delete( ) back (Bobby, Joe, Sue, Ellen) (Joe, Sue) The ADT Queues Slide Number 1 A queue is like a line of people. The first person to join a line is the first person served and is thus the first to leave the line. Queues are appropriate for many real-world situations. For instance, we often wait in a queue to buy a movie ticket, or to use an automatic ticket machine. The person at the front of the queue is served, while new people join the queue at its back. A queue is then a form of list. The difference from the previous forms of list is in its access procedures. Whereas a stack can be seen as a list with only one end, because all the operations are performed at the top of the stack, the queue can be seen, in contrast, as a list with two ends, the front and the back. Queues have the main property of allowing new items to be added only at the back of the list, and the item first inserted in the list (i.e. the item at the front of the list) is the first to be removed. This behaviour is commonly referred to as first-in-first-out or simply FIFO. So the first item in a queue is the front item, whereas the last item in a queue is the back item. The access procedures for a queue include operations such as examining whether the queue is empty, inspecting the item at the front of the queue but not others, placing an item at the back of the queue, but at no other position, and removing an item from the front of the queue, but from no other position. The next slides will describe these procedures in more detail. A typical application of queues in computer science is: resource allocation by operating systems on multi-user machines. For instance, if you share a printer with other users, a request to print enters a queue to wait its turn. 1

2 Access Procedures Constructor operations to construct a queue: i. createqueue( ) // post: creates an empty queue ii. enqueue(newitem) // [equivalent to add(newitem)] // post: adds newitem at the end of the queue. Predicate operations to test Queues i. isempty( ) // post: determines whether a queue is empty Selector operations to select items of a queue i. front( ) // post: returns the item at the front of the queue. It does not change the //queue. ii. dequeue( ) // post: retrieves and removes the item at the front of the queue. The ADT Queues Slide Number 2 This slide provides the list of the main access procedures and operations for the ADT queue. The operation enqueue, also called add, is a short form of entering the queue : it adds a new item to the end of a queue. The operation for retrieving and removing an item from a queue is called a dequeue operation, which means deleting from the queue. The operation front retrieves the item at the front of a queue leaving the queue unchanged. Note that so far we have defined the access procedure operation delete for an ADT as just a procedure that deletes an item from the ADT. In this case the procedure dequeue also returns the element that is deleted from the queue. We could have still defined this operation as simply deleting the first element from a queue, and use it in combination with front() in order to get the next element in the queue. We have adopted here this definition, because this is the one most commonly used in text books. So far we have only given the definition of these operations in terms of their partial postconditions. Note that these post-conditions do not include the exception cases. We ll show later which of these access procedures require exceptions. 2

3 Using a Queue: a simple example A method ReadString that reads a string of characters from a single line of input into a queue: The pseudocode: ReadString( ) // post: reads a string of characters from a // single line of input into a queue; queue.createqueue( ); while (not end of line) { Read a new character ch; queue.enqueue(ch); } //end while The ADT Queues Slide Number 3 This slide presents a simple application of the ADT queue. The example uses operations of the ADT queue independently from their implementations. When we enter characters at a keyboard, the system must retain them in the order in which you typed them. For this purpose an ADT queue is more appropriate than an ADT stack. A pseudocode solution to this problem is given in this slide. Once the characters are in a queue, the system can process them as necessary. Note that this example is just in pseudocode. In a real Java implementation, to create a queue we would need to use the constructor of the class that implements the queue. Let s see in the next few slides how we can declare such a class in both a dynamic and static implementation of queues. 3

4 Axioms for ADT Queues The access procedures must satisfy the following axioms, where Item is an item and aqueue is a given queue: 1. (aqueue.createqueue( ) ).isempty = true 2. (aqueue.enqueue(item)).isempty() = false 3. (aqueue.createqueue( )).front( ) = error 4. (aqueue.enqueue(item)).front( ) = Item 5. (aqueue.createqueue( )).dequeue( ) = error 6. pre: aqueue.isempty( )=true: 7. (aqueue.enqueue(item)).dequeue( )=(aqueue.dequeue()).enqueue(item) A queue is like a list with front( ), dequeue( ) and enqueue(item) equivalent to get 1 st item, get and remove 1 st item, and add item at the end of a list respectively. The ADT Queues Slide Number 4 In this slide I have listed the main axioms that the access procedures for an ADT queue have to satisfy. In this case, we have two axioms for each operation. Note that the access procedures for a queue are somewhat equivalent to the access procedures for a list. In particular, the front( ) procedure for a queue 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 dequeue( ) for a queue is similar to the procedure remove(1), which removes the first element in a list, (but in addition it returns the value of the removed item), and the procedure enqueue(item) is equivalent to the procedure add(list.size( ) +1, item), where list is the specific data structure used to implement the queue. This last operation adds the given new item to the end of a list. In the next slides we ll look at the two different types of implementations of a queue, one based on arrays and the other based on linked lists. The definition of the data structure for a queue in the case of a dynamic implementation will further illustrate the fact that queues are essentially lists with specific use of their access procedures. 4

5 Interface QueueInterface for the ADT Queue public interface QueueInterface{ public boolean isempty(); //Pre: none //Post: Returns true if the queue is empty, otherwise returns false. public void enqueue(object item) throws QueueException; //Pre:item is the new item to be added //Post: If insertion is successful, item is at the end of the queue. //Post:Throw QueueException if the item cannot be added to the queue. public Object front( ) throws QueueException; //Pre: none //Post: If queue is not empty, the item at the front of a queue is returned, and the queue //Post: is left unchanged. Throws QueueException if the queue is empty. public Object dequeue( ) throws QueueException; //Pre: none //Post: If queue is not empty, the item at the front of the queue is retrieved and removed //Post: from the queue. Throws QueueException if the queue is empty. The ADT Queues Slide Number 5 The interface QueueInterface given in this slide provides the main definition of each access procedure for the ADT queue. As in the case of the ADT list, the constructor createqueue( ) is not included here as it is normally given as constructor of the particular Java class that implements the Queue. The two main types of implementations (array-based, reference-based) for a queue 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 array-based and a reference-based implementation. An example of the QueueException for a queue can be the following: public class QueueException extends java.lang.runtimeexception { s public QueueException(String s){ super(s); }// end constructor }// end QueueException Note that this exception can be avoided by including in the program application method a check to see whether the queue is empty before calling any of the access procedures front(), dequeue(), and enqueue(item). In the case of enqueue(item), if the implementation is a static implementation using arrays, an exception caused by the underlying array data structure being full needs also to be considered. In a reference-based implementation, such exception is not necessary since the memory is dynamically allocated and not fixed a priori. 5

6 Dynamic Implementation of a Queue 5 13 first Data structure class QueueReferenceBased{ private Node first; private Node last; } class Node{ private Object item; private Node next; }. 10 last public class QueueReferenceBased implements QueueInterface{ private Node first; private Node last; public QueueReferenceBased( ){ first = null; last = null; }// end default constructor; To create an empty queue. The ADT Queues Slide Number 6 Like stacks, queues can have an array-based or a reference-based implementation. For the queues the reference-based implementation is a bit more straightforward than the array-based one, so we start with this. A reference-based implementation of a queue can use the same data structure as that used by a linked list, but with two external references, one to refer to the front of the queue, i.e. the first item in the queue, and one to refer to the back of the queue, i.e. the last item in the queue. We call these two reference variables first and last respectively. When we first create an empty queue (no item is inserted), the two instance variables first and last still exist and their reference value is null. This is shown in the main constructor of the class QueueReferenceBased given here. This corresponds diagrammatically to the following situation: The implementation of first the operation isempty( last ) is therefore pretty simple, and it consists of checking that the reference variable last is equal to null, as shown below. Note that it is actually sufficient to check that either of the two variables last or first is equal to null. If the queue were including at least one element both first and last reference variables would be different from null, as shown in the next slide. public boolean isempty( ){ return last == null; }// end isempty( ) 6

7 Dynamic Implementation of a Queue (continued) Inserting a new Node in a queue next last.setnext(newnode); 2. last = newnode; first last newnode For non-empty queues first = newnode; 2. last = newnode; first last newnode For empty queues. Deleting a Node in a queue next 1. first = first.getnext( ); For non-empty queues. first 1 last The ADT Queues Slide Number 7 Insertion at the back of a non-empty queue is straightforward. A diagrammatical representation is given in this slide, where the dashed lines indicate reference values before the operation. Addition of an item at the back of a non-empty queue requires two reference changes: the next reference in the back node needs to be changed so as to reference to newnode instead of null (this is denoted with 1 in the diagram), and the external reference last needs to be changed so as to reference also newnode (this is denoted with 2 in the diagram). When the queue is empty both instance variables first and last have value equal to null. The addition of one new item requires then the variable first and also last to reference the new variable Node since the single item in the queue is both the first and the last item. The case of deleting an item from the front of a non-empty queue requires just one reference change: the first variable has now to reference the second item in the list. Note that if the queue includes only one single element, then the command first = first.getnext( ) will automatically set the reference variable equal to null, but we will still need to change the value of the reference variable last to be equal to null. 7

8 Dynamic Implementation of a Queue (continued) public class QueueReferenceBased implements QueueInterface{ private Node first; private Node last; public void enqueue(object item) { Node newnode = new Node(item); if (isempty( )) { //insertion into empty queue first = newnode;} // new node is referenced by first else {last.setnext(newnode);} //insertion into non-empty queue last = newnode; } public Object dequeue( ) throws QueueException{ if (!isempty( )) { Node firstnode = first; if (first = = last) {last = null;} else{first = first.getnext( );} return firstnode.getitem( ); } else{throws new QueueException( QueueException on dequeue: empty );} } The ADT Queues Slide Number 8 This slide gives the basic implementation of the operations add and dequeue for a queue. Note a slightly different implementation would be required if instead of using just a linked list as data structure, we had chosen to use a circular linked list. What is missing is an example implementation of the access procedure front ( ). The code is given below: public Object front( ) { if (!isempty( )) { // queue is not empty. Retrieve the front item; return first.getitem( ); } else {throws new QueueException( QueueException on front: queue empty );} } Note that a different data structure could have been chosen to implement the queue dynamically. An example could have been to use a circular linked list and just a single reference variable referring to the last node in the circular list. This would have allowed us to get the reference to the first item in a queue by just getting the link value included in the last item of the queue. This example implementation is given in the tutorial sheet 3. 8

9 Static Implementation of a Queue 0 first 4 last max_queue-1 Enqueue increments last and put an item into items[last]. Dequeue just increments first. final int max_queue=max; Object[ ] items; int first; int last; What happens when last reaches the end of the array and the queue is not full? We would like to re-use released space between the start of the array and first. Consider a circular array: first Enqueue:last=(last+1)%max_queue; item[last] = newitem; ++count; 3 7 Dequeue: front=(front+1)%max_queue; --count; The ADT Queues last Slide Number 9 For applications where a fixed-sized queue does not present a problem, we could also use an array data structure to represent a queue. A naïve array-based implementation of a queue is to consider an array, whose size gives the maximum size of the queue, and two variables first and last, which contain, respectively, the index value of the first item and the last item in the queue. In the slide we have named this array items. At the beginning first= 0 and last = -1 to indicate that the queue is empty. To add an item to the queue, we would in this case increment the value of last and place the new item in items[last]. To dequeue an item we would just need to increment the variable first. To check if the queue is empty we would just need to check that last<first. On the other hand the queue is full when last=max_queue-1. One of the problem with this implementation is that after a sequence of enqueue and dequeues, the items in the queue will drift toward the end of the array, and last could become equal to max_queue-1 without the array being full. We could think of shifting the elements in the array to the left after each dequeue operation or whenever last becomes equal to max_queue-1. But this is not an efficient solution. A more elegant solution is to view the array as circular. In this case first and last advance clockwise to dequeue the first item and add a new item respectively. At the beginning, the empty queue is given with first=0 and last=max_queue-1. To obtain the effect of circular array, the values of first and last are calculated using modulo arithmatic (that is the Java % operator) as illustrated in the slide. The main question is now: what conditions define the queue to be full and what conditions define the queue to be empty? We can think of the queue to be empty whenever first passes the value of last. However, this condition would also be possible when the queue becomes full. Because the array is circular consecutive add operations will just increase the value of last until it will eventually catch up with first (i.e. when the queue is full). We therefore need to have a way to distinguish between these two different situations. This can be implemented using a counter variable, called here count, which is incremented at each enqueue operation and decremented at each dequeue operation. count=0 will indicate an empty queue, whereas count 0 will indicate a non-empty queue. 9

10 A circular array implementation of a Queue public class QueueArrayBased implements QueueInterface{ private final int max_queue = 50; private Object items[ ]; //an array of list items private int first, last, count; // number of items in the list public QueueArrayBased( ){ items = new Object[max_queue]; first = 0; count = 0; last = max_queue-1; }// end default constructor; public void enqueue(object newitem) throws QueueException { if (!isfull( )) {last = (last+1) % (max_queue); items[last]=newitem; count++;} else {throw new QueueException( Queue is full );} } The ADT Queues Slide Number 10 Example implementations for the main access procedures of a queue in the case of circular array implementation of the queue, are given here and in the next slide. 10

11 A circular array implementation of a Queue public Object dequeue( ) throws QueueException { if (!isempty( )) { Object queuefront = item[first]; first=(first+1)%(max_queue); count--; return queuefront; } else {throw new QueueException( Queue is empty );} } public isfull( ) { return count = = max_queue}; } The ADT Queues Slide Number 11 What would be the implementation of the access procedures isempty( ) and front( )? This are left as exercise because they are really very simple. 11

13 The ADT Double-Ended Queue Definition The ADT Double-ended Queue is a queue. The access procedures permit addition of items and deletion of items at both ends of the sequence. first 20 prev item next last A possible dynamic implementation is to have a double-linked list with two additional reference variables to refer to the first and last items in the queue. The ADT Queues Slide Number 13 Another particular form of queue is a Double-Ended queue, also called DEQueue. This is similar to a queue with the particular feature that any item can be added or deleted from the queue at either end. A diagrammatical representation is given in this slide. A possible dynamic implementation is to use a double-linked list with the addition of two extra reference variables, called first and last, which refer to the first item and the last item in the queue. The list of access procedure properties for this special type of queues is given in the next slide. 13

14 Access Procedures for DEQueue i. createdequeue( ) // post: creates an empty doubled-ended queue ii. addleft(newitem) // post: adds newitem at the front of the queue. iii. addright(newitem) // post: adds newitem at the end of the queue. Constructor operations i. isempty( ) Predicate operations // post: determines whether a queue is empty i. front( ) // post: returns the item at the front of the queue. It does not change the queue. ii. back( ) // post: returns the item at the back of the queue. It does not change the queue. iii. dequeueleft( ) // post: changes the queue by removing the item at the front of the queue. iv. dequeueright( ) // post: changes the queue by removing the item at the back of the queue. The ADT Queues Slide Number 14 14

15 An ADT Queue is: Course: Programming II - Abstract Data Types Summary A queue is a First-in/First-out (FIFO) data structure. The insertion and deletion operations require efficient access to both ends of the queue. Reference-based implementations use a linear linked list that has both a first item reference and a last item reference; or it uses a circular linked list with just a last item reference. Array-based implementations are prone to rightward drift, which makes queues look full when they are not. More efficient solutions use a circular array. In a circular array we must distinguish between the queue-full and queue-empty conditions. This can be done using appropriate counters. Priority queues and double ended queues are specific types of queues. Their implementation varies from the implementation of an ordinary queue. The ADT Queues Slide Number 15 15

### Course: Programming II - Abstract Data Types. The ADT Stack. A stack. The ADT Stack and Recursion Slide Number 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

### 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,

### 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

### 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

### 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!

### 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

### 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

### 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

### 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

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

### 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

### 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

### 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

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

### 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

### 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

### 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

### Summary. Pre requisition. Content Details: 1. Basics in C++

Summary C++ Language is one of the approaches to provide object-oriented functionality with C like syntax. C++ adds greater typing strength, scoping and other tools useful in object-oriented programming

### 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

### 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

### 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).

### 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

### 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

### 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

### 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

### 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

### 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

### 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

### 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,

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

### 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

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

### 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

### 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

### 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

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

Chapter 7 Linked Lists In order to use linked lists, you need to learn how to allocate memory dynamically on the heap and you need to learn about objects. Recall that local variables are temporary which

### 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

Linked List as an ADT (cont d.) Default constructor Initializes list to an empty state Destroy the list Deallocates memory occupied by each node Initialize the list Reinitializes list to an empty state

### 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

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

### 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

### 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

### TIE-20106 1 TIE-20106 2

TIE-20106 1 1 List structures In this chapter, a few simple data structures (stack and queue) that can be implemented with arrays and/or lists are covered. Two more complex structures based on lists are

### School of Informatics, University of Edinburgh Computer Science 1 Ah [03 04]

School of Informatics, University of Edinburgh Computer Science 1 Ah [03 04] CS1Ah Lecture Note 25 Binary Search Trees This lecture studies binary trees in more detail, in particular their application

### Data Structure. Lecture 3

Data Structure Lecture 3 Data Structure Formally define Data structure as: DS describes not only set of objects but the ways they are related, the set of operations which may be applied to the elements

### Questions 1 through 25 are worth 2 points each. Choose one best answer for each.

Questions 1 through 25 are worth 2 points each. Choose one best answer for each. 1. For the singly linked list implementation of the queue, where are the enqueues and dequeues performed? c a. Enqueue in

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

Data Structures Using C++ 2E Chapter 5 Linked Lists Test #1 Next Thursday During Class Cover through (near?) end of Chapter 5 Objectives Learn about linked lists Become aware of the basic properties of

### 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

### 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.

### Binary Search Trees and Hash Tables

CHAPTER 7 Binary Search Trees and Hash Tables 7.1 Binary Search Trees In Chapter, we introduced containers called a priority queues and dictionaries. A priority queue is a dispenser in which the current

Unordered Linked Lists Derive class unorderedlinkedlist from the abstract class linkedlisttype Implement the operations search, insertfirst, insertlast, deletenode See code on page 292 Defines an unordered

### Creating Database Tables in Microsoft SQL Server

Creating Database Tables in Microsoft SQL Server Microsoft SQL Server is a relational database server that stores and retrieves data for multi-user network-based applications. SQL Server databases are

### 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

### 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

### Queue ADT. March 16, 2000

Queue ADT March 6, 2000 The Queue ADT Queue represent another form of linear data structure. As in the case of the list, the idea of a queue is to represent sequences of elements, all having the same type.

### 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

### 14 Stacks, Queues, And Linked Lists

14-1 Java Au Naturel by William C. Jones 14-1 14 Stacks, Queues, And Linked Lists Overview This chapter requires that you have a solid understanding of arrays (Chapter Seven) and have studied Exceptions

### 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

### Inheritance and Virtual Functions. Linked lists.

Inheritance and Virtual Functions. Linked lists. 26th CS427 Lecture 12.2, 11am, 22nd March 2012 CS427 Inheritance and Virtual Functions. Linked lists. 1/27 In today s class 1 Recall... Inheritance 2 Replacing

### Algorithms and Data Structures Written Exam Proposed SOLUTION

Algorithms and Data Structures Written Exam Proposed SOLUTION 2005-01-07 from 09:00 to 13:00 Allowed tools: A standard calculator. Grading criteria: You can get at most 30 points. For an E, 15 points are

### 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

### Data Structures and Algorithms(3)

Ming Zhang Data Structures and Algorithms Data Structures and Algorithms(3) Instructor: Ming Zhang Textbook Authors: Ming Zhang, Tengjiao Wang and Haiyan Zhao Higher Education Press, 2008.6 (the "Eleventh

### 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)

### D06 PROGRAMMING with JAVA

Cicles Formatius de Grau Superior Desenvolupament d Aplicacions InformÃ tiques D06 PROGRAMMING with JAVA Ch20 Data Structures I PowerPoint presentation, created by Angel A. Juan - ajuanp(@)gmail.com, for

### ! stack, queue, priority queue, dictionary, sequence, set e.g., a Stack is a list implements a LIFO policy on additions/deletions.

Abstract Data Types and Data Structures Often, these terms are used as synonyms. But it s better to think of them this way: ADTs and Data Structures An Abstract Data Type (ADT) represents a particular

### 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

### List, Stack and Queue. Tom Chao Zhou CSC2100B Data Structures Tutorial 3

List, Stack and Queue Tom Chao Zhou CSC2100B Data Structures Tutorial 3 Outline Structure Linked List Overview Implementation Stack Overview Implementation Queue Overview Implementation Structure A collection

### 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

### Application of Stacks: Postfix Expressions Calculator (cont d.)

Application of Stacks: Postfix Expressions Calculator (cont d.) Postfix expression: 6 3 + 2 * = FIGURE 7-15 Evaluating the postfix expression: 6 3 + 2 * = Data Structures Using C++ 2E 1 Application of

### 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

### 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

### Monitors, Java, Threads and Processes

Monitors, Java, Threads and Processes 185 An object-oriented view of shared memory A semaphore can be seen as a shared object accessible through two methods: wait and signal. The idea behind the concept

### Java Review (Essentials of Java for Hadoop)

Java Review (Essentials of Java for Hadoop) Have You Joined Our LinkedIn Group? What is Java? Java JRE - Java is not just a programming language but it is a complete platform for object oriented programming.

### Answer Key. / append i at the tail of this queue and return i / public int enqueue ( int i ) ;

Answer Key 1. General Understanding (10 points) (a) What is the relationship between a method s throws clause and that checked exceptions the can be thrown during the execution of the method? (b) If a

### 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

### 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:

### Parallel Programming

Parallel Programming 0024 Recitation Week 7 Spring Semester 2010 R 7 :: 1 0024 Spring 2010 Today s program Assignment 6 Review of semaphores Semaphores Semaphoren and (Java) monitors Semaphore implementation

### PROBLEMS (Cap. 4 - Istruzioni macchina)

98 CHAPTER 2 MACHINE INSTRUCTIONS AND PROGRAMS PROBLEMS (Cap. 4 - Istruzioni macchina) 2.1 Represent the decimal values 5, 2, 14, 10, 26, 19, 51, and 43, as signed, 7-bit numbers in the following binary

### The ADT Binary Search Tree. Recursive Tree Traversals. The ADT Binary Search Tree. The ADT Binary Search Tree. In-order

Recursive Tree Traversals The ADT Binary Search Tree In-order private void printinorder(treenode node) { if (node!= null) { printinorder(node.getleft()); System.out.print(node.getItem() + " "); printinorder(node.getright());

### 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

### 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

### 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

### CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards

CompuScholar, Inc. Alignment to Utah's Computer Programming II Standards Course Title: TeenCoder: Java Programming Course ISBN: 978 0 9887070 2 3 Course Year: 2015 Note: Citation(s) listed may represent

### Collections & Data Structures. CS 3: Computer Programming in Java

Collections & Data Structures CS 3: Computer Programming in Java Objectives The concept of a collection Separating the interface from the implementation Dynamic data structures Linked lists Queues and

### Getting Started with the Internet Communications Engine

Getting Started with the Internet Communications Engine David Vriezen April 7, 2014 Contents 1 Introduction 2 2 About Ice 2 2.1 Proxies................................. 2 3 Setting Up ICE 2 4 Slices 2

### 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

### Overview of Data Structures

UNIT 3 Concrete Data Types Classification of Data Structures Concrete vs. Abstract Data Structures Most Important Concrete Data Structures Arrays Records Linked Lists Binary Trees Overview of Data Structures

### Introduction to Java A First Look

Introduction to Java A First Look Java is a second or third generation object language Integrates many of best features Smalltalk C++ Like Smalltalk Everything is an object Interpreted or just in time

### Singly Linked Lists and Chains

Chapter 4 Linked Lists Lecture 7-1 Singly Linked Lists and Chains Representing Chains in C++ Template Class Chain Circular Lists Available Space Lists Linked Stacks and Queues Polynomials Equivalence Classes

### 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

### API for java.util.iterator. ! hasnext() Are there more items in the list? ! next() Return the next item in the list.

Sequences and Urns 2.7 Lists and Iterators Sequence. Ordered collection of items. Key operations. Insert an item, iterate over the items. Design challenge. Support iteration by client, without revealing

### Chapter 8. Arithmetic in C++

Christian Jacob Chapter 8 Arithmetic in C++ 8.1 The C++ Vocabulary 8.2 Variables and Types 8.2.1 Data Objects 8.2.2 Variables 8.2.3 Declaration of Variables 8.3 Elementary C++ Data Types 8.3.1 Integers

### Sequences in the C++ STL

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

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

### DATA STRUCTURES USING C

DATA STRUCTURES USING C QUESTION BANK UNIT I 1. Define data. 2. Define Entity. 3. Define information. 4. Define Array. 5. Define data structure. 6. Give any two applications of data structures. 7. Give