1 / 23

15.6 – Queues

15.6 – Queues. A queue is a linear collection whose elements are added on one end and removed from the other Queue elements are processed in a first in, first out (FIFO) manner Elements are removed from the queue in the same order in which they are placed on the queue

curran-peters
Download Presentation

15.6 – Queues

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 15.6 – Queues • A queue is a linear collection whose elements are added on one end and removed from the other • Queue elements are processed in a first in, first out (FIFO) manner • Elements are removed from the queue in the same order in which they are placed on the queue • A queue is consistent with the general concept of • a waiting line to buy movie tickets • a request to print a document • crawling the web to retrieve documents

  2. 15.6 – Queues Adding an element Removingan element rear of queue front of queue

  3. 15.6 – javafoundations.Queue //******************************************************************** // Queue.java Java Foundations // // Defines the interface to a queue collection. //******************************************************************** package javafoundations; public interface Queue<T> { // Adds the specified element to the rear of the queue. public void enqueue (T element); // Removes and returns the element at the front of the queue. public T dequeue(); // Returns a reference to the element at the front of the queue // without removing it. public T first(); // Returns true if the queue contains no elements and false // otherwise. public boolean isEmpty(); // Returns the number of elements in the queue. public int size(); // Returns a string representation of the queue. public String toString(); }

  4. 15.7 – Radix Sort • A radix sort is unusual because it does not involve comparisons between elements! • The technique used in the radix sort is based on the structure of the sort key • Separate queues are created for each possible value of each digit or character of the sort key • The number of queues, or the number of possible values, is called the radix • if we were sorting strings made up of lowercase alphabetic characters, the radix would be 26, one for each possible character • if we were sorting decimal numbers, then the radix would be 10, one for each digit 0 to 9 • The radix sort makes a pass through the values for each position in the sort key

  5. 15.7 – Radix Sort (1st pass) front of queue  442 503 312 145 250 341 325 102 420 143 Original list

  6. 15.7 – Radix Sort (2nd pass results) front of queue  503 102 312 325 420 145 143 442 341 250

  7. 15.7 – Radix Sort (3rd pass results) front of queue  145 143 102 250 341 325 312 442 420 503

  8. 15.6 – RadixSort.java for (int digitVal = 0; digitVal <= 9; digitVal++) digitQueues[digitVal] = new ArrayQueue<Integer>(); // sort the list for (int position=0; position <= 3; position++) { for (int scan = 0; scan < list.length; scan++) { temp = String.valueOf (list[scan]); digit = Character.digit (temp.charAt(3-position), 10); digitQueues[digit].enqueue (list[scan]); } // gather numbers back into list num = 0; for (int digitVal = 0; digitVal <= 9; digitVal++) { while (!(digitQueues[digitVal].isEmpty())) { list[num] = digitQueues[digitVal].dequeue().intValue(); num++; } } } (more…)

  9. 15.8 – Implementing Queues with Arrays • Adds a new element to the rear of the queue, which is stored at the high end of the array Dequeue ‘A’ Left-shift tocorrectqueue A B C D E Enqueue ‘E’

  10. 15.8 – javafoundations.ArrayQueue //******************************************************************** // ArrayQueue.java Java Foundations // // Represents an array implementation of a queue. The front of // the queue is kept at array index 0. //******************************************************************** package javafoundations; import javafoundations.exceptions.*; public class ArrayQueue<T> implements Queue<T> { private final int DEFAULT_CAPACITY = 10; private int count; private T[] queue; //----------------------------------------------------------------- // Creates an empty queue using the default capacity. //----------------------------------------------------------------- public ArrayQueue() { } (more…)

  11. //----------------------------------------------------------------- // Removes the element at the front of this queue and returns a // reference to it. Throws an EmptyCollectionException if the // queue is empty. //----------------------------------------------------------------- public T dequeue() throws EmptyCollectionException { if (count == 0) throw new EmptyCollectionException ("Dequeue operation failed. " + "The queue is empty."); T result = count--; // shift the elements to keep the front element at index 0 for (int index=0; index < count; index++) queue[count] = null; return result; } // The following methods are left as Programming Projects. // public void enqueue (T element) { } // public T first () throws EmptyCollectionException { } // public boolean isEmpty() { } // public int size() { } // public String toString() { } } 15.8 – javafoundations.ArrayQueue

  12. 15.9 – Implementing Queues with Circular Arrays • As elements are dequeued, the front of the queue will move further into the array • As elements are enqueued, the rear of the queue will also move further into the array • The challenge comes when the rear of the queue reaches the end of the array • When this occurs, it “wraps around” to the front of the array • Use two variables, front and rear, to represent the location where the first element is stored, and where the next available slot in the array is located (respectively)

  13. n 0 n-1 1 2 3 4 … 5 … 6 7 8 15.9 – Implementing Queues with Circular Arrays A B front 3 4 C rear 7 6 count 4 3 D

  14. 15.9 – The Changing State of a Circular Array Q D A E B C A D E B C D E A B C 3 0 7 8 2 5 5 front rear count

  15. 15.9 – javafoundations.CircularArrayQueue //******************************************************************** // CircularArrayQueue.java Java Foundations // // Represents an array implementation of a queue in which neither // end of the queue is fixed in the array. The variables storing the // indexes of the front and rear of the queue continually increment // as elements are removed and added, cycling back to 0 when they // reach the end of the array. //******************************************************************** package javafoundations; import javafoundations.exceptions.*; public class CircularArrayQueue<T> implements Queue<T> { private final int DEFAULT_CAPACITY = 10; private int front, rear, count; private T[] queue; (more…)

  16. 15.9 – javafoundations.CircularArrayQueue //----------------------------------------------------------------- // Creates an empty queue using the default capacity. //----------------------------------------------------------------- public CircularArrayQueue() { } //----------------------------------------------------------------- // Adds the specified element to the rear of this queue, expanding // the capacity of the queue array if necessary. //----------------------------------------------------------------- public void enqueue (T element) { if (count == queue.length) expandCapacity(); queue[rear] = element; rear = count++; } (more…)

  17. 15.9 – javafoundations.CircularArrayQueue //----------------------------------------------------------------- // Creates a new array to store the contents of this queue with // twice the capacity of the old one. //----------------------------------------------------------------- public void expandCapacity() { T[] larger = (T[])(new Object[queue.length*2]); for (int index=0; index < count; index++) larger[index] = front = 0; rear = count; queue = larger; } //----------------------------------------------------------------- // The following methods are left as Programming Projects. //----------------------------------------------------------------- // public T dequeue () throws EmptyCollectionException { } // public T first () throws EmptyCollectionException { } // public int size() { } // public boolean isEmpty() { } // public String toString() { } }

  18. rear front A B C D 4 count 15.10 – Implementing Queues with Links

  19. 15.10 – javafoundations.LinkedQueue //******************************************************************** // LinkedQueue.java Java Foundations // // Represents a linked implementation of a queue. //******************************************************************** package javafoundations; import javafoundations.exceptions.*; public class LinkedQueue<T> implements Queue<T> { private int count; private LinearNode<T> front, rear; //----------------------------------------------------------------- // Creates an empty queue. //----------------------------------------------------------------- public LinkedQueue() { } (more…)

  20. 15.10 – javafoundations.LinkedQueue //----------------------------------------------------------------- // Adds the specified element to the rear of this queue. //----------------------------------------------------------------- public void enqueue (T element) { LinearNode<T> node = new LinearNode<T>(element); if (count == 0) front = node; else rear.setNext(node); rear = node; count++; } //----------------------------------------------------------------- // The following methods are left as Programming Projects. //----------------------------------------------------------------- // public T dequeue () throws EmptyCollectionException { } // public T first () throws EmptyCollectionException { } // public boolean isEmpty() { } // public int size() { } // public String toString() { } }

  21. Josephus Flavius Problem • Given n people, numbered 1 to n, sitting on a circle • Starting with person #1, a hot potato is passed around the circle. • After m passes, the person holding the potato is eliminated • The circle closes ranks, and the game continues with the person who is sitting next to the eliminated person. • The last remaining person, wins. Simulation at http://www.cut-the-knot.org/recurrence/flavius.shtml

  22. Josephus Flavius Game publicstatic void playJosephus (int n, int m) { // simulates the Josephus problem for n people and m passes, using a Queue Queue Q = new Queue(); int i, remove; for (i = 1; i <= n; i++) // create a queue of n integers Q.enq(new Integer(i)); while (Q.size() > 1) { // until 1 integer is left for (i = 0; i < m; i++) // pass over m integers ____________________________ // remove next integer System.out.println("Player " + Q.deq() + " removed"); } // last integer that remains is the "winner" System.out.println("Player " + Q.front() + " wins"); }

  23. 15.11 – Analysis of Stack Implementations • Both stacks and queues can be implemented very efficiently • In almost all cases, the operations are not affected by the number of elements in the collection • All operations for a stack (push, pop, peek, etc.) are O(1) • Almost all operations for a queue are O(1) • The only exception is the dequeue operation for the ArrayQueue implementation – the shifting of elements makes it O(n) • The dequeue operation for the CircularArrayQueue is O(1) because of the ability to eliminate the shifting of elements

More Related