Stack Data Structure

Which of the following describes the Last In, First Out (LIFO) principle of a stack?

Which operation adds an element to the top of a stack?

What does the peek operation do in a stack?

Which of the following is a key advantage of using a linked list for stack implementation compared to an array?

What is a primary disadvantage of using arrays to implement stacks?

In the context of stack operations, what does the isEmpty function typically check?

Which of the following scenarios is best suited for using a stack data structure?

In a stack implemented using a linked list, where is the new element added?

How does implementing a stack with a linked list affect memory usage compared to using an array?

If a stack is implemented using an array and the array is full, what action should be taken when a push operation is attempted?

Consider a stack implemented using an array with a maximum capacity of 5. If the stack currently has 3 elements, how many more push operations can be performed before a stack overflow might occur, assuming no resizing?

What might be the result of calling pop() on an empty stack?

In the given Python code:

stack = []
stack.append('A')
stack.append('B')
stack.pop()
print(stack[-1])

What will be printed?

You have a stack with elements [1, 2, 3], where 3 is the top element. After performing stack.push(4) and then stack.pop(), what element will stack.peek() return?

Which of the following is NOT a typical application of stacks in computer science?

In implementing a stack with a linked list, what happens to the size attribute when the pop operation is successfully performed?

Consider this code:

class Stack:
    def __init__(self):
        self.items = []

    def push(self, item):
        self.items.append(item)

    def is_empty(self):
        return len(self.items) == 0

stack = Stack()
print(stack.is_empty())
stack.push(1)
print(stack.is_empty())

What is the output?

When should you prefer a stack implemented with arrays over a stack implemented with linked lists?

In a stack implemented with a linked list, what happens to the head pointer when pop() is called on the last element in the stack?

A stack is used to evaluate the expression $5 + (8 - 2) * 4$. After processing the expression and before performing the final addition, what will be the top two elements on the stack?