NAME KAPADIA NARAYAN HEMANTKUMAR

ROLL NO. 2314518157

PROGRAM MCA
SEMESTER 2
COURSE NAME ADVANCED DATA STRUCTURES
COURSE CODE DCA6202
Set – I

Question: 1

a. Explain different types of data structures in detail

Answer:

Data structures are essential for organizing, managing, and retrieving data efficiently in computer science and
software development. Here are the main types:

1. Arrays: Arrays store elements in contiguous memory locations, accessible via indices. They have a fixed size
and are ideal for storing multiple values of the same type efficiently.

2. Linked Lists: Linked lists consist of nodes, each containing data and a reference to the next node. Variants
include singly linked lists, doubly linked lists, and circular linked lists. They support dynamic memory
allocation and efficient insertions and deletions.

3. Stacks: Stacks operate on the Last In, First Out (LIFO) principle, with primary operations being push (insert)
and pop (remove). They are useful in recursive algorithms, expression evaluation, and backtracking.

4. Queues: Queues follow the First In, First Out (FIFO) principle, with operations including enqueue (insert) and
dequeue (remove). Variants include simple queues, circular queues, and priority queues. They are used in
scheduling, buffering, and breadth-first search algorithms.

5. Trees: Trees are hierarchical structures with a root node and child nodes. Types include binary trees, binary
search trees (BST), AVL trees, and B-trees. They enable efficient searching, sorting, and hierarchical data
representation.

6. Graphs: Graphs consist of nodes (vertices) and edges (connections). Types include directed, undirected,
weighted, and unweighted graphs. They are used to model relationships in networking, social networks, and
pathfinding algorithms.

7. Hash Tables: Hash tables use hash functions to map keys to values for fast data retrieval. They support
efficient insertions, deletions, and lookups, making them ideal for implementing associative arrays and
databases.

b. What do you understand by complexity of algorithm?

Answer:

Algorithm complexity refers to the evaluation of an algorithm's efficiency in terms of the time and space it requires.
This is a key aspect of algorithm design and analysis, influencing the performance and scalability of software
solutions.

1. Time Complexity: Time complexity assesses how long an algorithm takes to complete as a function of the
input size (n). It helps predict the algorithm's performance and is typically expressed using Big O notation,
 such as O(1), O(n), O(log n), O(n^2), etc. This notation represents the number of fundamental operations or
steps the algorithm executes.

2. Space Complexity: Space complexity evaluates the amount of memory an algorithm needs relative to the
input size. This includes memory for input data, auxiliary data structures, and the call stack for recursive
algorithms. Space complexity is also denoted using Big O notation, like O(1), O(n), O(n^2), etc.

Understanding algorithm complexity is essential for choosing the right algorithm for a specific problem, especially in
large-scale applications. It guides in making informed decisions to balance execution speed and memory usage,
ensuring the algorithm operates efficiently under various conditions. Optimizing complexity can lead to significant
enhancements in the overall performance and responsiveness of software systems.

Question: 2

What is linked list? Explain different types of linked list.

Answer:

A linked list is a basic data structure that represents a sequence of elements, known as nodes. Each node contains
data and a reference (or pointer) to the next node in the sequence. Unlike arrays, linked lists do not require
contiguous memory locations, making insertion and deletion operations more efficient, especially with dynamic
datasets.

Types of Linked Lists

1. Singly Linked List:

• Structure: Each node in a singly linked list has two parts: the data and a reference to the next node. The
first node is called the head, and the last node, which points to null, is called the tail.
• Characteristics: Singly linked lists allow traversal in one direction—from the head to the tail. Insertion and
deletion at the beginning of the list are efficient (O(1)), but these operations at the end or in the middle
require traversal from the head, resulting in O(n) complexity.
• Use Cases: These lists are used in scenarios where memory is limited, and elements are frequently
inserted or deleted from the front, such as in stacks, adjacency lists of graphs, and hash tables.

2. Doubly Linked List:

• Structure: Each node in a doubly linked list contains three parts: the data, a reference to the next node,
and a reference to the previous node. This allows for bidirectional traversal.
• Characteristics: Doubly linked lists support traversal in both directions, making insertion and deletion
more flexible, especially when the position of the element is known. However, they require extra memory
for the additional pointer.
• Use Cases: These lists are ideal for applications needing bidirectional traversal, such as navigation
systems (e.g., browser history) and scenarios where frequent insertion and deletion at both ends are
necessary, like in dequeues (double-ended queues).

3. Circular Linked List:

• Structure: In a circular linked list, the last node points back to the first node, forming a circular structure.
They can be either singly or doubly linked.
• Characteristics: Circular linked lists lack null references at the end, enabling potentially infinite traversal.
This necessitates additional logic to determine the end of a traversal. They are useful for applications
requiring circular traversal of elements.
 • Use Cases: Circular linked lists are employed in circular queues, round-robin scheduling in operating
systems, and applications needing circular data traversal, such as in multiplayer games to manage player
turns.

4. Skip List:
• Structure: Skip lists are layered linked lists with each level being a sorted linked list pointing to elements
further down the list, facilitating efficient searching, insertion, and deletion.
• Characteristics: Skip lists have multiple layers of linked lists, with each upper layer skipping a fixed
number of elements, reducing the search time complexity to O (log n) on average.
• Use Cases: They are used in applications requiring fast search times, such as databases and in-memory
storage systems like Redis.

Conclusion

Linked lists are versatile and efficient data structures, particularly useful for applications requiring dynamic memory
allocation and frequent insertions and deletions. Each type of linked list has distinct characteristics and use cases,
making them suitable for various applications. By understanding the strengths and weaknesses of each type,
developers can select the most appropriate linked list implementation for their specific needs.

Question:3

a. Discuss PUSH and POP operations of STACK in detail.

Answer:

A stack operates on the Last In, First Out (LIFO) principle and supports two fundamental operations: PUSH and POP.

PUSH Operation

PUSH adds an element onto the top of the stack:

1. Process:
• Check if the stack is full; if so, a stack overflow occurs.
• If space is available, increment the top pointer and place the new element at that position.

2. Example:
• Starting with an empty stack: [].
• PUSH 5: ` [5] `.
• PUSH 10: ` [5, 10] `.
• PUSH 15: ` [5, 10, 15] `.

POP Operation

POP removes the top element from the stack:

a. Process:
• Check if the stack is empty; if so, a stack underflow occurs.
• If elements are present, retrieve the element at the top pointer and decrement the top pointer.

b. Example:
• Stack ` [5, 10, 15] `.
• POP removes 15: ` [5, 10] `.
• POP removes 10: ` [5] `.
 • POP removes 5: ` [] ` (empty stack).

Characteristics and Applications

• Characteristics:
o Both operations have a constant time complexity of O(1).
o Stacks can be implemented using arrays or linked lists.

• Applications:
o Function Call Management: Stacks manage function calls and local variables in programming.
o Expression Evaluation: Used to evaluate postfix and prefix expressions.
o Undo Mechanisms: Implementing undo features in applications by storing previous states.

Understanding PUSH and POP operations is crucial for effectively using stacks in various programming tasks and
applications, ensuring efficient data management and manipulation.

b. What is AVL tree? How it is different from BST?

Answer:

An AVL tree is a type of self-balancing binary search tree (BST) named after its creators, Adelson-Velsky and
Landis. Unlike regular BSTs, AVL trees enforce a balance condition where the heights of the left and right
subtrees of any node differ by at most one level. This balance is maintained through rotations during insertion and
deletion operations.

Differences from BST:

1. Balancing Requirement: While BSTs do not impose any specific balance requirements, AVL trees ensure
that the height difference (balance factor) between left and right subtrees of each node is no more than one.
2. Insertion and Deletion: AVL trees use rotations (single or double) to maintain balance after insertions and
deletions. In contrast, regular BSTs may become unbalanced, leading to degraded performance in search
operations.
3. Performance: AVL trees typically offer faster search operations compared to unbalanced BSTs because
their balanced structure ensures logarithmic time complexity (O(log n)) for search, insert, and delete
operations.
4. Applications: AVL trees are preferred in scenarios where consistent and efficient search times are critical,
such as in databases, compilers, and other applications where data needs to be dynamically managed and
accessed.

In essence, AVL trees enhance the performance of basic BST operations by ensuring balanced height distributions,
thus optimizing search efficiency while maintaining structural integrity through systematic rebalancing.

Set - II

Question:4

Explain difference between linear and binary search with example.

Answer:
Linear Search

Definition: Linear search, also called sequential search, is a straightforward algorithm that examines each element
in a list one by one until the desired element is found or the end of the list is reached.

Algorithm:

1. Start at the first element.

2. Compare the target value with the current element.
3. If they match, return the index.
4. If not, move to the next element.
5. Repeat until the target is found or the list ends.
6. If the end is reached without finding the target, return an indication that the target is not in the list (e.g., -1).

Example: Given the list: [3, 8, 1, 7, 4, 9, 5]

• Target value: 7
• Steps:
o Compare 7 with 3 (not a match, move to next)
o Compare 7 with 8 (not a match, move to next)
o Compare 7 with 1 (not a match, move to next)
o Compare 7 with 7 (match found at index 3)
• Result: Target value 7 is found at index 3.

Complexity:

• Time Complexity: O(n), where n is the number of elements. In the worst case, every element is checked.
• Space Complexity: O(1), requiring no extra space.

Binary Search

Definition: Binary search is an efficient algorithm that works on sorted lists. It repeatedly divides the list in half,
comparing the target value to the middle element to narrow down the search interval.

Algorithm:

1. Set two pointers: one at the beginning (low) and one at the end (high) of the list.
2. Find the middle element.
3. Compare the target with the middle element.
4. If they match, return the index.
5. If the target is less than the middle element, search the left half.
6. If the target is greater, search the right half.
7. Repeat until the target is found or the interval is empty (low > high).
8. If the interval is empty, return an indication that the target is not in the list (e.g., -1).

Example: Given the sorted list: [1, 3, 4, 5, 7, 8, 9]

• Target value: 7
• Steps:
o Initial interval: low = 0, high = 6
o Middle element: index 3, value 5
o Compare 7 with 5 (7 > 5, search right half)
o New interval: low = 4, high = 6
 o Middle element: index 5, value 8
o Compare 7 with 8 (7 < 8, search left half)
o New interval: low = 4, high = 4
o Middle element: index 4, value 7
o Compare 7 with 7 (match found at index 4)
• Result: Target value 7 is found at index 4.

Complexity:

• Time Complexity: O(log n), where n is the number of elements. The search interval is halved with each
step.
• Space Complexity: O(1) for the iterative version and O(log n) for the recursive version due to the call
stack.

Comparison

1. Efficiency:
o Linear search is less efficient for large lists since it may check every element.
o Binary search is much more efficient for large, sorted lists due to its logarithmic time complexity.
2. Preconditions:
o Linear search can be used on unsorted lists.
o Binary search requires the list to be sorted.
3. Use Cases:
o Linear search is suitable for small or unsorted lists, or when sorting is not feasible.
o Binary search is ideal for large, sorted lists where fast searching is crucial.
4. Implementation Complexity:
o Linear search is simpler to implement.
o Binary search is more complex, requiring list sorting and careful interval management.

Question:5

What is external sorting? Explain in detail.

Answer:

External Sorting

Definition: External sorting refers to a set of algorithms designed to sort data that is too large to fit into a
computer's main memory (RAM). When data exceeds memory capacity, it must be stored on external storage
devices like hard drives or SSDs. External sorting algorithms efficiently manage this large-scale data, minimizing
disk accesses, which are significantly slower than in-memory operations.

Why External Sorting is Needed

In scenarios with vast data sets—such as large databases, data warehouses, or big data applications—traditional in-
memory sorting algorithms like QuickSort or MergeSort are impractical due to memory constraints. External
sorting allows these large data sets to be sorted effectively by using secondary storage.

Key Concepts

1. Block Access:
 o
Data is divided into blocks, optimizing read/write operations by reducing the number of disk
accesses compared to accessing data element by element.
o Block size is chosen to match the system’s memory and disk I/O capabilities.
2. Two-Phase Multiway Merge Sort:
o The most common external sorting algorithm, consisting of a sorting phase and a merging phase.

Phases of External Sorting

1. Sorting Phase:
o Initial Runs: The large data set is divided into manageable chunks that fit into memory. Each
chunk is read into memory, sorted using an in-memory sorting algorithm, and then written back to
disk as a sorted run.
o Example: For 1 TB of data with 100 MB of memory, divide the data into 10,000 chunks of 100
MB each. Sort each chunk in memory and write it back to disk, resulting in 10,000 sorted runs.
2. Merging Phase:
o Multiway Merge: Sorted runs are merged to produce a single sorted output. Multiple passes are
made if necessary, with each pass reducing the number of runs until only one remains.
o K-Way Merge: During each pass, a k-way merge is performed, where k is the number of runs that
can be processed in memory simultaneously.
o Example: If memory allows merging 100 runs at a time, merge the 10,000 runs in multiple passes.
The first pass merges 100 runs into 100 larger runs. The next pass merges these into one final
sorted run.

Optimizations

1. Replacement Selection:
o Uses a priority queue to generate longer initial runs by selecting the smallest element and replacing
it with the next element from the unsorted data. This can create runs longer than the memory size.
2. Polyphase Merge:
o Minimizes I/O operations by distributing data unevenly across multiple tapes or files, ensuring
productive merge steps.

Applications

1. Database Management Systems (DBMS):

o Essential for query processing, particularly for operations like ORDER BY, GROUP BY, and
joining large tables.
2. Big Data Processing:
o Used in frameworks like Hadoop and Spark for efficient processing of massive data sets.
3. File Systems:
o Used to sort large log files or data files before processing.

Conclusion

External sorting is vital for handling and sorting large data sets that exceed main memory capacity. By efficiently
utilizing secondary storage and optimizing disk access, external sorting algorithms enable sorting of even the
largest data sets in a reasonable time frame, making them essential in many data-intensive applications.

Question:6

Explain collision resolution methods in detail.

Answer:

Collision Resolution Methods

In hash tables, collisions occur when two keys hash to the same index. Efficient collision resolution is crucial to
maintain the performance of hash tables. There are several methods to handle collisions, including open
addressing, chaining, and more advanced techniques. Below, these methods are explained in detail.

1. Open Addressing

Open addressing resolves collisions by searching for another available slot within the hash table. Several strategies
exist within open addressing:

• Linear Probing:
o Upon collision, the algorithm checks the next slot in a sequential manner until an empty slot is
found.
o Example: If index 5 is occupied, it checks index 6, then 7, and so on.
o Pros: Simple to implement.
o Cons: Can cause clustering, leading to performance degradation.
• Quadratic Probing:
o Upon collision, the algorithm checks slots at increasing quadratic intervals from the original hash
index (e.g., h(k),h(k)+12,h(k)+22h(k), h(k) + 1^2, h(k) + 2^2h(k),h(k)+12,h(k)+22, etc.).
o Example: If index 5 is occupied, it checks index 6, then 9 (5 + 2^2), and so forth.
o Pros: Reduces clustering compared to linear probing.
o Cons: May still result in secondary clustering.
• Double Hashing:
o Uses a secondary hash function to determine the step size for resolving collisions.
o Example: h(k)=(h1(k)+i∗h2(k))%mh(k) = (h1(k) + i * h2(k)) \% mh(k)=(h1(k)+i∗h2(k))%m, where
h1h1h1 and h2h2h2 are two hash functions and iii is the iteration count.
o Pros: Minimizes clustering and provides better distribution of keys.
o Cons: More complex to implement.

2. Chaining

Chaining handles collisions by storing multiple elements at the same index using a data structure like a linked list
or a tree.

• Separate Chaining:
o Each index in the hash table points to a linked list (or another data structure) containing all
elements that hash to that index.
o Example: If two keys hash to index 5, both are stored in a linked list at that index.
o Pros: Simple and easy to implement, with no limit on the number of elements.
o Cons: Requires additional memory for pointers. Performance can degrade if many elements hash to
the same index.

3. Other Methods

• Coalesced Hashing:
o Combines open addressing and chaining within the hash table array. If a collision occurs, the
colliding element is placed in the next available slot, forming a linked list within the table.
o Pros: Efficient memory usage compared to separate chaining.
o Cons: More complex than simple chaining or probing methods.
• Robin Hood Hashing:
 o A variant of open addressing where elements are placed to balance probe lengths across the table. If
a new element collides, it can displace an existing element if the new element has probed fewer
slots than the existing element.
o Pros: Provides better average-case performance by balancing probe lengths.
o Cons: Complex to implement and manage.

Choosing a Collision Resolution Method

The choice of collision resolution method depends on several factors, including:

• Load Factor: Higher load factors require more efficient collision resolution methods to maintain
performance.
• Memory Usage: Methods like separate chaining need extra memory for pointers, whereas open addressing
uses the hash table array itself.
• Ease of Implementation: Simpler methods like linear probing are easier to implement but may suffer from
performance issues.
• Performance Requirements: Applications requiring high performance may benefit from more
sophisticated methods like double hashing or Robin Hood hashing.

Conclusion

Collision resolution is a vital aspect of hash table implementation. Each method has its strengths and weaknesses,
and the best choice depends on the specific requirements and constraints of the application. By understanding and
selecting the appropriate collision resolution technique, one can ensure efficient and reliable performance of hash
tables in various use cases.