Determine if the following are true or false A "glass" queue allows an application to peek at the front or rear values of a queue. The enqueue and dequeue queue operations are inverses of each other. Therefore, performing an enqueue followed by a dequeue is always equivalent to performing a dequeue followed by an enqueue. A "glass" queue allows an application to peek at any value in a queue. A java interface can inherit from at most one other interface.

Determine if the following are true or false A "glass" queue allows an application to peek at the front or rear values of a queue. The enqueue and dequeue queue operations are inverses of each other. Therefore, performing an enqueue followed by a dequeue is always equivalent to performing a dequeue followed by an enqueue. A "glass" queue allows an application to peek at any value in a queue. A java interface can inherit from at most one other interface.

C++ Programming: From Problem Analysis to Program Design

8th Edition

ISBN:9781337102087

Author:D. S. Malik

Publisher:D. S. Malik

Chapter18: Stacks And Queues

Section: Chapter Questions

Problem 16PE: The implementation of a queue in an array, as given in this chapter, uses the variable count to...

See similar textbooks

Similar questions

I need help with getting started for this in Java. Codes listed below. Complete the CircularArrayQueue.java class implementation of the Queue.java interface so that it does not use a count field. This implementation must have only the following fields: DEFAULT_CAPACITY front rear queue Implement the methods enter leave front isEmpty isFull expandCapacity Write a test class to test each of the methods you implement. Queue.java public interface Queue<E> { /** * The element enters the queue at the rear. */ public void enter(E element); /** * The front element leaves the queue and is returned. * @throws java.util.NoSuchElementException if queue is empty. */ public E leave(); /** * Returns True if the queue is empty. */ public boolean isEmpty(); /** * Returns the front element without removing it. * @throws java.util.NoSuchElementException if queue is empty. */ public E front();}…
IN JAVA This triple-ended queue exercise can be found at https://open.kattis.com/problems/teque. The requirements for this program are compatible with those of the Kattis problem, so a solution should produce correct results when submitted on Kattis. The Triple-Ended QUEue supports four operations: push_back x: inserts the element x at the end of the TEQUE push_front x: inserts the element x at the front of the TEQUE push_middle x: inserts the element x so that the insertion index for x is (k + 1)/2 for a 0-based indexed TEQUE. get i: prints out the ith index element (0-based) of the TEQUE. The TEQUE will be implemented as a linked list. The usual implementation requirements apply along with a screenshot of the results from Kattis. Sample input 10 push_back 1 push_front 2 push_back 3 push_front 4 push_middle 5 push_back 6 get 3 push_middle 7 push_middle 8 get 5 Sample Output 1 1 Subject: Java Programming
Write a java function toRemoves the element at the front of this queue and returns a reference to it. return the element removed from the front of the queue throws EmptyCollectionException if the queue is empty.
A) Write a generic Java queue class (a plain queue, not a priority queue). Then, call it GenericQueue, because the JDK already has an interface called Queue. This class must be able to create a queue of objects of any reference type. Consider the GenericStack class shown below for some hints. Like the Stack class below, the GenericQueue should use an underlying ArrayList<E>. Write these methods and any others you find useful: enqueue() adds an E to the queue peek() returns a reference to the object that has been in the queue the longest, without removing it from the queue dequeue() returns the E that has been in the queue the longest, and removes it from the queue contains(T t) returns true if the queue contains at least one object that is equal to t *in the sense that calling .equals() on the object with t the parameter returns true.* Otherwise contains returns false. size() and isEmpty() are obvious.
1. Implement the “missing” front and rear operations in JAVA using constructor and Also write output: class Queue { private int maxSize; private long[] queArray; private int front; private int rear; private int nItems; public Queue(int s) // constructor { maxSize = s; queArray = new long[maxSize]; front = 0; rear = -1; nItems = 0; } // public void insert(long j) { // put item at rear of queue // public long remove() { // take item from front of queue //And then return } // public long peekFront() { // peek at front of queue //Return queue array front } // public boolean isEmpty(){ // true if queue is empty //return nItems zero } // public boolean isFull() { // true if queue is full return } // public int size() // number of items in queue { //return nItems; } // } // end class Queue //////////////////////////////////////////////////////////////// class QueueApp { public static void main(String[] args) { Queue theQueue = new Queue(5); // queue holds 5 items…
ALL TRUE OR FALSE QUESTIONS 1. A "deque" allows an application to enqueue and dequeue from both front and rear of a queue. 2. The Queue ADT of the text is defined to hold elements of type Objec 3. Java supports inheritance of interfaces. 4. The text's array-based queue implementations use the fixed-front approach. 5. If N represents the number of elements in the queue, then the dequeue method of the ArrayBoundedQueue class is O(1). 6. When an object of class LinkedQueue represents an empty queue, its rear variable is 0. 7. A standard linked list provides a good implementation of a "Deque". 8. When implementing a queue with a linked list, the front of the queue is also the front of the linked list. 9. Our LinkedQueue class implements the QueueInterface interface. 10. The text's array-based queue implementations use the floating-front approach.
Create a new Java class in a file named "ListPQ.java" that implements the Queue interface and uses the LinkedList provided by the JCF to implement a priority queue. Note that LinkedList does not automatically order values based on priority, so it will be up to you to make sure that values are removed in priority order. You should try to implement your priority queue as efficiently as possible - basic operations should run in constant or linear time. Your priority queue need only work with integers. Do not modify any of the provided code. //This is ArrayHeap (provided code) import java.util.Arrays; public class ArrayHeap implements Heap { private int[ ] array; private int size; public ArrayHeap() { array = new int[3]; size = 0; } @Override public void add(int value) { // add pt 1 if(size == array.length) { array = Arrays.copyOf(array, size*2); } array[size] = value; // sifting up int child = size; int parent = (child - 1) / 2; while(array[parent] > array[child]) { swap(parent,…
For the Queue use the java interface Queue with the ArrayDeque classFor the Stack use the java Deque interface with the ArrayDeque classFor the LinkedList, use the java LinkedList class Also, when you are asked to create and use a Queue, you can use only those methods pertaining to the general operations of a queue (Enqueue: addLast, Dequeue: removeFirst, and peek() Similarly, when you are asked to create and/or use a stack, you can use only those methods pertaining to the general operations of a Stack (push: addFirst, pop:removeFirst, and peek() ) Your code should not only do the job, but also it should be done as efficiently as possible: fast and uses no additional memory if at all possible Questions Write a method “int GetSecondMax(int[] array)” . this method takes an array of integers and returns the second max value Example: if the array contains: 7, 2, 9, 5, 4, 15, 6, 1}. It should return the value: 9
In java by using this Queue class: public class Queue {private int rear, front;private Object[] elements;Queue(int capacity) {elements = new Object[capacity];rear = -1;front = 0;}void enqueue(Object data) {if (isFull()) {System.out.println("Queue overflow");} else {rear = (rear + 1) % elements.length;elements[rear] = data;}}Object dequeue() {if (isEmpty()) {System.out.println("Queue empty");return null;} else {Object retData = elements[front];elements[front] = null;front = (front + 1) % elements.length;return retData;}}Object peek() {if (isEmpty()) {System.out.println("Queue is empty");return null;} else {return elements[front];}}boolean isEmpty() {return elements[front] == null;}boolean isFull() {return (front == (rear + 1) % elements.length &&elements[front] != null && elements[rear] != null);}int size() {if (rear >= front) {return rear - front + 1;} else if (elements[front] != null) {return elements.length - (front - rear) + 1;} else {return 0;}}void…
Write a Java program to implement a queue by using arrayo Define a Queue interface.o Define an ArrayQueue class.o Define a Test class to test all methods first code package ArrayQueue; public class ArrayQueue<E> implements Queue<E> { public static final int CAPACITY=1000; private E[] data; private int f = 0; private int sz = 0; public ArrayQueue() { data = (E[]) new Object[CAPACITY]; } public ArrayQueue(int capacity) { data = (E[]) new Object[capacity]; } public int size() { return sz; } public boolean isEmpty() { return (sz == 0); } public void enqueue(E e ) throws IllegalStateException { if(sz == data.length) throw new IllegalStateException(" queue is full"); int enqueueIndex = (f + sz) % data.length; data[enqueueIndex] = e; sz++; } public E first() { if(isEmpty()) return null; return data[f]; } public E dequeue() { if(isEmpty()) return null; E answer = data[f]; data[f] = null; f= (f+1)% data.length; sz --; return answer; } } secound code package…
Develop an application in java language that stores characters A, B and C in a queue array and then displays both the size and the first-in element of the stack. The application should then remove the first element of the queue and then display both the size and the first-in element of the queue again. Appropriate queue methods should be used to add, delete and display characters.
Create a class Circular Queue that implements the functionality of a queue providing all therequired operations (Enqueue(), Dequeue(), Empty(), Full() and getFront()). in C++