Question 1

Consider a class that uses the following variables to implement an array-based stack:
String [ ] s = new String[100];
Int top = 0;
A method that implements the String peek()operation can be written as
A) return s[top];
B) if (top == 0.
Throw new RuntimeException("Underflow".;
Else
Return s[top];
C) if (top == 0.
Throw new RuntimeException("Underflow".;
Else
Return s[top-1];
D) return s[top-1];

Accepted Answer

The method peek() should return the top element of the stack without removing it. Since the stack is array-based, the top element is stored at the index top-1 (since top represents the next available index). Therefore, option D is also a valid choice. However, options A and B return the top element at the current index (top), which is incorrect if the stack is not empty. Option C checks if the stack is empty before returning the top element at index top-1, which is the correct implementation for the peek() method.

Question 2

In a list implementation of a queue,the end of the list from which elements are removed is called
A) the front of the queue
B) the rear of the queue
C) the top of the queue
D) the bottom of the queue

Accepted Answer

In a queue, elements are removed from the front, which is the end of the list where dequeue operations occur.

Question 3

The stack pull operation
A) increases the capacity of a stack that is about to fill up
B) extracts one element from the stack and returns it
C) brings two stacks together and combines their elements
D) does not exist: There is no such stack operation

Accepted Answer

D

Question 4

The stack class provided by the Java Collections Framework
A) can be used to hold values of any type
B) can be used to create stacks of int
C) cannot be used to instantiate a stack of int,or of any primitive type
D) is not efficient,so its use is not recommended

Accepted Answer

The Stack class in Java Collections Framework is a generic class that cannot directly hold primitive types like int. Instead, you must use wrapper classes like Integer.

Question 5

In a list implementation of a stack,the end of the list at which elements are added and removed is called
A) the active end of the stack
B) the head of the stack
C) the top of the stack
D) the bottom of the stack

Accepted Answer

In a stack implemented using a list, the last element added to the list is placed at the end of the list, which is also the top of the stack. When an element is removed from the stack, it is removed from the top of the stack, or the end of the list. Therefore, the end of the list at which elements are added and removed is called the top of the stack.

Question 6

Compilers of modern programming languages support method calls and returns with an internal
A) priority queue
B) hash set
C) stack
D) queue

Accepted Answer

Method calls and returns are typically implemented using a stack data structure, known as the call stack. When a method is called, its return address (i.e., the location in the program where execution should resume after the method is done) and any method parameters are added to the top of the call stack. When the method is done, it pops its return address and parameters off the top of the stack and execution resumes at the return address. The call stack is important for supporting recursive function calls and nested method calls. While other data structures such as queues or hash sets could theoretically be used for method calls and returns, the stack is by far the most common and efficient choice.

Question 7

Consider a class that uses the following variables to implement an array-based stack:
String [ ] s = new String[100];
Int top = 0;
A method for adding an item x to the stack can be written as
A) s.add(top,x);
B) if (top == s.length.
Throw new RuntimeException("Overflow".;
Else
{
Top ++;
S[top] = x;
}
C) if (top < 0.throw new IndexOutBoundsException(.
S[top] = x;
Top ++;
D) if (top < s.length.
{
S[top] = x;
Top ++;
}
Else
Throw new RuntimeException("Overflow".;

Accepted Answer

The correct method checks if the stack is not full before adding an item. If there's space, it assigns the item to the current top position and then increments the top index.

Question 8

A queue is a container that allows elements to be stored and removed
A) in a last-in-first-out fashion
B) in a first-in-first-out fashion
C) in a first-in-last-out fashion
D) quickly and efficiently

Accepted Answer

A queue stores elements in a first-in-first-out (FIFO) fashion, meaning the first element added to the queue will be the first one removed.

Question 9

The stack empty operation
A) removes all elements from the stack
B) checks to see if there is at least one item on the stack
C) destroys the stack and creates a new empty one in its place
D) None of the above

Accepted Answer

The stack empty operation checks if the stack is empty, meaning it checks if there is at least one item on the stack.

Question 10

The JCF Stack class is used to instantiate a stack: Stack< Integer > intStack = new Stack< Integer >(); The statements Int k = 77; IntStack.push(k*k); Use the primitive type int instead of the wrapper type Integer.These statements A) cause a compile time error B) compile and execute correctly C) cause a ClassCastException D) None of the above

Accepted Answer

The statements will compile and execute correctly because Java performs autoboxing, which automatically converts int to Integer, when necessary. Therefore, k*k will be converted to a Integer object and pushed onto the stack without any issues.

Question 11

The stack push operation
A) is normally implemented through a hash set
B) removes and returns an item from the stack
C) returns the item at the top of the stack,but does not remove it
D) adds a single item to the stack

Accepted Answer

The stack push operation adds a single item to the stack.

Question 12

A stack is a container that allows elements to be stored and removed
A) in a last-in-first-out fashion
B) in a first-in-first-out fashion
C) last-in-last-out fashion
D) according to priority

Accepted Answer

A stack follows the last-in-first-out (LIFO) principle, where the most recently added element is the first one to be removed.

Question 13

In a list implementation of a queue,the end of the list at which elements are added is called
A) the front of the queue
B) the rear of the queue
C) the head of the queue
D) the bottom of the queue

Accepted Answer

In a queue implementation using a list, elements are added at the end of the list and removed from the front of the list. The end of the list where elements are added is referred to as the rear of the queue.

Question 14

A stream of cars going through a toll booth is an example of a
A) priority queue
B) hash set
C) stack
D) queue

Accepted Answer

A stream of cars going through a toll booth follows the first-in, first-out (FIFO) principle, where the first car to arrive at the booth is the first one to be served. This is the characteristic of a queue, where elements are inserted from one end and removed from the other end in a sequential manner. Therefore, the best choice for this scenario is option D, a queue.

Question 15

Consider a class that uses the following variables to implement an array-based stack:
String [ ] s = new String[100];
Int top = 0;
A method that implements the String pop()operation can be written as
A) if (top == 0)
Throw new RuntimeException("Underflow");
Top--;
String temp = s[top];
S[top] = null;
Return temp;
B) if (top == 0.
Throw new RuntimeException("Underflow".;
String temp = s[top];
Top--;
S[top] = null;
Return temp;
C) if (top == 0.
Throw new RuntimeException("Underflow".;
Return s[top-1];
Top --;
S[top] = null;
D) top--;
Return s[top];

Accepted Answer

Choice A is the best option because it includes a check for underflow (the stack being empty) and throws an exception in that case. It also sets the top element to null after it has been removed to prevent memory leaks. Choices B and C are similar but do not null out the top element after removal. Choice D does not have a check for underflow and will cause an error if the stack is empty.

Question 16

Consider a class that uses the following variables to implement an array-based stack:
String [ ] s = new String[100];
Int top = 0;
The boolean method to check for an empty stack can be written as:
A) return top;
B) if (top == 0.
Return true;
Else
Return false;
C) if (s == null.
Return true;
Else
Return false;
D) if
Return true;
Else
Return false;

Accepted Answer

Option B checks if the top variable (which indicates the index of the topmost element in the stack) is equal to zero, i.e., if the stack is empty. If top equals zero, the method returns true, otherwise, it returns false. This is the correct way to check for an empty stack.

Option A just returns the value of top, which isn't a boolean value and doesn't indicate whether the stack is empty.

Option C checks if the array itself is null, but this doesn't necessarily mean that the stack is empty.

Option D is incomplete and doesn't provide any logic to check for an empty stack.

Question 17

Consider a class that uses the following variables to implement an array-based stack:
String [ ] s = new String[100];
Int top = -1;//Note top == -1 indicates stack is empty
A method that implements a void push(String x)operation can be written as
A) if (top == s.length-1)
Throw new RuntimeException("Overflow");
Top ++;
S[top] = x;
B) if (top == s.length.
Throw new RuntimeException("Overflow".;
Top ++;
S[top] = x;
C) if (top == s.length-1.
Throw new RuntimeException("Overflow".;
S[top] = x;
Top ++;
D) if (top == s.length.
Throw new RuntimeException("Overflow".;
S[top] = x;
Top ++;

Accepted Answer

Choice A correctly checks if the stack is full before pushing the new element and throws an exception if it is. It then increments the top counter and adds the new element to the stack. Choices B, C, and D are incorrect as they either have a syntax error or do not properly check if the stack is full before pushing.

Question 18

The stack pop operation
A) removes all items currently on the stack
B) extracts one element from the stack and returns it
C) removes from the stack the number of elements specified by its integer parameter
D) does not exist: There is no such stack operation

Accepted Answer

The pop operation in a stack removes and returns the top element of the stack. It does not remove all the elements or a specific number of elements.

Question 19

In an array-based implementation of a stack,an operation that needs to add a new element to the stack may not be able to complete because the array is full.In this case,the failed operation should
A) print an error message and return from the method
B) throw some appropriately defined exception
C) print an error message and exit
D) alert the user before continuing execution

Accepted Answer

Throwing an appropriately defined exception is the best choice in this scenario. This allows the calling code to handle the exception appropriately, such as by resizing the array or taking some other action to resolve the issue. Printing an error message or alerting the user before continuing execution could lead to undefined behavior and exiting the program entirely is not necessary unless the error cannot be handled within the program.

Question 20

The stack peek operation
A) checks a stack to see if there are any elements in it
B) removes and returns an item from the stack
C) returns the item at the top of the stack,but does not remove it
D) adds a single item to the stack

Accepted Answer

The stack peek operation returns the item at the top of the stack but does not remove it. It is used to inspect the topmost element without removing it from the stack.

Quiz 21: Stacks and Queues

Consider a class that uses the following variables to implement an array-based stack: String [ ] s = new String[100]; Int top = 0; A method that implements the String peek() operation can be written as

In a list implementation of a queue,the end of the list from which elements are removed is called

The stack pull operation

The stack class provided by the Java Collections Framework

In a list implementation of a stack,the end of the list at which elements are added and removed is called

Compilers of modern programming languages support method calls and returns with an internal

Consider a class that uses the following variables to implement an array-based stack: String [ ] s = new String[100]; Int top = 0; A method for adding an item x to the stack can be written as

A queue is a container that allows elements to be stored and removed

The stack empty operation

The JCF Stack class is used to instantiate a stack: Stack< Integer > intStack = new Stack< Integer >() ; The statements Int k = 77; IntStack.push(k*k) ; Use the primitive type int instead of the wrapper type Integer.These statements

The stack push operation

A stack is a container that allows elements to be stored and removed

In a list implementation of a queue,the end of the list at which elements are added is called

A stream of cars going through a toll booth is an example of a

Consider a class that uses the following variables to implement an array-based stack: String [ ] s = new String[100]; Int top = 0; A method that implements the String pop() operation can be written as

Consider a class that uses the following variables to implement an array-based stack: String [ ] s = new String[100]; Int top = 0; The boolean method to check for an empty stack can be written as:

Consider a class that uses the following variables to implement an array-based stack: String [ ] s = new String[100]; Int top = -1;//Note top == -1 indicates stack is empty A method that implements a void push(String x) operation can be written as

The stack pop operation

In an array-based implementation of a stack,an operation that needs to add a new element to the stack may not be able to complete because the array is full.In this case,the failed operation should

The stack peek operation