Lecture 3: Stacks & Queues

Size: px

Start display at page:

Download "Lecture 3: Stacks & Queues"

Barrie Williamson
5 years ago
Views:

1 Lecture 3: Stacks & Queues Prakash Gautam 22 March, 2018

2 Objectives Definition: Stacks & Queues Operations of Stack & Queues Implementation of Stack & Queue Applications 2

3 Stacks 3

4 Last In, First Out: LIFO

5 Queues 5

6 First In, First Out: FIFO

7 Agenda Introduction: Stacks & Queues Basic Operations of Stack Implementation of Stack Basic Operations of Queue Implementation of Queue 7

8 An An array array is is aa random random access access data data structure, structure, where where each each element element can can be be accessed accessed directly directly and and in in constant constant time. time. A A typical typical illustration illustration of of random random access access is is aa book book -- each each page page of of the the book book can can be be open open independently independently of of others. others. Random Random access access is is critical critical to to many many algorithms, algorithms, like like binary binary search search

9 A A linked linked list list is is aa sequential sequential access access data data Structure, Structure, where where each each element element can can be be accessed accessed only only in in particular particular order. order. A A typical typical illustration illustration of of sequential sequential access access is is aa roll roll of of paper paper or or tape tape -- all all prior prior material material must must be be unrolled unrolled in in order order to to get get to to data data you you want. want.

10 Stacks Linear data structure Last In, First Out (LIFO) data structure A Stack is a container of objects: inserted and removed according to LIFO principle Items are removed in the reverse order from the way they were inserted Stacks are less flexible (Limited access DS) Data can be added & removed from the Stack only at the top But are more efficient and easy to implement 10

11 Structural Definition: A stack is either empty or It consists of a top and the rest which is a stack TOP TOP 11

12 Stack Operations PUSH: To insert an item from top of stack POP: To remove an item from top of the stack IsEmpty: Stack considered empty when there is no item on top IsFull: Stack considered full if no other element can be inserted on top of the stack 12

13 PUSH(A) TOP TOP TOP A POP( ) PUSH(B) B A TOP A Empty Stack 13

14 Implementation of Stacks using Array S An array S: must be, S.TOP=5 TOP: Refers to the top element Capacity: Refers to the size S.Capacity=10 S[S.top] 14

15 The variable TOP changes from -1 to capacity 1 The stack S is empty when top = -1 The stack S is full when top = capacity-1 In fixed-size stack abstraction the capacity stays unchanged, so when top=capacity, the stack object throws an exception In a dynamic stack abstraction when top=capacity, we double up the stack size 15

16 Stack Errors Stack Underflow:trying to pop empty stack Stack Overflow: trying to push a full stack For underflow, you should throw an exception If don t caught, Java will throw an ArrayIndexOutOfBounds exception You could create your own, more informative exception For Overflow: Consider larger array 16

17 The bottom of the stack could be at the other end S S.top=6 Two stacks to share the same storage area S1.top= S2.top=6 17

18 O(1) STACK-EMPTY(S) STACK-EMPTY(S) if if S.top S.top == == return 2. return TRUE TRUE else else return return FALSE FALSE

19 O(1) PUSH(S, PUSH(S, x) x) S.top S.top == S.top+1 S.top S[S.top]=x S[S.top]=x

20 O(1) POP(S) POP(S) if if STACK-EMPTY(S) STACK-EMPTY(S) 2. error 2. error underflow underflow else else S.top S.top == S.top-1 S.top return return S[S.top+1] S[S.top+1]

Implementation of Stacks using Linked-List All the action happens at the top of a stack, so SLL is a fine way to implement it The header of the list points

21 Implementation of Stacks using Linked-List All the action happens at the top of a stack, so SLL is a fine way to implement it The header of the list points to the top of the stack mystack Push: inserting an element at the front of the list Pop: deleting an element from the front of the list Null 21

22 Overflow won t happen. Why? Underflow can happen. How can we solve? If node is popped from a list: data will be removed. 22

23 Queues Linear data structure First In, First Out (FIFO) data structure A Stack is a container of objects: inserted and removed according to FIFO principle Insertion is done at one end, while deletion is performed at the other end Example: Customers waiting to pay a cashier Can only add to the end of the queue, and can only remove from the front of the queue 23

24 Queue Operations Enqueue: To insert an item at back of the queue Dequeue: To delete an item from front of the queue 24

25 Queue Implementations using Array 25

26 To Insert(enqueue): Insert element on 5th position & set MyQueue.back=4 myqueue MyQueue.front= MyQueue.back=4 To delete(dequeue): Take element from 1st position(0) & set MyQueue.front=1 26

27 Q1.back=4 Q1.front=0 Initial queue After insertion: After deletion: Q1.front= ? Q1.back=5

28 Notice how the array contents crawl to the right as elements are inserted and deleted!

29 O(1) QUEUE-EMPTY(Q) QUEUE-EMPTY(Q) if if Q.front==Q.back Q.front==Q.back 2. return 2. return TRUE TRUE else else return return FALSE FALSE

30 O(1) ENQUEUE(Q,x) ENQUEUE(Q,x) Q[Q.back]=x Q[Q.back]=x if if Q.back==Q.length Q.back==Q.length 3. Q.back=0 3. Q.back= else else Q.back=Q.back+1 Q.back=Q.back+1

31 O(1) DEQUEUE(Q) DEQUEUE(Q) x=q[q.front] x=q[q.front] if if Q.front==Q.length Q.front==Q.length 3. Q.front=0 3. Q.front= else else Q.front=Q.front+1 Q.front=Q.front return return xx

32 Implementations of Queues using Linked-List In a queue, insertions occur at one end, deletions at the other end Operations at the front of a SLL are O(1), but at the other end they are O(n), Because you have to find the last element each time BUT There is a simple way to use a SLL to implement both insertions and deletions in O(1) time 32

33 HOW? Use the first element in an SLL as the front of the queue Use the last element in an SLL as the back of the queue Keep pointers to both the front and the rear of the SLL 34

34 Enqueue Node to be enqueued last first Find the current last node Change it to point to the new last node Change the last pointer in the list header 35

35 Dequeue last first First = First.next 36

36 Queue Implementation Details Array Implementation You can have both overflow and underflow You should set deleted elements to null SLL Implementation You can have underflow Overflow is a global out-of-memory condition There is no reason to set deleted elements to null 37

37 Applications: Stacks & Queues To Implement recursive functions Queue of processes to be scheduled on the CPU Page-visited history in a Web browser Undo sequence in a text editor HTML Tag Matching & Management Access to shared resources (e.g., printer) Multiprogramming Waiting lists Bracket Balance(Mathematics) Round-Robin scheduling 38

38 ...? Thank You 39

Stacks and Queues. CSE 373 Data Structures Lecture 6

Stacks and Queues. CSE 373 Data Structures Lecture 6 Stacks and Queues CSE 373 Data Structures Lecture 6 Readings and References Reading Sections 3.3 and 3.4 10/11/02 Stacks and Queues - Lecture 6 2 Stacks A list for which Insert and Delete are allowed only