# Basics of Data Structures for Viva

## Module I: Introduction to Data Structures

1. **What is a data structure?**

- A way of organizing and storing data to perform operations efficiently.

2. **What is an Abstract Data Type (ADT)?**

- Logical description of data and operations, separate from implementation.

3. **Linear vs non-linear data structures:**

- Linear: Sequential (arrays, stacks, queues)

- Non-linear: Hierarchical (trees, graphs)

4. **Static vs dynamic data structures:**

- Static: Fixed size (arrays)

- Dynamic: Grows/shrinks (linked lists)

5. **Common operations:**

- Insertion, deletion, traversal, searching, sorting, updating

## Module II: Stack

1. **What is a stack?**

- LIFO (Last In First Out) linear data structure

- Push (add), Pop (remove), Peek/Top, IsEmpty, IsFull

3. **Implementation:**

- Array (with top pointer) or Linked List

4. **Applications:**

- Function calls, expression evaluation, undo operations

## Module III: Queue

1. **What is a queue?**

- FIFO (First In First Out) linear data structure

2. **Queue operations:**

- Enqueue (add), Dequeue (remove), Front, Rear, IsEmpty, IsFull

3. **Types:**

- Linear queue, Circular queue, Priority queue, Deque

4. **Applications:**

- Job scheduling, printer queues, CPU scheduling

## Module IV: Linked List

- Dynamic data structure with nodes containing data and pointer(s)

2. **Types:**

- Singly, Doubly, Circular, Circular Doubly

3. **Advantages over arrays:**

- Dynamic size, efficient insertions/deletions

## Module V: Tree

1. **What is a tree?**

- Hierarchical data structure with nodes

2. **Binary Search Tree (BST):**

- Left < Root < Right property for efficient searching

3. **Traversals:**

- Inorder (LNR), Preorder (NLR), Postorder (LRN)

## Module VI: Applications

1. **Stack applications:**

- Expression conversion/evaluation, parentheses checking

- Resource management, simulations

3. **Tree applications:**

- File systems, database indexing, Huffman coding

# Solutions to Above Questions

The images you've provided already contain detailed answers to all the viva questions about data
structures. Here's a summary of the solution approach:

1. **For definition questions:** Provide concise textbook definitions (as shown in the images)

2. **For comparison questions:** Highlight key differences (e.g., stack vs queue: LIFO vs FIFO)

3. **For implementation questions:** Describe the approach (e.g., array with top pointer for stack)

4. **For application questions:** Give practical examples (e.g., stack for undo operations)

5. **For operation questions:** List steps clearly (e.g., how to insert in BST: compare and recurse)

The answers in your images are comprehensive and suitable for viva preparation. Focus on
understanding these concepts rather than just memorizing them, as viva exams often involve follow-up
questions based on your initial answers.

Here are detailed solutions to the data structure viva questions from your uploaded images, organized
by module:
---

### **Module I: Introduction to Data Structures**

1. **What is a data structure?**

- *Solution:* A data structure is a specialized format for organizing, storing, and manipulating data to
enable efficient access and modification (e.g., arrays, linked lists).

2. **What is an Abstract Data Type (ADT)?**

- *Solution:* ADT defines a logical model for data and operations (e.g., `Stack` with `push/pop`)
without specifying implementation details.

3. **Linear vs. Non-linear data structures**

- *Solution:*

- **Linear:** Sequential arrangement (arrays, stacks).

- **Non-linear:** Hierarchical/tree-like (graphs, BSTs).

4. **Static vs. Dynamic data structures**

- *Solution:*

- **Static:** Fixed size (arrays).

- **Dynamic:** Resizable at runtime (linked lists).

---

### **Module II: Stack**

1. **Stack operations**
 - *Solution:*

- `Push`: Add to top.

- `Pop`: Remove from top.

- `Peek`: View top element.

- `isEmpty/IsFull`: Check capacity.

2. **Stack vs. Array**

- *Solution:* Stack is an ADT (LIFO logic); arrays can implement stacks.

3. **Stack overflow/underflow**

- *Solution:*

- **Overflow:** `Push` on full stack.

- **Underflow:** `Pop` on empty stack.

4. **Postfix evaluation**

- *Solution:*

```python

# Example: Evaluate "3 4 + 5 *"

stack = []

for token in expression.split():

if token.isdigit(): stack.append(int(token))

else:

b, a = stack.pop(), stack.pop()

stack.append(a + b if token == '+' else a * b) # Result: 35

```
---

### **Module III: Queue**

1. **Queue operations**

- *Solution:*

- `Enqueue`: Add to rear.

- `Dequeue`: Remove from front.

2. **Circular queue**

- *Solution:* Reuses empty spaces by wrapping around (avoids wasted space in linear queues).

3. **Priority Queue**

- *Solution:* Elements dequeued by priority (e.g., hospital triage).

---

### **Module IV: Linked List**

1. **Singly vs. Doubly Linked List**

- *Solution:*

- **Singly:** Nodes have `data + next` pointer.

- **Doubly:** Nodes have `data + next + prev` pointers.

2. **Reversing a Singly Linked List**

- *Solution:*
 ```python

prev, current = None, head

while current:

next_node = current.next

current.next = prev

prev, current = current, next_node

head = prev

```

---

### **Module V: Tree**

1. **BST Insertion**

- *Solution:*

```python

def insert(root, key):

if not root: return Node(key)

if key < root.val: root.left = insert(root.left, key)

else: root.right = insert(root.right, key)

return root

```

2. **Tree Traversals**

- *Solution:*

- **Inorder (LNR):** Sorted output in BST.

- **Postorder (LRN):** Root last.

---

### **Module VI: Applications**

1. **Stack in Parentheses Checking**

- *Solution:*

- Push `(` on stack, pop on `)`. Valid if stack empty at end.

2. **Huffman Coding**

- *Solution:* Tree built from character frequencies; frequent chars get shorter codes.

3. **BST vs. Array**

- *Solution:*

- **BST:** O(log n) search (if balanced).

- **Unsorted Array:** O(n) search.

---

### **Key Tips for Viva:**

1. **Definitions:** Use textbook language (e.g., "LIFO principle").

2. **Examples:** Relate to real-world apps (e.g., "Stack for undo/redo").

3. **Code Snippets:** Write pseudocode for algorithms (e.g., BST insertion).

4. **Comparisons:** Highlight trade-offs (e.g., "Arrays allow random access; linked lists allow dynamic
resizing").
The answers in your images are already comprehensive—practice explaining them concisely!