Stacks and Queues. Overview. Stacks. Stack Functions

Transcription

1 Overview Stacks and Queues Stacks Queues Adding to the Tail of a List Efficiency Issues Queue Structure Stack Application: Postfix Calculator Stacks and Queues are examples of Abstract Data Types Stacks and Queues are used in many computing applications, as well as forming auxiliary structures for common algorithms, and appearing as components of larger structures. Stacks Stack Functions push pop a stack is a collection of items such that the last item to enter is the first one to exit, i.e. last in, first out (LIFO) based on the idea of a stack of books, or plates top of stack Essential Stack functions: push() // add new item to stack pop() // remove top item from stack Additional Stack functions: top() // fetch top item (but don t remove it) size() // number of items isempty()

2 Stack Applications Queues page-visited history in a Web browser undo sequence in a text editor checking for balanced brackets HTML tag matching postfix calculator chain of function calls in a program a queue is a collection of items such that the first item to enter is the first one to exit, i.e. first in, first out (FIFO) based on the idea of queueing at a bank, shop, etc. First element of queue dequeue enqueue Queue Functions Queue Applications Essential Queue functions: enqueue() // add new item to queue dequeue() // remove front item from queue Additional Queue functions: front() // fetch front item (but don t remove it) size() // number of items isempty() waiting lists, bureaucracy access to shared resources (printers, etc.) phone call centres multiple processes in a computer

3 Implementing Stacks and Queues Adding to the Tail of a List First element of list a stack can be implemented using a linked list, by adding and removing at the head [push() and pop()] for a queue, we need to either add or remove at the tail can either of these be done efficiently? adding an item at the tail is achieved by making the last node of the list point to the new node we first need to scan along the list to find the last item Adding to the Tail of a List Efficiency Issues Lnode a d d t o t a i l ( Lnode new node, Lnode head ) { i f ( head == ) { // l i s t i s empty head = new node ; e l s e { // l i s t not empty Lnode node = head ; w h i l e ( node >!= ) { node = node > ; // scan to end node >n e x t = new node ; r e t u r n head ; Unfortunately, this implementation is very slow. Every time a new item is inserted, we need to traverse the entire list (which could be very large). We can do the job much more efficiently if we retain a direct link to the last item or tail of the list: i f ( t a i l == ) { // l i s t i s empty head = node ; e l s e { // l i s t not empty t a i l > = node ; t a i l = node ; Note: there is no way to efficiently remove items from the tail. (Why?)

4 Queue Structure Making a new Queue We can use this structure to implement a queue efficiently: t y p e d e f s t r u c t queue Queue ; s t r u c t queue { Lnode head ; Lnode t a i l ; i n t s i z e ; ; Queue makequeue ( ) { Queue q = ( Queue ) m a l l o c ( s i z e o f ( Queue ) ) ; i f ( q == ) { f p r i n t f ( s t d e r r, Out o f memory\n ) ; e x i t ( 1 ) ; q >head = ; q > t a i l = ; q >s i z e = 0 ; r e t u r n q ; Adding a new Item to a Queue Removing an Item from a Queue v o i d enqueue ( Lnode new node, Queue q ) { i f ( q > t a i l == ) { // queue i s empty q >head = new node ; e l s e { // queue not empty q >t a i l > = new node ; q > t a i l = new node ; q >s i z e ++; Lnode dequeue ( Queue q ) { Lnode node = q >head ; i f ( q >head!= ) { i f ( q >head == q > t a i l ) { // o n l y one item q > t a i l = ; q >head = q >head >n e x t ; q >s i z e ; r e t u r n node ;

5 Example: queue.c Example: queue.c i n t main ( v o i d ) { Queue q = makequeue ( ) ; Lnode node ; i n t ch ; w h i l e ( ( ch = g e t c h a r ( ) )!= EOF) { i f ( ch == ) { node = dequeue ( q ) ; i f ( node!= ) { p r i n t f ( Dequeueing %c \n, node > ) ; f r e e ( node ) ;... e l s e i f ( ch == \ n ) { p r i n t L i s t ( q >head ) ; e l s e { enqueue ( makenode ( ch ), q ) ; f r e e L i s t ( q >head ) ; r e t u r n 0 ; Reverse Polish Notation Postfix Calculator Some early calculators and programming languages used a convention known as Reverse Polish Notation (RPN) where the operator comes after the two operands rather than between them: result = * result = * result = * + result = 15 A calculator using RPN is called a Postfix Calculator; it can be implemented using a stack: when a number is entered: push it onto the stack when an operator is entered: pop the top two items from the stack, apply the operator to them, and push the result back onto the stack.

6 postfix.c postfix.c i n t main ( v o i d ) { Lnode l i s t = ; i n t num ; i n t a, b, num ; w h i l e ( ( ch = g e t c ( s t d i n ) )!= EOF) { i f ( ch == \ n ) { p r i n t f ( R e s u l t : %d\n, l i s t > ) ; e l s e i f ( i s d i g i t ( ch ) ) { ungetc ( ch, s t d i n ) ; // put f i r s t d i g i t back s c a n f ( %d, &num ) ; // now scan e n t i r e number l i s t = push ( makenode (num ), l i s t ) ; e l s e i f ( ch == + ch == ch == ) { i f ( l i s t!= ) { a = l i s t > ; // f e t c h top item l i s t = pop ( l i s t ) ; i f ( l i s t!= ) { b = l i s t > ; // f e t c h 2nd item l i s t = pop ( l i s t ) ; s w i t c h ( ch ) { c a s e + : num = b + a ; break ; c a s e : num = b a ; break ; c a s e : num = b a ; break ; l i s t = push ( makenode (num ), l i s t ) ;