SYSC 2006 Winter 2012 Linear Collections: Queues

Size: px

Start display at page:

Download "SYSC 2006 Winter 2012 Linear Collections: Queues"

Evangeline Gardner
5 years ago
Views:

1 SYSC 2006 Winter 2012 Linear Collections: Queues Copyright D.L. Bailey, Systems and Computer Engineering, Carleton University revised March 20, 2011, November 28, 2011, March 30, 2012

2 Definition A queue is a collection in which the elements are maintained in the order in which they were added A queue is a first-in, first out (FIFO) collection - the first element is the first one retrieved or removed SYSC Queues 2

3 Abstract View create queue add (enqueue) 5 5 add (enqueue) 3 add (enqueue) 7 remove (dequeue) element (returns 5) remove (dequeue) element (returns 3) queue queue SYSC Queues 3

4 Implementing a Queue Because elements are always added at the of the queue, but are retrieved and removed from the of the queue, we should pick a data structure that permits efficient manipulation of both ends of the queue there are no operations that insert elements into or remove elements from the middle of a queue, so efficient access to that part of the data structure is not important SYSC Queues 4

5 Array-Based Queue Data Structure An array-based implementation could be similar to the array-based list struct intarrayqueue { int *elems; int capacity; int size; }; typedef struct intarrayqueue IntQueue; SYSC Queues 5

6 Thinking About the Queue Operations We define elems[0] to be the of the queue and elems[size-1] to be the of the queue enqueue running time will be constant - why? running time will be constant - why? dequeue running time will be proportional to the # of items in the queue why? dequeue would be more efficient (its running time reduced) if elements in the array weren't shifted to the left when the item at position 0 is removed SYSC Queues 6

7 Revised Queue Data Structure struct intarrayqueue { int *elems; int capacity; int size; // # of elements in the Q int ; int ; }; typedef struct intarrayqueue IntQueue; SYSC Queues 7

8 Revised Queue Data Structure is the index of the element in the queue; i.e., the index of the array element from which the next integer will be removed is the index of the element in the queue; i.e., the index of the array element where the last integer was stored SYSC Queues 8

9 Revised Queue Data Structure Initially, is 0, is -1, and size is 0 After 5, 3, 7 have been added to the queue: size 3 0 elems [0] [1] [2]?? [3] [4] SYSC Queues 9

10 Rightward Drift Assume that 5, 3, 7, 2, 8 were added to the queue, and 5 and 3 have been removed from the queue Now, == capacity of queue - 1, but there is room in the queue at the beginning of the array for 2 more elements (elems[0], elems[1]) size elems?? 7 [0] [1] [2] 2 8 [3] [4] SYSC Queues 10

11 Handling Rightward Drift Approach 1: ensure always == 0 after an element is removed from the queue, shift all remaining elements in the array one position to the left, decrement by 1 (an O(n) algorithm) that's what we wanted to avoid e.g., after adding 5, 3, 7, 2, 8, removing 5, 3: size elems [0] [1] [2]?? [3] [4] SYSC Queues 11

12 Handling Rightward Drift Approach 2: shift elements only as required when we try to enqueue an element, if == capacity of queue - 1, shift all elements in the array to the left, then append the element (an O(n) algorithm) e.g., after adding 5, 3, 7, 2, 8, removing 5, 3, then adding 6 size [0] [1] [2] 6? [3] [4] SYSC Queues 12

13 Handling Rightward Drift Approach 3: visualize the array as a circular array (sometimes called a ring buffer) e.g., a queue with capacity = 8 size [6] [5] [7] SYSC Queues 13 [0] [1] 3 4 [2] 6 3 [4] [3]

14 Handling Rightward Drift When or reaches capacity of queue -1, its value wraps around to 0 size [6] [5] [7] 7 3 [4] 2 6 [0] 12 3 [3] [1] 4 [2] SYSC Queues 14

15 Full Queue is one slot ahead of, size == 8 size 8 2 [6] [7] 7 2 [0] 12 9 [1] 1 [5] 3 [4] [3] [2] SYSC Queues 15

16 Empty Queue is one slot ahead of, size == 0 size 0 2 [6] [7]??? [0]? [1] 1 [5]? [4]??? [3] [2] SYSC Queues 16

17 Construct an Empty Queue IntQueue *intqueue_construct(int capacity) { assert(capacity > 0); IntQueue *qp = malloc(sizeof(intqueue)); assert(qp!= NULL); int *pa = malloc(capacity * sizeof(int)); assert(pa!= NULL); SYSC Queues 17

18 Construct an Empty Queue } qp->data = pa; qp->capacity = capacity; qp->size = 0; qp-> = 0; qp-> = capacity - 1; return qp; SYSC Queues 18

19 Determining the Queue's State _Bool intqueue_is_empty(const IntQueue *qp) { assert(qp!= NULL); return qp->size == 0; } _Bool intqueue_is_full(const IntQueue *qp) { assert(qp!= NULL); return qp->size == qp->capacity; } SYSC Queues 19

20 Determining the Queue's State int intqueue_size(const IntQueue *qp) { assert(qp!= NULL); return qp->size; } SYSC Queues 20

21 Insert/Retrieve/Remove Elements intqueue_enqueue() returns true if an element was inserted, false if the queue is full (element not inserted) intqueue_() returns true if an integer was retrieved (and assigned to the variable pointed to by parameter element), false if the queue is empty intqueue_dequeue() returns true if an integer was retrieved and removed (and assigned to the variable pointed to by parameter element), false if the queue is empty SYSC Queues 21

22 Insert an Element into a Queue _Bool intqueue_enqueue(intqueue *qp, int element) { assert(qp!= NULL); if (intqueue_is_full(qp)) return false; qp-> = (qp-> + 1) % qp->capacity; qp->data[qp->] = element; qp->size++; return true; } SYSC Queues 22

23 Retrieve an Element from a Queue _Bool intqueue_(intqueue *qp, int *element) { assert(qp!= NULL); if (intqueue_is_empty(qp)) return false; *element = qp->data[qp->]; return true; } SYSC Queues 23

24 Remove an Element from a Queue _Bool intqueue_dequeue(intqueue *qp, int *element) { assert(qp!= NULL); if (intqueue_is_empty(qp)) return false; *element = qp->data[qp->]; qp-> = (qp-> + 1) % qp->capacity; qp->size--; return true; } SYSC Queues 24

Queues. Gaddis 18.4, Molly A. O'Neil CS 2308 :: Spring 2016

Queues. Gaddis 18.4, Molly A. O'Neil CS 2308 :: Spring 2016 Queues Gaddis 18.4, 18.6 Molly A. O'Neil CS 2308 :: Spring 2016 The Queue ADT A queue is an abstract data type that stores a collection of elements of the same type The elements of a queue are accessed