C-3 (DSA)

1. What is data structure?

A data structure is a way of organizing and storing data to perform operations efficiently. It defines the
relationships and operations that can be performed on the data, facilitating efficient access, modification,
and retrieval of information. Common examples include arrays, linked lists, stacks, queues, trees, and
graphs.

2. Diff b/w

★Linear:

1. Data elements are arranged in a sequential manner, one after the other.
2. Elements can be accessed in a linear or sequential order.
3. It uses memory efficiently, and elements are stored in a contiguous block of memory.
4. Arrays, Linked Lists, Stacks, and Queues are common linear data structures.
5.Traversing or moving through elements involves visiting them one by one in a specific order.

Non linear:

1. Data elements are not organized sequentially; they have a hierarchical or interconnected
structure.
2. Elements can be accessed in a more random or non-sequential manner.
3. It may use memory less efficiently compared to linear structures as elements are not stored in a
contiguous block.
4. Trees and Graphs are common nonlinear data structures.
5. Traversing elements might involve navigating through different paths and branches, not
necessarily in a linear order.

★Primitive Data Structures:

1. Primitive data structures are basic and fundamental types of data that are directly operated
upon by the computer's hardware.
2. Common examples include integers, floating-point numbers, characters, and booleans.
3. They are used to store simple values and are the building blocks for more complex data
structures.
4. They have fixed sizes and are usually represented directly in machine memory.

Non-Primitive Data Structures:

1. Non-primitive data structures are more advanced and complex, constructed using primitive
data types as well as other non-primitive data structures.
2. Arrays, linked lists, stacks, queues, trees, and graphs are common non-primitive data structures.
3. They are designed to organize and manage collections of data, offering more flexibility and
functionality than primitive types alone.
 4. Their size is dynamic and may vary based on the amount of data they contain.

★Static Data Structures:

1. In static data structures, memory allocation is fixed and predetermined during compile-time.
2. The size of the data structure is constant and doesn't change during program execution.
3. Arrays are a common example of a static data structure. Once an array is declared, its size is
fixed, and it cannot be easily changed.
4. Static data structures can be more memory-efficient in terms of storage because the size is
known in advance.

Dynamic Data Structures:

1. In dynamic data structures, memory is allocated during runtime, and the size can be adjusted
as needed.
2. The size of the data structure can change dynamically based on the program's requirements.
3. Linked lists, stacks, queues, trees, and dynamic arrays (like Array List in Java) are examples of
dynamic data structures.
4. Dynamic data structures provide more flexibility as they can grow or shrink based on the data
being processed.
5. While dynamic data structures offer flexibility, they may involve more overhead due to dynamic
memory allocation and deallocation.

★Linear Queue:

1. In a linear queue, elements are arranged in a straight line, and the queue has a front and a rear.
2. It can suffer from overflow (when trying to enqueue in a full queue) and underflow (when
trying to dequeue from an empty queue) conditions.
3. Enqueue (adding an element to the rear) and dequeue (removing an element from the front)
operations follow a linear order.
4. Memory for a linear queue is allocated in a linear or sequential manner.

Circular Queue:

1. In a circular queue, the last element is connected to the first element, forming a circle.
2. Circular queues efficiently handle overflow and underflow conditions. When the rear reaches
the end, it can wrap around to the front.
3. Enqueue and dequeue operations are performed in a circular fashion, and they wrap around
the queue if needed.
4. Memory is allocated in a circular manner, allowing efficient use of space.

3. Perform the PUSH, POP algorithm in stock

 # Initialize an empty stock (stack)
stock = []

# Function to perform PUSH operation

def push_to_stock(item):
stock.append(item)
print(f"Pushed {item} to the stock. Stock after PUSH: {stock}")

# Function to perform POP operation

def pop_from_stock():
if not stock:
print("Error: Stock is empty. Cannot POP.")
return None popped_item = stock.pop()
print(f"Popped {popped_item} from the stock. Stock after POP: {stock}")
return popped_item

# Example usage:
push_to_stock("Apple")
push_to_stock("Banana")
push_to_stock("Orange")

popped_item = pop_from_stock()

output:

Pushed Apple to the stock. Stock after PUSH: ['Apple']

Pushed Banana to the stock. Stock after PUSH: ['Apple', 'Banana']
Pushed Orange to the stock. Stock after PUSH: ['Apple', 'Banana', 'Orange']
Popped Orange from the stock. Stock after POP: ['Apple', 'Banana']

4. what is asymptotic natation and how to find the time complexity in best, worth, average case??
Asymptotic notation is a mathematical notation used to describe the limiting behavior of a function as
its input approaches infinity. It is commonly used in the analysis of algorithms to express the upper and
lower bounds on the running time or space complexity.

To find the time complexity in the best, worst, and average cases, We typically follow these steps:

1. Best Case:
• Identify the scenario where your algorithm performs optimally.
• Analyze the number of basic operations or steps required in this best-case scenario.
• Express the best-case time complexity using Omega (Ω) notation.
2. Worst Case:
• Identify the scenario where your algorithm performs the least optimally.
• Analyze the number of basic operations or steps required in this worst-case scenario.
• Express the worst-case time complexity using Big O (O) notation.
3. Average Case:
 • Analyze the average number of basic operations or steps required over all possible
inputs.
• Express the average-case time complexity using Theta (Θ) notation.
5. what is deque and explain the type of deque??

A deque, short for double-ended queue, is a data structure that allows insertion and deletion of
elements from both ends – the front and the rear. It combines the features of a stack and a queue,
providing more flexibility in managing data.

There are two main types of deques based on how elements are added and removed:

1. Input-Restricted Deque (IRD):

• In an input-restricted deque, elements can only be removed from both ends.
• It follows the First-In-First-Out (FIFO) principle for removal.
• Elements can be added at both ends.
• Useful when you want to maintain a queue-like structure with the ability to add
elements at both ends.
2. Output-Restricted Deque (ORD):
• In an output-restricted deque, elements can only be added at both ends.
• It follows the Last-In-First-Out (LIFO) principle for removal.
• Elements can be removed from both ends.
• Useful when you want to maintain a stack-like structure with the ability to remove
elements from both ends.

6. Explain the following stack application

1. Town of Hanoi
2. infix, postfix conversion using stack

1. Tower of Hanoi:

• Description: The Tower of Hanoi is a classic problem that involves moving a tower of discs
from one rod to another, subject to the constraint that a larger disc cannot be placed on top of
a smaller one.
• Stack Application: The Tower of Hanoi is often solved using a recursive algorithm that mimics
the behavior of a stack. Each recursive call corresponds to moving a sub-tower. The stack
stores the state of each recursive call, helping in the systematic movement of discs.

2. Infix to Postfix Conversion using Stack:

• Description: Infix notation is the standard mathematical notation where operators are placed
between operands (e.g., 2 + 3). Postfix (or Reverse Polish Notation) is an alternative notation
where operators follow their operands (e.g., 2 3 +).
• Stack Application: Converting infix to postfix involves using a stack to keep track of operators
and ensuring the correct order of operations. The stack helps in managing the precedence of
 operators and handling parentheses effectively. The algorithm scans the infix expression, and
the stack ensures the proper ordering of operators during the conversion process.

7. what is linked list. the diff b/w array and linked-list & perform the following algorithms in single
linked-list.

a) insert node at start

b) insert node at specified

c) insert Node At end

d) delete start node

e) delete specified Node

f) delete node at end

A linked list is a linear data structure consisting of nodes, where each node contains data and a reference (or link)
to the next node in the sequence. It forms a chain-like structure, and the last node typically points to null,
indicating the end of the list. Unlike arrays, linked lists don't require contiguous memory, allowing for dynamic and
efficient memory allocation.

**Differences Between Array and Linked List: **

1. **Memory Allocation:**
- Array: Contiguous block of memory.
- Linked List: Non-contiguous nodes with each node having a reference to the next node.

2. **Size:**
- Array: Fixed size.
- Linked List: Dynamic size, can grow or shrink during runtime.

3. **Insertion and Deletion:**

- Array: Costly for insertions and deletions, especially in the middle.
- Linked List: Efficient for insertions and deletions at any position.

4. **Access Time:**
- Array: Direct access to elements using index.
- Linked List: Sequential access, requires traversal from the beginning.

**Algorithms for Single Linked List:**

a) **Insert Node at Start:**

- Create a new node.
- Set the new node's next pointer to the current head.
- Update the head to the new node.

b) **Insert Node at Specified Position:**

- Traverse the list to the specified position.
- Create a new node.
- Adjust pointers to insert the new node at the specified position.
c) **Insert Node at End:**
- Traverse to the last node.
- Create a new node.
- Set the next pointer of the last node to the new node.

d) **Delete Start Node:**

- Update the head to the next node of the current head.
- Optionally, free the memory of the removed node.

e) **Delete Specified Node:**

- Traverse to the specified node.
- Adjust pointers to bypass the specified node.
- Optionally, free the memory of the removed node.

f) **Delete Node at End:**

- Traverse to the second-to-last node.
- Update the next pointer to null, removing the last node.
- Optionally, free the memory of the removed node.

These algorithms take advantage of the dynamic nature of linked lists, making insertions and deletions efficient
compared to arrays.

8. Diff b/w single, double, and circular linked List.

**Single Linked List:**
- Each node contains data and a reference to the next node.
- Allows traversal in only one direction, from the head to the end.
- Requires less memory compared to double linked lists.
- Simple implementation and memory-efficient.

**Double Linked List:**

- Each node contains data, a reference to the next node, and a reference to the previous node.
- Allows traversal in both forward and backward directions.
- Requires more memory than a single linked list due to the additional previous pointers.
- Supports easy insertion and deletion at both ends.

**Circular Linked List:**

- Similar to a single linked list, but the last node points back to the first node, forming a circle.
- Allows continuous traversal in a loop.
- Requires more memory than a single linked list due to the circular reference.
- Useful in applications where continuous looping is necessary, such as in round-robin scheduling.

9. what is tree? explain BST and Traversal in tree using in order, pre order, post order.

A tree is a hierarchical data structure that consists of nodes connected by edges. It is widely used in computer
science to represent hierarchical relationships or structures. In a tree:

1. Each node has a value or data.

2. Nodes are connected by edges.
3. The topmost node is called the root.
4. Nodes with no children are called leaves.
5. Nodes with the same parent are called siblings.
6. The depth of a node is the length of the path from the root to that node.
7. The height of a tree is the length of the longest path to a leaf.

A Binary Search Tree (BST) is a special type of binary tree where each node has at most two children, and the key
(value) of each node is greater than or equal to the keys of all nodes in its left subtree and less than or equal to the
keys of all nodes in its right subtree. This property ensures efficient searching, insertion, and deletion operations.

Traversal in a tree refers to the process of visiting all the nodes in a specific order. There are three common ways to
traverse a binary tree:

1. **In-order traversal (LNR - Left, Node, Right):**

- Traverse the left subtree.
- Visit the node.
- Traverse the right subtree.

2. **Pre-order traversal (NLR - Node, Left, Right):**

- Visit the node.
- Traverse the left subtree.
- Traverse the right subtree.

3. **Post-order traversal (LRN - Left, Right, Node):**

- Traverse the left subtree.
- Traverse the right subtree.
- Visit the node.

These traversal methods are commonly used for various operations on binary trees, such as searching for a
specific node, printing the nodes in a specific order, or evaluating expressions represented by the tree.

Here's a simple example to illustrate these traversals:

```plaintext
4
/\
2 6
/\/\
1 35 7
```

- In-order traversal: 1, 2, 3, 4, 5, 6, 7
- Pre-order traversal: 4, 2, 1, 3, 6, 5, 7
- Post-order traversal: 1, 3, 2, 5, 7, 6, 4

10. construct tree using in order and pre order traversal result.

Constructing a binary tree using the in-order and pre-order traversals involves the following steps:
1. **Given:**
- In-order traversal: [D, B, E, A, F, C]
- Pre-order traversal: [A, B, D, E, C, F]

2. **Identify Root:**
- The first element in the pre-order traversal is the root of the tree.
- Root = A

3. **Split In-order:**
- Find the root in the in-order traversal. Elements to the left are part of the left subtree, and elements to the right
are part of the right subtree.
- In-order left subtree: [D, B, E]
- In-order right subtree: [F, C]

4. **Recursion:**
- Recursively repeat the process for the left and right subtrees using the remaining pre-order elements.
- For the left subtree:
- Pre-order: [B, D, E]
- In-order: [D, B, E]
- Root: B (first element in the new pre-order)
- Left subtree: [D], Right subtree: [E]
- For the right subtree:
- Pre-order: [C, F]
- In-order: [F, C]
- Root: C (first element in the new pre-order)
- Left subtree: [F]

5. **Construct the Tree:**

- Continue this process recursively until the tree is fully constructed.

The resulting binary tree for the given in-order and pre-order traversals is:

```plaintext
A
/\
B C
/\ \
D E F
```
11. what is threaded binary tree? explain the advantage with example?
A threaded binary tree is a binary tree with additional links, called threads, that connect some nodes to their in-
order successor or predecessor. These threads help in traversing the tree efficiently without using recursion or a
stack.

**Advantages of Threaded Binary Trees:**

1. **Efficient Traversal:**
- Threaded binary trees allow for quick in-order traversals without the need for recursive function calls or an
explicit stack.
 - This is particularly beneficial in scenarios where memory usage needs to be minimized.

2. **Space Efficiency:**
- Threads reduce the need for extra space that would be required for maintaining a stack during recursive
traversals.
- This can be crucial in resource-constrained environments or when dealing with large trees.

3. **Simplified Tree Operations:**

- The threads provide an alternative path for traversal, making it easier to perform operations like finding the next
or previous node in an in-order traversal.
- This simplifies the implementation of various tree-related algorithms.

**Example:**

Consider the following binary tree:

```plaintext
4
/\
2 6
/\/\
1 35 7
```

In a threaded binary tree, additional threads can be added to connect the in-order successor or predecessor of
each node.

For example, the threads can be represented as follows:

- Thread from 1 to 2 (in-order predecessor of 2).

- Thread from 3 to 4 (in-order predecessor of 4).
- Thread from 5 to 6 (in-order predecessor of 6).
- Thread from 7 to null (in-order successor of 7).

Now, with these threads, an in-order traversal can be done without using recursion or a stack. Starting from the
leftmost node (1) and following the threads, the traversal would be: 1, 2, 3, 4, 5, 6, 7.

12. what is graph. the diff b/w tree anad graph. how to represent graph ( adjust matrix and adjency list)

A graph is a data structure that consists of a set of nodes (vertices) and a set of edges connecting these nodes.
Nodes represent entities, and edges represent relationships or connections between these entities. Graphs are
widely used to model various relationships in real-world scenarios, such as social networks, transportation
systems, and dependencies between tasks.

**Differences Between Tree and Graph:**

1. **Hierarchy:**
- In a tree, each node has a parent (except for the root), and there is a clear hierarchical structure.
- In a graph, nodes and edges can be connected in a more flexible way, and there is no strict hierarchy.
2. **Acyclic vs. Cyclic:**
- Trees are acyclic structures, meaning there are no cycles (loops).
- Graphs can be cyclic (contain cycles) or acyclic, providing more flexibility in representing relationships.

3. **Root vs. No Root:**

- Trees have a distinct root node from which all other nodes are descended.
- Graphs do not necessarily have a root; they can be disconnected or have multiple components.

**Representation of a Graph:**

1. **Adjacency Matrix:**
- In an adjacency matrix, a 2D array is used to represent the graph.
- Rows and columns correspond to nodes, and the value at matrix[i][j] indicates whether there is an edge
between nodes i and j.
- Efficient for dense graphs but can be memory-intensive for sparse graphs.

**Example:**
```
012
+---------
0|0 1 1
1|1 0 1
2|1 1 0
```

2. **Adjacency List:**
- In an adjacency list, each node has a list of its neighbors.
- A list of lists or a dictionary is commonly used to represent the graph.
- Efficient for sparse graphs and consumes less memory compared to an adjacency matrix.

**Example:**
{
0: [1, 2],
1: [0, 2],
2: [0, 1]
}
13. The Diff B/W BFS and BFS.

DFS (Depth-First Search):

- DFS explores as far as possible along one branch before backtracking.
- Uses a stack to keep track of nodes, which can lead to higher memory usage in certain cases.
- May visit nodes in a non-linear order.
- Useful for tasks like topological sorting, connected components, and maze solving.

BFS (Breadth-First Search):

- BFS explores all the neighbors of a node before moving on to the next level of neighbors.
- Uses a queue to keep track of nodes, generally requiring more memory than DFS.
- Visits nodes level by level, moving outward from the starting node.
- Effective for finding the shortest path in unweighted graphs and for tasks like web crawling.
*DFS is like exploring a maze by going as deep as possible along one path before trying other paths. You might
backtrack when you hit a dead end.
*BFS is like searching for something in your house. You check all the rooms on one floor before moving to the next
floor, making sure you don't miss anything on the same level.

14. what is spanning tree. what is MST and Following algorithm to finding MST
a) prim's algorithm
b) Kruskal’s algorithm
c) Dijkstra’s algorithm
d) Floyd-warshall algorithm.

A spanning tree of a connected, undirected graph is a subgraph that is a tree and includes all the vertices of the
original graph. It essentially forms a tree that spans all the vertices of the graph without forming any cycles.

Minimum Spanning Tree (MST):

A minimum spanning tree of a connected, undirected graph is a spanning tree that has the minimum possible total
edge weight. There can be multiple minimum spanning trees for a given graph.

Algorithms for Finding Minimum Spanning Tree (MST):

a) Prim's Algorithm
- Start with an arbitrary vertex and grow the tree by adding the cheapest edge that connects a vertex in the tree to
a vertex outside the tree.
- Repeat this process until all vertices are included in the tree.
b) Kruskal's Algorithm:
- Sort all the edges in non-decreasing order of their weights.
- Iterate through the sorted edges and add each edge to the tree if it doesn't form a cycle with the edges already in
the tree.
- Repeat until the tree spans all vertices.
c) Dijkstra's Algorithm:
- Primarily used for finding the shortest path from a source vertex to all other vertices in a weighted graph.
- Not directly used for finding MST, but can be adapted to find a minimal spanning tree by repeatedly adding the
vertex with the smallest distance that is not already in the tree.
d) Floyd-Warshall Algorithm:
- Primarily used for all-pairs shortest path in a weighted graph.
- Not directly used for finding MST. It computes the shortest paths between all pairs of vertices, but it doesn't
directly produce a minimum spanning tree.