Get to explore about stack data structure and different types of LinkedList.

1. Data Structure Interview Questions
What are different operations available in stack data structure?
In a stack data structure, several operations are available to manage and manipulate the
elements within it. A stack follows the Last-In-First-Out (LIFO) principle, where the last
element added to the stack is the first one to be removed. Let's explore these operations in
more detail:
Push: The push operation adds an element to the top of the stack. It involves two steps:
allocating memory for the new element and updating the stack's top pointer to point to the
new element. This operation has a time complexity of O(1) since it takes a constant amount
of time, regardless of the stack's size.
Pop: The pop operation removes and returns the topmost element from the stack. It involves
updating the stack's top pointer to point to the next element in the stack and deallocating the
memory occupied by the removed element. Similar to the push operation, pop also has a
time complexity of O(1) since it only requires a constant amount of time.
Peek/Top: The peek or top operation allows you to retrieve the topmost element from the
stack without removing it. It returns the value of the element pointed to by the top pointer.
This operation is useful when you need to access the top element's value but do not want to
modify the stack. Like push and pop, peek has a time complexity of O(1).
isEmpty: The isEmpty operation checks whether the stack is empty or not. It returns a
Boolean value, true if the stack is empty and false otherwise. It can be implemented by
checking if the stack's top pointer is null or not. The time complexity of isEmpty is also O(1)
since it requires a constant amount of time to perform the check.
isFull: The isFull operation is applicable to fixed-size stacks. It checks whether the stack is
full, meaning it has reached its maximum capacity, and no more elements can be added.
This operation is typically used in scenarios where the stack has a predetermined size. It can
be implemented by comparing the current number of elements in the stack with its maximum
capacity. The time complexity of isFull is O(1).
Size: The size operation returns the current number of elements present in the stack. It
involves traversing the stack from top to bottom and counting the elements. The time
complexity of the size operation is O(n), where n is the number of elements in the stack.
Clear: The clear operation removes all the elements from the stack, leaving it empty. It
typically involves deallocating the memory occupied by each element in the stack and setting
the top pointer to null. The time complexity of the clear operation is O(n), where n is the
number of elements in the stack.

2. Search: The search operation allows you to find the position of a specific element within the
stack. It starts from the top of the stack and iterates until the element is found or the end of
the stack is reached. The position is returned as an index, with the top element being at
index 1. If the element is not found, the operation returns -1. The time complexity of the
search operation is O(n), where n is the number of elements in the stack.
These operations provide the basic functionality to manage and utilize a stack data structure.
They allow you to add and remove elements, check the stack's status, access elements, and
perform various other operations based on the LIFO principle. Stacks are widely used in
many applications, including expression evaluation, function call stack management, undo
mechanisms, and more.
What are the different types of Linked Lists?
Linked lists are a type of data structure where elements, known as nodes, are connected via
pointers. Each node contains data and a reference to the next node in the list. There are
several variations of linked lists, each with its own characteristics and uses. Let's explore the
different types of linked lists:
Singly Linked List: In a singly linked list, each node has a data field and a single pointer to
the next node. The last node points to null, indicating the end of the list. This type of linked
list allows traversal only in one direction, from the head (the first node) to the tail (the last
node). Insertion and deletion at the beginning of the list have a time complexity of O(1), while
operations at the end or middle require traversing the list, resulting in a time complexity of
O(n).
Doubly Linked List: A doubly linked list extends the singly linked list by including an
additional pointer in each node that points to the previous node. This enables traversal in
both directions, providing more flexibility. Doubly linked lists allow for efficient insertion and
deletion at both the beginning and end of the list, as it involves updating the pointers of
adjacent nodes. However, they consume slightly more memory than singly linked lists due to
the extra pointer.
Circular Linked List: A circular linked list is a variation of a singly linked list where the last
node's next pointer points back to the first node, creating a loop. This circular structure
allows traversal from any node to any other node in the list. Circular linked lists are useful in
applications where continuous looping is required, such as implementing a round-robin
scheduling algorithm. Caution must be exercised to ensure proper termination conditions to
prevent infinite loops.
Doubly Circular Linked List: The doubly circular linked list combines the properties of both
the doubly linked list and the circular linked list. Each node has a reference to both the next
and previous nodes, and the last node's next pointer points back to the first node, forming a
circular structure. This type of linked list enables bidirectional traversal and circular looping.
Skip List: A skip list is a more advanced variation of a linked list that incorporates multiple
layers of linked lists. Each layer acts as an express lane, allowing faster search operations.
The topmost layer contains all the elements, while subsequent layers contain a subset of the

3. elements. Skip lists provide efficient search, insertion, and deletion operations with an
average time complexity of O(log n), making them suitable for large-scale data sets.
However, they require additional memory to store the layers, which increases the space
complexity.
Self-Adjusting List: A self-adjusting list is designed to optimize search operations by
adapting its structure based on access patterns. When an element is accessed, it is moved
to the front of the list, improving future access time. This type of linked list aims to reduce
search time by exploiting temporal locality. However, self-adjusting lists may exhibit
performance degradation if the access pattern is not uniform.
XOR Linked List: An XOR linked list is an innovative variation that uses bitwise XOR
operations to store the XOR combination of the addresses of the previous and next nodes
instead of explicit pointers. This approach allows bidirectional traversal while reducing
memory usage by a factor of two compared to traditional doubly linked lists. However, XOR
linked lists require careful handling and can be more challenging to implement and maintain.
These are some of the commonly known types of linked lists, each offering unique
advantages and use cases. The choice of which type to use depends on the specific
requirements of your application, such as the need for bidirectional traversal, efficient search
operations, or memory constraints. By understanding the characteristics and trade-offs of
these linked list variations, you can select the most suitable one to optimize your data
structure.
Explore more DSA interview questions for your preparation.