Explore topic-wise MCQs in Technical Programming.

In case of insertion into a linked queue, a node borrowed from the __________ list is inserted in the queue.

 In linked list implementation of a queue, front and rear pointers are tracked. Which of these pointers will change during an insertion into EMPTY queue?

In linked list implementation of a queue, front and rear pointers are tracked. Which of these pointers will change during an insertion into a NONEMPTY queue?

In linked list implementation of a queue, where does a new element be inserted?

In linked list implementation of queue, if only front pointer is maintained, which of the following operation take worst case linear time?

What is the output of the following piece of code?

public class CircularQueue
{
	protected static final int CAPACITY = 100;
	protected int size,front,rear;
	protected Object q[];
	int count = 0;
 
	public CircularQueue()
	{
		this(CAPACITY);
	}
	public CircularQueue (int n)
	{
		size = n;
		front = 0;
		rear = 0;
		q = new Object[size];
	}
 
 
	public void enqueue(Object item)
	{
		if(count == size)
		{
			System.out.println("Queue overflow");
				return;
		}
		else
		{
			q[rear] = item;
			rear = (rear+1)%size;
			count++;
		}
	}
	public Object dequeue()
	{
		if(count == 0)
		{
			System.out.println("Queue underflow");
			return 0;
		}
		else
		{
			Object ele = q[front];
			q[front] = null;
			front = (front+1)%size;
			count--;
			return ele;
		}
	}
	public Object frontElement()
	{
		if(count == 0)
		return -999;
		else
		{
			Object high;
			high = q[front];
			return high;
		}
	}
	public Object rearElement()
	{
		if(count == 0)
		return -999;
		else
		{
			Object low;
			rear = (rear-1)%size;
			low = q[rear];
			rear = (rear+1)%size;
			return low;
		}
	}
}
public class CircularQueueDemo
{
	public static void main(String args[])
	{
		Object var;
		CircularQueue myQ = new CircularQueue();
		myQ.enqueue(10);
		myQ.enqueue(3);
		var = myQ.rearElement();
		myQ.dequeue();
		myQ.enqueue(6);
		var = mQ.frontElement();
		System.out.println(var+" "+var);
	}
}

What is the space complexity of a linear queue having n elements?

What is the need for a circular queue?

What does the following piece of code do?

public Object function()
{
	if(isEmpty())
	return -999;
	else
	{
		Object high;
		high = q[front];
		return high;
	}
}

 What is the time complexity of enqueue operation?

What is the term for inserting into a full queue known as?

 In a circular queue, how do you increment the rear end of the queue?

 Which of the following properties is associated with a queue?

Minimum number of queues to implement stack is __________

Which of the following data structures can be used for parentheses matching?

Consider these functions:
push() : push an element into the stack
pop() : pop the top-of-the-stack element
top() : returns the item stored in top-of-the-stack-node
What will be the output after performing these sequence of operations

push(20);
push(4);
top();
pop();
pop();
pop();
push(5);
top();

What does ‘stack overflow’ refer to?

Which of the following statements are correct with respect to Singly Linked List(SLL) and Doubly Linked List(DLL)?

What is the complexity of searching for a particular element in a Singly Linked List?

Which of the following array element will return the top-of-the-stack-element for a stack of size N elements(capacity of stack > N).

Array implementation of Stack is not dynamic’, which of the following statements supports this argument?

What happens when you pop from an empty stack while implementing using the Stack ADT in Java?

Which of the following array position will be occupied by a new element being pushed for a stack of size N elements(capacity of stack > N).

What is the time complexity of pop() operation when the stack is implemented using an array?

What is the output of the following program?

public class Stack
{
	protected static final int CAPACITY = 100;
	protected int size,top = -1;
	protected Object stk[];
 
	public Stack()
	{
		stk = new Object[CAPACITY];
	}
 
	public void push(Object item)
	{
		if(size_of_stack==size)
		{
			System.out.println("Stack overflow");
				return;
		}
		else
		{
			top++;
			stk[top]=item;
		}
	}
	public Object pop()
	{
		if(top<0)
		{
			return -999;
		}
		else
		{
			Object ele=stk[top];
			top--;
			size_of_stack--;
			return ele;
		}
	}
}
 
public class StackDemo
{
	public static void main(String args[])
	{
		Stack myStack = new Stack();
		myStack.push(10);
		Object element1 = myStack.pop();
		Object element2 = myStack.pop();
		System.out.println(element2);
	}
}

What does ‘stack underflow’ refer to?

What does the following function check for? (all necessary headers to be included and function is called from main)

   #define MAX 10
 
   typedef struct stack
   {
        int top;
	int item[MAX];
   }stack;
 
   int function(stack *s)
   {
        if(s->top == -1)
	    return 1;
	 else return 0;
   }

Which of the following real world scenarios would you associate with a stack data structure?

Consider a small circular linked list. How to detect the presence of cycles in this list effectively?

 Which of the following is false about a circular linked list?

What is the functionality of the following code? Choose the most appropriate answer.

public int function()
{
	if(head == null)
		return Integer.MIN_VALUE;
	int var;
	Node temp = head;
	Node cur;
	while(temp.getNext() != head)
	{
		cur = temp;
		temp = temp.getNext();
	}
	if(temp == head)
	{
		var = head.getItem();
		head = null;
		return var;
	}
	var = temp.getItem();
	cur.setNext(head);
	return var;
}

Which of the following application makes use of a circular linked list?

What is the time complexity of searching for an element in a circular linked list?

What differentiates a circular linked list from a normal linked list?

Consider the following doubly linked list: head-1-2-3-4-5-tail
What will be the list after performing the given sequence of operations?

	Node temp = new Node(6,head,head.getNext());
	head.setNext(temp);
	temp.getNext().setPrev(temp);
	Node temp1 = tail.getPrev();
	tail.setPrev(temp1.getPrev());
	temp1.getPrev().setNext(tail);

What is the functionality of the following piece of code?

public int function()
{
	Node temp = tail.getPrev();
	tail.setPrev(temp.getPrev());
	temp.getPrev().setNext(tail);
	size--;
	return temp.getItem();
}

Consider the following doubly linked list: head-1-2-3-4-5-tail
What will be the list after performing the given sequence of operations?

	Node temp = new Node(6,head,head.getNext());
	Node temp1 = new Node(0,tail.getPrev(),tail);
	head.setNext(temp);
	temp.getNext().setPrev(temp);
	tail.setPrev(temp1);
	temp1.getPrev().setNext(temp1);

What is the time complexity of inserting a node in a doubly linked list?

How do you calculate the pointer difference in a memory efficient double linked list?

 What is a memory efficient double linked list?

Which of the following is false about a doubly linked list?

Which of these is an application of linked lists?

What is the space complexity for deleting a linked list?

What is the time complexity to count the number of elements in the linked list?

What is the time complexity of inserting at the end in dynamic arrays?

Which of the following is not a disadvantage to the usage of array?

You are given pointers to first and last nodes of a singly linked list, which of the following operations are dependent on the length of the linked list?

Given pointer to a node X in a singly linked list. Only one pointer is given, pointer to head node is not given, can we delete the node X from given linked list?

 In the worst case, the number of comparisons needed to search a singly linked list of length n for a given element is

The following C function takes a single-linked list of integers as a parameter and rearranges the elements of the list.
The function is called with the list containing the integers 1, 2, 3, 4, 5, 6, 7 in the given order. What will be the contents of the list after the function completes execution?

struct node 
{
    int value;
    struct node *next;
};
void rearrange(struct node *list)
{
    struct node *p, * q;
    int temp;
    if ((!list) || !list->next) 
      return;
    p = list;
    q = list->next;
    while(q) 
    {
         temp = p->value;
         p->value = q->value;
         q->value = temp;
         p = q->next;
         q = p?p->next:0;
    }
}