Module 4

Module 4
questions will be from dsa. answer to the point and if differences asked return in tabular form. first
half of the prompt will be question and second half will be hint for it. first answer it according to any
hint then continue with whatever is left to answer from the question. ALL PROGRAMS ASKED SHOUD
BE WRITTEN IN C AND ALGORITHMS IN STEPPS. BE CONCISE AND TO THE POINT
NO NEED TO GIVE TWO DIFFERENT ANSWER JUST ANSWER EVERYTHING TOGETHER
Got it! I'll follow this format for your DSA-related questions.
Examine and elaborate the worst case scenario for linear search.
Recall the linear search operation procedure. Try to judge the condition that might take this search
operation to consume maximum number of search matches.
Worst-Case Scenario for Linear Search:
Based on the Hint:
In linear search, the worst-case scenario occurs when the element to be found is either:
1. Not present in the array.

2. Located at the last position of the array.
This is because the algorithm has to compare every element in the array before concluding.
Explanation:
1. Procedure of Linear Search:

Start from the first element of the array.
Compare each element with the target key.
Stop when the element is found or the array ends.
2. Condition for Worst Case:
If the key does not exist or is the last element, all `n` elements are compared.
Algorithm (Steps):
1. Initialize a loop starting from the first element.

2. Compare the current element with the key.
Printed using Save ChatGPT as PDF, powered by PDFCrowd HTML to PDF API. 1/56
3. If they match, return the index.
4. If the loop ends without a match, return -1.
Program (in C):
#include <stdio.h>
int linearSearch(int arr[], int n, int key) {

for (int i = 0; i < n; i++) {
if (arr[i] == key)
return i; // Key found, return index
}
return -1; // Key not found
}
int main() {
int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr) / sizeof(arr[0]);
int key = 6; // Element not present
int result = linearSearch(arr, n, key);
if (result == -1)
printf("Element not found\n");
else
printf("Element found at index %d\n", result);
return 0;
}
Time Complexity:
Best Case: O(1) (Element is at the first position).

Worst Case: O(n) (Element is the last or not present).
Justify the number of interchanges required to sort 5, 1, 6, 24 in ascending order using Bubble Sort.
Recall how Bubble sort works by comparing and swapping elements whenever necessary.
Henceforth, try to figure out the number of interchanges required for the problem given in
question.
Number of Interchanges Required for Bubble Sort:
Based on the Hint:
Bubble Sort works by repeatedly comparing adjacent elements and swapping them if they are in the
wrong order. It continues passing through the array until no more swaps are needed.
Given the array: 5, 1, 6, 24
Step-by-Step Bubble Sort:
1. Initial array: [5, 1, 6, 24]
Compare 5 and 1: Swap (5 > 1) → [1, 5, 6, 24] (1 interchange)
Compare 5 and 6: No swap needed (5 < 6)
End of first pass: [1, 5, 6, 24] (1 interchange)
2. Second pass (already sorted after the first pass, no swaps needed):
End of second pass: [1, 5, 6, 24] (0 interchanges)
Since no swaps were made in the second pass, the algorithm terminates.
Total Interchanges:
1 interchange in the first pass.

0 interchanges in the second pass.
Total interchanges: 1
Conclusion:
The number of interchanges required to sort the array [5, 1, 6, 24] using Bubble Sort is 1.
Relate to a method of sorting which resembles the technique of playing cards.
Recall a sorting technique where any new element coming in is adjusted in such a way so that the
sorted order of the existing others is not disturbed.
The sorting technique you're referring to is Insertion Sort, which resembles the technique of sorting
playing cards.
Relating to Playing Cards:
When you sort a hand of playing cards, you typically take a card from the deck and insert it into its
correct position within the already sorted hand, maintaining the sorted order. This is exactly how
Insertion Sort works.
Insertion Sort Process:
1. Start with the second element in the array (since a single element is trivially sorted).
2. Compare it with the elements in the sorted portion of the array (left side).
3. Shift the larger elements one position to the right to make space for the new element.
4. Insert the element in its correct position.
5. Repeat the process for each subsequent element.
Example:
For the array [5, 1, 6, 24], the insertion sort would proceed like this:
1. Start with 1 (second element). It is smaller than 5, so it is inserted before 5.

After first step: [1, 5, 6, 24] (sorted portion: [1, 5])
2. The next element is 6, which is already in its correct place, so no change is needed.
After second step: [1, 5, 6, 24] (sorted portion: [1, 5, 6])
3. The last element is 24, which is also already in its correct place, so no change is needed.
After third step: [1, 5, 6, 24] (sorted portion: [1, 5, 6, 24])
Conclusion:
Insertion Sort adjusts each new element into the sorted portion without disturbing the order of the
existing elements, just like you would insert a new card into an already sorted hand in a card game.
Test radix sort on the following list:

189, 205, 986, 421, 97, 192, 535, 839, 562, 674
Recall that in radix sort, the procedure of sorting is performed from least
significant digit to the most significant digit.
Radix Sort Process (Least Significant Digit to Most Significant Digit):
Given List:
189, 205, 986, 421, 97, 192, 535, 839, 562, 674
Steps for Radix Sort:
1. Sort by Least Significant Digit (unit place):

Extract the last digit (rightmost digit) and group the numbers based on it.
Numbers sorted by the unit place:
189, 839, 419, 192, 562, 674, 205, 535, 986, 97
2. Sort by Second Least Significant Digit (tens place):
Now, group the numbers based on their second-to-last digit.
Numbers sorted by the tens place:
205, 535, 674, 839, 192, 562, 97, 189, 986, 421
3. Sort by Third Least Significant Digit (hundreds place):
Group the numbers based on their hundreds place.
Numbers sorted by the hundreds place:
97, 189, 192, 205, 421, 535, 562, 674, 839, 986
Final Sorted List:
97, 189, 192, 205, 421, 535, 562, 674, 839, 986
Explanation:
Step 1 (Units place): We sorted based on the unit digit (rightmost digit). After sorting by this, we
move to the next step.
Step 2 (Tens place): We then sorted the numbers based on the tens digit.
Step 3 (Hundreds place): Finally, we sorted based on the hundreds digit, which results in the fully
sorted array.
Conclusion:
The list after performing Radix Sort is: 97, 189, 192, 205, 421, 535, 562, 674, 839, 986.
Apply the binary search algorithm to locate a target element in a sorted array. Explain each step of
the algorithm and analyze its time complexity.
Start by recalling the meaning of time complexity of different searching techniques
Time Complexity of Searching Techniques:
Linear Search: O(n), where n is the number of elements in the array. It checks each element one by
one.
Binary Search: O(log n), where n is the number of elements. It divides the search space in half at
each step, making it much faster than linear search for large arrays.
Binary Search Algorithm:
Binary Search works by repeatedly dividing a sorted array into two halves and narrowing down the
possible locations of the target element based on comparisons with the middle element.
Steps of Binary Search:
Given a sorted array: `[2, 4, 7, 10, 13, 17, 22, 35, 42, 56]`, and a target element `17`.
Step-by-Step Process:
1. Initialize:
Set `low` to the first index (`0`).
Set `high` to the last index (`9`).
2. Find the Middle Element:
Calculate `mid = (low + high) / 2`. In this case, `mid = (0 + 9) / 2 = 4`.
Compare the middle element (àrr[mid] = 13`) with the target (`17`):
Since `13 < 17`, we know the target is in the right half of the array.
3. Update the Search Range:
Set `low = mid + 1`, so `low = 5`.
4. Repeat:
New search range is from index `5` to `9`.
Calculate `mid = (5 + 9) / 2 = 7`.
Since `35 > 17`, the target is in the left half of the array.
5. Update the Search Range:
Set `high = mid - 1`, so `high = 6`.
6. Repeat:
New search range is from index `5` to `6`.
Calculate `mid = (5 + 6) / 2 = 5`.
Since they are equal, target found at index `5`.
Final Answer:
Target 17 is found at index 5.
Time Complexity Analysis:
In each iteration, the search space is reduced by half, which results in a time complexity of O(log n).
For an array of size `n`, the maximum number of steps needed is log₂(n).
In this example:
The array has 10 elements, and we only needed 4 comparisons to find the target, which is
logarithmic growth (log₂(10) ≈ 3.32, rounded up to 4).
Conclusion:
The Binary Search algorithm efficiently locates the target element in O(log n) time, making it highly
suitable for large sorted arrays.
Given a partially sorted array, propose an algorithm that takes advantage of the existing order and
optimizes the sorting process.
Start by recalling the concepts of merge sort with time complexity. BE TO THE POINT
Merge Sort:
Merge Sort is a divide and conquer sorting algorithm. It works by:
1. Dividing the array into two halves.

2. Recursively sorting each half.
3. Merging the two sorted halves to produce a sorted array.
Time Complexity:
Best, Worst, and Average Case: O(n log n), where n is the number of elements in the array.
The algorithm always divides the array and performs merging, regardless of the initial order.
Optimizing Merge Sort for a Partially Sorted Array:
Given that the array is partially sorted, we can optimize the merge process by using the fact that some
portions of the array are already in order. A few strategies include:
1. Check for Sorted Subarrays:

If a subarray is already sorted (i.e., it is monotonic), we can skip the merge step for that
subarray.
Instead of recursively dividing small, already sorted segments, directly merge them to save
computation.
2. Hybrid Approach with Insertion Sort:
When dealing with small subarrays (of size ≤ 10), Insertion Sort is often faster than Merge
Sort.
Apply Insertion Sort on smaller subarrays (which are often nearly sorted) before merging
them.
Optimized Algorithm (Hybrid Merge Sort):
#include <stdio.h>
void insertionSort(int arr[], int left, int right) {

for (int i = left + 1; i <= right; i++) {
int key = arr[i];
int j = i - 1;
while (j >= left && arr[j] > key) {
arr[j + 1] = arr[j];
j--;
}
arr[j + 1] = key;
}
}
void merge(int arr[], int left, int mid, int right) {

int n1 = mid - left + 1;
int n2 = right - mid;
int L[n1], R[n2];

for (int i = 0; i < n1; i++) L[i] = arr[left + i];
for (int i = 0; i < n2; i++) R[i] = arr[mid + 1 + i];
int i = 0, j = 0, k = left;
while (i < n1 && j < n2) {
if (L[i] <= R[j]) {
arr[k++] = L[i++];
} else {
arr[k++] = R[j++];
}
}
while (i < n1) arr[k++] = L[i++];
while (j < n2) arr[k++] = R[j++];
}
void optimizedMergeSort(int arr[], int left, int right) {

if (right - left <= 10) {
insertionSort(arr, left, right);
return;
}
if (left < right) {
int mid = left + (right - left) / 2;
optimizedMergeSort(arr, left, mid);
optimizedMergeSort(arr, mid + 1, right);
merge(arr, left, mid, right);
}
}
int main() {
int arr[] = {3, 5, 7, 9, 12, 8, 6, 4};
optimizedMergeSort(arr, 0, n - 1);
for (int i = 0; i < n; i++) {

printf("%d ", arr[i]);
}
return 0;
}
Explanation of the Optimized Approach:
1. Insertion Sort on Small Subarrays: For subarrays of size ≤ 10, Insertion Sort is used instead of
Merge Sort. This helps to optimize the sorting of nearly sorted sections.
2. Merging Sorted Subarrays: The regular merging process is used for larger arrays, but it takes
advantage of the existing order in partially sorted arrays.
Conclusion:
This hybrid approach of Merge Sort combined with Insertion Sort optimizes sorting for partially sorted
arrays, making it more efficient by leveraging existing order.
Evaluate the impact of different collision resolution strategies in hash tables (e.g., chaining, open
addressing) and propose a new approach or improvement that mitigates their limitations.
Recall different collision resolution strategies in hashing.
Collision Resolution Strategies in Hashing:
In hash tables, a collision occurs when two different keys hash to the same index. Different strategies
are used to handle collisions, and each has its strengths and weaknesses.
1. Chaining:
Description: Each position in the hash table points to a linked list (or another data structure) that
stores all elements whose hash value maps to that position.
Impact:
Advantages:
Simple to implement.
Does not require resizing the table when collisions occur.
Disadvantages:
Can lead to poor performance if many keys hash to the same index (long linked lists).
Wasted space in the hash table when many positions remain empty.
Performance degrades to O(n) in the worst case if all keys hash to the same index.
Use Cases: Suitable for situations where the number of elements is highly variable or unknown.
2. Open Addressing:
Description: When a collision occurs, open addressing searches for the next available slot in the
hash table itself (instead of using a linked list). Common methods include:
Linear Probing: Search sequentially (e.g., index + 1, index + 2, etc.).
Quadratic Probing: Search by incrementing indices using a quadratic function (e.g., index +
1^2, index + 2^2).
Double Hashing: Use a secondary hash function to determine the step size for probing.
Impact:
Advantages:
Uses less memory than chaining because it stores all data in the hash table itself.
Can be more cache-efficient due to the table’s contiguity.
Disadvantages:
Clustering: Long runs of consecutive occupied slots can form, especially with linear
probing, leading to performance degradation.
Requires resizing when the table becomes full (rehashing), which is costly.
Performance suffers when the load factor is high.
Use Cases: Useful when memory efficiency is crucial and the table size can be managed to avoid
high load factors.
3. Double Hashing:
Description: This is a variation of open addressing where a second hash function is used to
compute the step size for probing.
Impact:
Advantages:
Reduces clustering (a common issue in linear and quadratic probing).
More evenly distributed probes.
Disadvantages:
More complex to implement because it requires two hash functions.
Can still suffer from performance degradation when the load factor is high.
Use Cases: Ideal when dealing with large datasets and when reducing clustering is
important.
Proposed New Approach: Dynamic Hybrid Hashing (DHH)
A potential improvement can be made by dynamically switching between chaining and open
addressing based on certain conditions:
1. Dynamic Hybrid Hashing (DHH):

Description: Use open addressing (e.g., linear probing or double hashing) for collision
resolution by default, but switch to chaining when the load factor crosses a certain threshold
(say 70%).
How It Works:
Initially, the hash table uses open addressing.
When collisions become frequent (load factor increases), the hash table automatically
switches to chaining for certain segments or entire regions of the table, while
continuing to use open addressing in other areas.
This dynamic switch is triggered by monitoring the collision rate or load factor and can
optimize performance by balancing memory usage and computational complexity.
Impact:
Advantages:
Avoids clustering by using open addressing until collisions are frequent, then
switches to chaining for more efficient handling of high collision rates.
More adaptable than static strategies because it adapts to the actual usage
patterns of the hash table.
Can provide better overall performance by balancing the strengths of both
approaches.
Disadvantages:
More complex to implement and maintain (requires dynamic switching logic and
tracking of load factors).
Potential overhead due to frequent rehashing or transitioning between strategies.
Use Cases: Useful in systems where the dataset size fluctuates over time and the load
factor can vary significantly.
Conclusion:
Each collision resolution strategy in hashing has its strengths and weaknesses. Chaining is simple but
can waste space and degrade in performance with long lists. Open addressing is space-efficient but can
suffer from clustering. Double hashing mitigates clustering but adds complexity. The proposed
Dynamic Hybrid Hashing (DHH) approach optimizes performance by dynamically switching between
chaining and open addressing, offering an adaptable solution for varying collision scenarios.
Create a function to implement the Insertion Sort algorithm. The function should take an array of
integers as input and sort it in ascending order using the Insertion Sort technique.
Here is the C function to implement the Insertion Sort algorithm, which sorts an array of integers in
ascending order:
#include <stdio.h>
// Function to perform Insertion Sort

void insertionSort(int arr[], int n) {
int i, key, j;
for (i = 1; i < n; i++) {
key = arr[i]; // The element to be inserted
j = i - 1;
// Move elements of arr[0..i-1], that are greater than key, to one position ahead
while (j >= 0 && arr[j] > key) {
arr[j + 1] = arr[j];
j = j - 1;
}
arr[j + 1] = key; // Insert the key in the correct position
}
}
// Function to print the array

void printArray(int arr[], int n) {
for (int i = 0; i < n; i++) {
printf("%d ", arr[i]);
}
printf("\n");
}
int main() {
int arr[] = {12, 11, 13, 5, 6}; // Example array
printf("Original array: \n");

printArray(arr, n);
insertionSort(arr, n); // Call Insertion Sort
printf("Sorted array: \n");

printArray(arr, n);
return 0;
}
Explanation:
1. insertionSort function:
We start with the second element (index 1) and consider it as the "key."
Compare the key with the elements before it, and shift those elements one position to the
right if they are greater than the key.
Place the key in its correct position within the sorted portion of the array.
2. printArray function:
This function is used to print the array after sorting.
Example Output:
Original array:
12 11 13 5 6
Sorted array:
5 6 11 12 13
Time Complexity:
Best Case: O(n) (when the array is already sorted).

Worst and Average Case: O(n^2) (when the array is in reverse order or randomly ordered).
Explain Binary Search procedure for the following list of elements and assume the key element is
85.
12, 23, 34, 45, 55, 62, 71, 85, 96
You have to find the mid value using start and end index of the array. If search element is mid then
return the value, otherwise you have to change the start value or end value
Binary Search Procedure for the Given List
List of elements: `[12, 23, 34, 45, 55, 62, 71, 85, 96]`
Key element: `85`
Binary Search Procedure:
1. Initialize the start and end indices:

`start = 0` (the index of the first element)
ènd = 8` (the index of the last element, since the array has 9 elements)
2. Calculate the mid index:
Mid index is calculated as:
start + end
mid =
2

Since the start and end indices are integers, the mid value is rounded down if the result is a
fraction.
3. Check the element at the mid index:
If àrr[mid] == key`, the key is found and returned.
If àrr[mid] > key`, change the ènd` to `mid - 1` (narrowing the search to the left half).
If àrr[mid] < key`, change the `start` to `mid + 1` (narrowing the search to the right half).
4. Repeat the process until the `start` index is greater than the ènd` index, or the key is found.
Steps to Find the Key `85`:
Initial values:
`start = 0`, ènd = 8` (array size is 9)
Array: `[12, 23, 34, 45, 55, 62, 71, 85, 96]`
First iteration:
Calculate mid: `mid = (0 + 8) / 2 = 4` (integer division)
Element at `mid` = àrr[4] = 55`
Since `55 < 85`, update `start = mid + 1 = 5`.
Second iteration:
Now, `start = 5`, ènd = 8`
Calculate mid: `mid = (5 + 8) / 2 = 6`
Since `71 < 85`, update `start = mid + 1 = 7`.
Third iteration:
Now, `start = 7`, ènd = 8`
Calculate mid: `mid = (7 + 8) / 2 = 7`
Since `85 == 85`, we have found the key at index 7.
Final Answer:
The key `85` is found at index 7 in the array.
Algorithm in Pseudocode:
text
function binarySearch(arr, start, end, key):

while start <= end:
mid = (start + end) / 2
if arr[mid] == key:
return mid // Found the key
else if arr[mid] < key:
start = mid + 1 // Narrow search to right half
else:
end = mid - 1 // Narrow search to left half
return -1 // Key not found
Time Complexity:
Best Case: O(1) (key is found at the middle of the array in the first check).
Worst Case: O(log n) (the search space is halved each time).
Write the name of the sorting technique which is

used in playing cards game? Write a procedure for
sorting a given list of numbers using THAT technique?
14, 25, 36, 74, 85, 6, 53, 62, 41 .
Perform insertion sort in this sorting technique.
The sorting technique used in a playing card game is Insertion Sort. This technique resembles how
players would sort a hand of playing cards by picking each card from the unsorted portion of their hand
and placing it in the correct position relative to the already sorted cards.
Insertion Sort Procedure:
1. Start with the second element (index 1) because the first element is trivially considered sorted.
2. Compare the current element with the elements before it in the sorted portion of the array.
3. Shift the elements greater than the current element one position to the right.
4. Insert the current element into its correct position.
5. Repeat until the entire list is sorted.
Insertion Sort Algorithm for the List:
`[14, 25, 36, 74, 85, 6, 53, 62, 41]`
Let's go through the steps of sorting this list using Insertion Sort.
1. Initial List: `[14, 25, 36, 74, 85, 6, 53, 62, 41]`
2. Step 1: Start with the second element, `25`. Compare it with the first element `14`. Since `14 < 25`,
no change.
List after Step 1: `[14, 25, 36, 74, 85, 6, 53, 62, 41]`
3. Step 2: Move to the next element, `36`. Compare it with `25` and `14`. Since `14 < 25 < 36`, no
change.
List after Step 2: `[14, 25, 36, 74, 85, 6, 53, 62, 41]`
4. Step 3: Move to the next element, `74`. Compare it with `36`, `25`, and `14`. Since `14 < 25 < 36 <
74`, no change.
List after Step 3: `[14, 25, 36, 74, 85, 6, 53, 62, 41]`
5. Step 4: Move to the next element, `85`. Compare it with `74`, `36`, `25`, and `14`. Since `14 < 25 <
36 < 74 < 85`, no change.
List after Step 4: `[14, 25, 36, 74, 85, 6, 53, 62, 41]`
6. Step 5: Move to the next element, `6`. Compare it with `85`, `74`, `36`, `25`, and `14`. Shift
elements to the right as needed, and insert `6` at the beginning.
List after Step 5: `[6, 14, 25, 36, 74, 85, 53, 62, 41]`
7. Step 6: Move to the next element, `53`. Compare it with `85`, `74`, `36`, `25`, and `14`. Insert `53`
in the correct position (between `36` and `74`).
List after Step 6: `[6, 14, 25, 36, 53, 74, 85, 62, 41]`
8. Step 7: Move to the next element, `62`. Compare it with `85`, `74`, `53`, `36`, `25`, and `14`. Insert
`62` in the correct position (between `53` and `74`).
List after Step 7: `[6, 14, 25, 36, 53, 62, 74, 85, 41]`
9. Step 8: Move to the next element, `41`. Compare it with `85`, `74`, `62`, `53`, `36`, `25`, and `14`.
Insert `41` in the correct position (between `36` and `53`).
Final Sorted List: `[6, 14, 25, 36, 41, 53, 62, 74, 85]`
Final Sorted List:
`[6, 14, 25, 36, 41, 53, 62, 74, 85]`
Time Complexity of Insertion Sort:
Best Case: O(n) (when the list is already sorted).

Worst and Average Case: O(n^2) (when the list is in reverse order or has random elements).
What is the idea behind Selection sort and sort the following list of elements using that idea. Array
A = [ 7, 5 , 4 , 2 ] needs to be sorted in ascending order.
Set Min to location 0. Look for the smallest element on the list. Replace the value at location Min
with a different value
Idea Behind Selection Sort:
The Selection Sort algorithm works by repeatedly selecting the minimum element from the unsorted
portion of the list and swapping it with the leftmost unsorted element. This process is repeated for each
position in the array until the entire array is sorted.
Steps in Selection Sort:
1. Start with the first element (index 0), and assume it is the minimum.
2. Scan the remaining elements (from index 1 to the end of the array) to find the smallest element.
3. Swap the smallest element with the element at the current position.
4. Move to the next element (index 1), and repeat the process.
5. Continue this until the entire array is sorted.
Sorting the Array:
Array A = [7, 5, 4, 2]
Step-by-Step Execution:
1. Initial Array: `[7, 5, 4, 2]`

Set Min = 0 (index 0, value 7).
Look for the smallest element in the remaining list (`[5, 4, 2]`).
The smallest element is `2` at index 3.
Swap `7` and `2`.
Array after step 1: `[2, 5, 4, 7]`
2. Next iteration (start from index 1):

Look for the smallest element in the remaining list (`[4, 7]`).
The smallest element is `4` at index 2.
Swap `5` and `4`.
Look for the smallest element in the remaining list (`[7]`).
The smallest element is `5` (no change required).

There are no remaining elements, so no changes are needed.
Final Sorted Array:
`[2, 4, 5, 7]`
Time Complexity of Selection Sort:
Best Case: O(n^2) (no optimization is done for the best case).
Worst and Average Case: O(n^2) (it always performs the same number of comparisons).
Given the input { 4371, 1323, 6173, 4199, 4344, 9679, 1989 } and a hash function of h(X)=X
(mod 10) show the resulting:
a. Open addressing hash table using linear probing
In linear probing, the algorithm simply looks for the next available slot in the hash table and places
the collided key there. If that slot is also occupied, the algorithm continues searching for the
next available slot until an empty slot is found.
Problem:
Given the input list `{4371, 1323, 6173, 4199, 4344, 9679, 1989}` and a hash function h(X) =X
mod 10, we need to implement Open Addressing using Linear Probing to resolve hash collisions and
create the resulting hash table.
Hash Function:
The hash function is h(X) = X mod 10, which means we take the modulus of each number with 10
to determine its index in the hash table.
Procedure:
1. Initial setup: We will create a hash table with 10 slots (0 to 9) because the modulus operation X
mod 10 will give values from 0 to 9.
2. Linear Probing: If the slot at the computed index is occupied, we will search for the next available
slot (index + 1, and so on, wrapping around to 0 if necessary) until we find an empty slot.
Step-by-Step Calculation:
1. Insert 4371:
h(4371) = 4371 mod 10 = 1.
Slot 1 is empty, so insert 4371 at index 1.
Hash Table: `[_, 4371, _, _, _, _, _, _, _, _]`.
2. Insert 1323:
h(1323) = 1323 mod 10 = 3.
Hash Table: `[_, 4371, _, 1323, _, _, _, _, _, _]`.
3. Insert 6173:
h(6173) = 6173 mod 10 = 3.
Slot 3 is occupied (1323 is already there), so we apply linear probing.
Check the next slot (index 4), which is empty, so insert 6173 at index 4.
Hash Table: `[_, 4371, _, 1323, 6173, _, _, _, _, _]`.
4. Insert 4199:
h(4199) = 4199 mod 10 = 9.
Hash Table: `[_, 4371, _, 1323, 6173, _, _, _, _, 4199]`.
5. Insert 4344:
h(4344) = 4344 mod 10 = 4.
Slot 4 is occupied (6173 is already there), so we apply linear probing.
Hash Table: `[_, 4371, _, 1323, 6173, 4344, _, _, _, 4199]`.
6. Insert 9679:
h(9679) = 9679 mod 10 = 9.
Slot 9 is occupied (4199 is there), so we apply linear probing.
Hash Table: `[9679, 4371, _, 1323, 6173, 4344, _, _, _, 4199]`.
7. Insert 1989:
h(1989) = 1989 mod 10 = 9.
Slot 9 is occupied (4199 is there), so we apply linear probing.
Check the next slot (index 0), which is also occupied (9679 is there).
Check the next slot (index 1), which is also occupied (4371 is there).
Hash Table: `[9679, 4371, 1989, 1323, 6173, 4344, _, _, _, 4199]`.
Final Hash Table:
After inserting all the elements, the resulting Open Addressing Hash Table using Linear Probing is:
yaml
[9679, 4371, 1989, 1323, 6173, 4344, _, _, _, 4199]
Summary:
Key Concept: The Linear Probing technique resolves collisions by checking the next available slot
(index + 1) in the hash table.
Final Table: After inserting all elements, the table is filled as shown above, with the values placed
at the corresponding slots based on the hash function, using linear probing to handle collisions.
Analyze the time complexity for the algorithm to calculate sum of natural numbers using loops and
using direct formula.
Write both algorithms and use step count method to calculate time complexity.
Problem:
We need to analyze the time complexity of calculating the sum of the first n natural numbers using two
different methods:
1. Using Loops.
2. Using the Direct Formula.
1. Sum Using Loops (Iterative Approach)
Algorithm:
int sumUsingLoop(int n) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += i;
}
return sum;
}
Time Complexity Analysis (Step Count Method):
Initialization of sum: 1 step.

Loop: The loop runs from 1 to n, so it will iterate n times. In each iteration:
Adding i to `sum`: 1 step.
Total steps: The loop executes n times, and in each iteration, there is a constant amount of work (1
step for the addition).
Thus, the total time complexity for this algorithm is:
T (n) = 1 + n × 1 = O(n)
So, Time Complexity for the loop-based sum algorithm is O(n).
2. Sum Using Direct Formula
The sum of the first n natural numbers is given by the formula:
n × (n + 1)
S=
2

Algorithm:
c
int sumUsingFormula(int n) {
return (n * (n + 1)) / 2;
}
Time Complexity Analysis (Step Count Method):
Multiplying n × (n + 1): 1 step.

Dividing by 2: 1 step.
Return: 1 step.
Since all operations (multiplication, addition, division, and return) take constant time, the total time
complexity is:
T (n) = 1 + 1 + 1 = O(1)
So, Time Complexity for the formula-based sum algorithm is O(1).
Summary of Time Complexities:
Using Loops: O(n)

Using Direct Formula: O(1)
Conclusion:
The loop-based approach has linear time complexity because it iterates through n elements.
The formula-based approach has constant time complexity because it calculates the sum in a
fixed number of steps, regardless of n.
All algorithms cannot have tight bound."- Analyze the justification of the statement.
Go through the definition of theta notation.
Statement: "All algorithms cannot have a tight bound."
This statement is related to the tight bound of an algorithm's time complexity, and it can be analyzed
through the concept of Big-Theta (θ) notation.
1. Understanding Theta Notation (θ)
Big-Theta Notation (θ) is used to describe the tight bound of an algorithm’s time complexity. It
provides a precise asymptotic bound on the runtime, meaning it captures both the upper bound
and the lower bound of an algorithm's time complexity.
Formally, an algorithm has a time complexity T (n) = θ(f (n)) if and only if there exist constants
c1 , c2 , and n0 such that for all n > n0 ,

c1 ⋅ f (n) ≤ T (n) ≤ c2 ⋅ f (n)

In other words, T (n) grows asymptotically at the same rate as f (n), within constant factors.
Key points about theta notation:
Upper Bound: T (n) ≤ c2 ⋅ f (n) (ensures the algorithm doesn’t exceed the upper bound).

Lower Bound: T (n) ≥ c1 ⋅ f (n) (ensures the algorithm takes at least this much time).

The function f (n) is the exact growth rate of the algorithm’s time complexity, bounded from
both above and below.
2. Interpretation of the Statement: "All algorithms cannot have tight bound."
The statement asserts that not every algorithm can have a tight bound (i.e., an exact θ -notation). To
understand this, we need to consider scenarios where an algorithm’s time complexity is not well-defined
or cannot be tightly bounded.
Possible Reasons for Lack of Tight Bound:
1. Algorithms with Unpredictable Behavior:

Some algorithms, especially those involving randomization (like randomized algorithms) or
complex input-dependent behavior, may not have a single, precise bound. For instance,
algorithms like QuickSort have different time complexities for the average case and the
worst case.
Average case: O(n log n)
Worst case: O(n2 )
In such cases, we can describe the algorithm with different asymptotic notations for
different cases (e.g., Big-O for worst case and Big-Theta for average case), but we
cannot guarantee a single tight bound across all possible inputs.
2. Complexity in the Presence of Multiple Variables:
For algorithms with multiple input variables, the time complexity may be a function of
multiple parameters. For example, an algorithm with complexity O(n2 + m3 ) might have
different growth rates depending on how n and m grow relative to each other.
In such cases, it may be difficult to capture a single tight bound that applies to all
combinations of inputs, and hence, it may not have a tight bound.
3. Non-Deterministic Algorithms:
Some non-deterministic algorithms, where the execution time depends on random choices
or probabilistic factors, may not have a clear tight bound that applies in all cases. For
example, algorithms based on Monte Carlo methods or Las Vegas algorithms may not have
predictable worst-case times, and their performance can vary across different runs.
4. Infinite or Undefined Time Complexities:
Some algorithms may run indefinitely or have undefined behavior in certain cases, making it
impossible to define a tight bound. For example, if an algorithm has an infinite loop in the
worst case or if it is highly dependent on the problem structure (like in some combinatorial
problems), we cannot apply Theta notation effectively.
3. Conclusion:
While Theta notation (θ) provides a way to describe tight bounds for many algorithms, the statement
"All algorithms cannot have a tight bound" is justified in the following cases:
1. Unpredictable behavior (e.g., randomized algorithms, algorithms with varying input sizes).
2. Multiple input variables that lead to complexities dependent on combinations of those variables.
3. Non-deterministic algorithms where performance is not predictable.
4. Infinite or undefined time complexities, making it impossible to apply tight bounds.
Thus, although many algorithms have well-defined time complexities with tight bounds (i.e., they can be
described by Big-Theta notation), there are certain cases where a tight bound cannot be determined
due to the nature of the algorithm or problem.
Show that f(n) is having upper bound of O(n^2) with proper constant and minimum input value;
f(n)= 10n^2 - 5n
Go through the definition of Big-Oh notation.
Problem:
We are given the function f (n) = 10n2 − 5n, and we need to show that this function has an upper
bound of O(n2 ) with proper constants and the minimum input value.
1. Definition of Big-Oh Notation:
Big-Oh notation O(g(n)) is used to describe the upper bound of an algorithm's time complexity, i.e., it
provides an asymptotic upper limit on how a function grows as the input size increases.
Formally, f (n) = O(g(n)) means that there exist positive constants c and n0 such that for all n ≥ n0 :

f (n) ≤ c ⋅ g(n)
In other words, f (n) does not grow faster than g(n) multiplied by a constant c, for sufficiently large n.
2. Our Task:
We are asked to prove that f (n) = 10n2 − 5n is in O(n2 ).
3. Steps to Prove f (n) = O(n2 ):

1. Start with the definition of Big-Oh notation: We want to show that f (n) ≤ c ⋅ n2 for some
constant c and for n ≥ n0 .
2. Simplify f (n):
f (n) = 10n2 − 5n
Now, we want to find a constant c such that 10n2 − 5n ≤ c ⋅ n2 .
3. Find the upper bound for large n: Let's start by simplifying the expression for large n.
We know that for sufficiently large n, the term 10n2 will dominate over −5n. So, we want to show
that:
10n2 − 5n ≤ c ⋅ n2
for some constant c.
To do this, divide the inequality by n2 (for n > 0):

5
10 − ≤c
n
As n becomes large, the term n5 approaches 0. Therefore, for large n, the inequality becomes:

10 ≤ c
This suggests that we can choose c = 11, which ensures that for large n, the inequality holds.
4. Minimum Value for n: Now, let's check for a minimum value n0 where this inequality holds.

For n ≥ 1, we can check the inequality:
10n2 − 5n ≤ 11n2
Simplifying:
10n2 − 5n − 11n2 ≤ 0
−n2 − 5n ≤ 0
n2 + 5n ≥ 0
This inequality holds for all n ≥ 0.

5. Conclusion: We have found that for c = 11 and n0 = 1, the inequality 10n2 − 5n ≤ 11n2 holds

for all n ≥ 1.
Therefore, we have shown that f (n) = 10n2 − 5n is O(n2 ), with c = 11 and n0 = 1.

Final Answer:
We have demonstrated that f (n) = 10n2 − 5n has an upper bound of O(n2 ) with constants c = 11
and n0 = 1.
Design an algorithm of time complexity O(log(log n).
Study step count method.
Designing an Algorithm with Time Complexity O(log(log n))
To design an algorithm with a time complexity of O(log(log n)), we need to think about the types of
operations that could lead to such a complexity. This time complexity generally appears in scenarios
where the size of the input is dramatically reduced in each step, much more so than in a typical
logarithmic algorithm.
One example of an algorithm with O(log(log n)) complexity is an algorithm that repeatedly reduces
the input size exponentially, such as repeatedly taking the logarithm of the input.
Here is a simple conceptual algorithm to demonstrate this:
Example: Double Logarithmic Search Algorithm
Consider the problem of finding the integer x such that 2x= n. This would require a logarithmic
number of steps to reduce the problem size by repeatedly dividing n in half. However, applying a
logarithmic operation twice can lead to O(log(log n)).
Algorithm: Double Logarithmic Search
1. Start with the number n.

2. Find log n, which reduces the problem size by one logarithmic step.
3. Find log(log n), reducing the problem size even further.
Step-by-Step Algorithm:
#include <math.h>
#include <stdio.h>
int doubleLogarithmicSearch(int n) {
int log_n = (int)log2(n); // Step 1: Find log n (base 2)
int log_log_n = (int)log2(log_n); // Step 2: Find log(log n)
return log_log_n; // Return log(log n)
}
int main() {
int n = 1024;
int result = doubleLogarithmicSearch(n);
printf("log(log(%d)) = %d\n", n, result);
return 0;
}
Time Complexity Analysis Using Step Count Method:
1. Finding log n:
The computation of log n requires a constant number of operations, which we consider as a
constant time operation, O(1), assuming we're using a logarithmic function directly.
2. Finding log(log n):
The computation of log(log n) also requires a constant number of operations, O(1).
3. Total Steps:
The algorithm involves two logarithmic operations, each of which requires O(1) time,
resulting in a total of O(1) + O(1) = O(1) operations, making the time complexity per
operation constant.
Thus, we can express the overall time complexity as:
T (n) = O(log(log n))
Conclusion:
The algorithm above, which computes log(log n), takes O(log(log n)) time because:
The size of the problem is reduced significantly with each logarithmic step.
The number of operations is determined by two logarithmic reductions: first log n, then log(log n)
.
This is a classic example of an algorithm with O(log(log n)) time complexity, which is very efficient and
occurs in scenarios where you apply logarithmic operations repeatedly.
Analyze the benefits of using array of pointers over 2D array with proper example.
Take variable length multiple strings and compare storage requirement.
Benefits of Using Array of Pointers Over 2D Arrays
When handling multiple strings (or variable-length data) in C, the choice between using an array of
pointers and a 2D array can have significant implications on memory management, storage
requirements, and flexibility. Below is an analysis of both approaches with an example, followed by a
comparison of storage requirements.
1. Array of Pointers:
An array of pointers is a collection of pointers, where each pointer points to a string (or an array of
characters). The size of the array of pointers is fixed, but the length of each string can vary.
Example of Array of Pointers:
#include <stdio.h>
#include <stdlib.h>
int main() {
// Array of pointers to strings
char *arr[] = {
"Hello",
"World",
"Array",
"of",
"Pointers"
};
// Printing strings
for (int i = 0; i < 5; i++) {
printf("%s\n", arr[i]);
}
return 0;
}
In this example, we have an array of pointers where each element points to a dynamically allocated
string.
Benefits:
1. Dynamic Memory Allocation:

Each string can have a different length, as each pointer can point to a separately allocated
memory block.
This is useful when the strings have variable lengths, allowing more efficient use of memory.
2. Flexibility:
The strings can be manipulated independently, and you can resize or modify each string
without affecting others.
3. Efficient Memory Usage:
Only the required memory is allocated for each string. If one string is small and another is
large, the memory is allocated accordingly without waste.
4. No Fixed Size:
Unlike a 2D array, the size of the string array (number of strings) does not need to be
predefined, allowing greater flexibility.
2. 2D Array:
A 2D array can also be used to store strings, but each string must have the same length (i.e., each row
of the array will have the same fixed number of characters).
Example of 2D Array:
#include <stdio.h>
int main() {
// 2D array for storing strings
char arr[5][20] = {
"Hello",
"World",
"Array",
"of",
"Strings"
};
// Printing strings
for (int i = 0; i < 5; i++) {
}
return 0;
}
In this case, we predefine a 2D array of size 5 × 20, meaning there are 5 strings, and each string can
hold up to 20 characters.
Benefits:
1. Simpler to Use:
The 2D array is simpler to manage because there’s no need for dynamic memory allocation or
pointer manipulation.
2. Memory Contiguity:
The memory for all strings is allocated contiguously, which might provide some performance
benefits in certain cases.
3. Faster Access:
Since the strings are stored in a contiguous block, accessing them can be faster because of
the improved cache locality.
3. Comparison of Storage Requirements:
Aspect Array of Pointers 2D Array

Memory Memory is pre-allocated for all
Memory is allocated dynamically for each string.
Allocation strings (fixed size).
Memory Less efficient, as each string must
More efficient since each string can have variable length.
Usage be the same size (fixed).
High. Strings can vary in size and can be dynamically Low. All strings must be the same
Flexibility
resized. length (fixed size).
More complex because of dynamic memory allocation Simple. Direct access to each
Complexity
and pointer management. character with indices.
If each string has a different length, e.g., 5, 10, 7, 3, 8, Memory is fixed for all strings. For 5
Example (5
total memory would be 5 + 10 + 7 + 3 + 8 = 33 bytes strings with 20 characters, it uses
strings)
(plus overhead for the array of pointers). 5 × 20 = 100 bytes.
4. Example of Variable-Length Multiple Strings:
Let’s consider a scenario where we have 3 strings with different lengths:
#include <stdio.h>
#include <stdlib.h>
int main() {
// Array of pointers to strings
char *arr[] = {
"Hello",
"World",
"This is a longer string"
};
// Print strings
for (int i = 0; i < 3; i++) {
}
return 0;
}
Storage Analysis:
Array of Pointers:
Memory will be allocated as follows:
"Hello" (5 characters) = 5 bytes + pointer size (typically 4 or 8 bytes).
"World" (5 characters) = 5 bytes + pointer size.
"This is a longer string" (23 characters) = 23 bytes + pointer size.
Total memory = 5 + 5 + 23 + 3 pointers (let’s assume pointer size is 4 bytes): 5 + 5 + 23 +
12 = 45 bytes.
2D Array:
If we define a 2D array with 3 rows and the maximum string length of 30 characters
(assuming 30 for padding), we get:
Total memory = 3 × 30 = 90 bytes.
Thus, for the array of pointers, the storage requirement is 45 bytes, whereas for the 2D array, it would
be 90 bytes. The array of pointers uses memory more efficiently because it only allocates the exact
amount of memory required for each string.
Conclusion:
Array of Pointers is more efficient in terms of memory usage when dealing with variable-length
strings, as each string can be allocated the exact amount of memory it needs.
2D Arrays are simpler to implement but can lead to inefficient memory usage when strings have
varying lengths, as the array size must be fixed for all strings.
When working with multiple strings of varying lengths, the array of pointers is typically preferred due
to its flexibility and efficient memory usage.
Design an algorithm to calculate the memory address of any element in a N-dimensional array.
Take the idea from 2D array formula
To calculate the memory address of an element in an N-dimensional array, we can extend the idea
used for 2D arrays. The formula for the memory address in a 2D array is:
Address = Base Address + (∑(Indexi × stridei ))

n−1

i=0
Where:
Base Address is the starting address of the array.

Indexi is the index of the element along the i-th dimension (starting from 0).

stridei is the size of an element in the i-th dimension (typically stridei =

total size of the elements in previous dimensions × size of each element).
Step-by-Step Formula for N -Dimensional Array:
1. Stride Calculation:
For each dimension, the stride is calculated based on the size of the elements in the next
dimensions. For example, for a 2D array, the stride for the first dimension is the number of
columns (the second dimension size), and for the second dimension, it is 1 (since we move
one element at a time).
2. Address Formula for N-Dimensional Array:
Let’s say we have an N-dimensional array with dimensions D1 × D2 × ⋯ × DN where Di is

the size of the i-th dimension.

The address of an element located at indices (i1 , i2 , … , iN ) can be calculated as:

N
Address = Base Address + ∑ (ik × stridek )
k=1
where stridek is the size of the step to move to the next element in the k -th dimension.

3. Stride Calculation:
The strides for each dimension are calculated from the array's dimensions and size of each
element. For a 1D array, the stride is 1 (each element is next to each other).
For a 2D array, the stride for the first dimension (rows) would be the number of elements in
the second dimension (columns). The stride for the second dimension (columns) would be 1.
Example of Memory Address Calculation for 3D Array
Let's take a 3D array with dimensions D1 × D2 × D3 (i.e., an array with D1 rows, D2 columns, and D3

depth). The formula to calculate the address of the element at position (i1 , i2 , i3 ) is:
Address = Base Address + (i1 × (D2 × D3 )) + (i2 × D3 ) + i3

Where:
i1 , i2 , i3 are the indices of the element in the 3D array.

D2 × D3 gives the total number of elements in each 2D plane, which corresponds to the stride for

the first dimension.

D3 is the stride for the second dimension (i.e., the number of elements in each row).

1 is the stride for the third dimension (i.e., the elements are adjacent in the third dimension).
Generalized Algorithm to Calculate Memory Address in an N-Dimensional Array:
Here’s a generalized algorithm to calculate the memory address of an element in an N -dimensional

array:
#include <stdio.h>
unsigned long long calculateAddress(unsigned long long baseAddress, int dimensions[], int in
dices[], int N, int elementSize) {
unsigned long long address = baseAddress;
unsigned long long stride = 1;
for (int i = N - 1; i >= 0; i--) {

// Calculate the address of the element at indices[i] in the i-th dimension
address += indices[i] * stride;
// Update the stride for the next dimension
stride *= dimensions[i];
}
// Multiply by the size of each element to account for the element's size in memory
address *= elementSize;
return address;
}
int main() {
// Example for a 3D array with dimensions 4x5x6 (4 rows, 5 columns, 6 depth)
int dimensions[3] = {4, 5, 6};
int indices[3] = {2, 3, 4}; // Element at indices (2, 3, 4)
unsigned long long baseAddress = 1000; // Arbitrary base address

int elementSize = 4; // Assume each element is of size 4 bytes (e.g., an integer)
unsigned long long address = calculateAddress(baseAddress, dimensions, indices, 3, eleme

ntSize);
printf("The memory address of the element is: %llu\n", address);

return 0;
}
Explanation of the Algorithm:
1. Input:
`baseAddress`: The starting memory address of the array.
`dimensions[]`: An array representing the size of each dimension of the array.
ìndices[]`: The indices for the element whose address is to be calculated.
`N`: The number of dimensions.
èlementSize`: The size of one element in memory (e.g., 4 bytes for an integer).
2. Steps:
The algorithm calculates the address by iterating over each dimension starting from the
innermost one.
For each dimension, the stride is updated, and the corresponding offset (calculated by
multiplying the index by the stride) is added to the address.
3. Output:
The calculated memory address of the element at the given indices.
Time Complexity:
The time complexity of this algorithm is O(N ), where N is the number of dimensions in the array. This
is because we need to iterate over each dimension to compute the address.
Conclusion:
This algorithm allows you to calculate the memory address of any element in an N-dimensional array
based on its indices. The key idea is to apply the concept of strides for each dimension, progressively
reducing the problem to a 1D array.
Design an algorithm to check whether a linked list is containing any loop or not.
Use two pointers, say fast & slow. Fast will move 2 steps at a time and slow will 1 step. If they meet
then there is a loop.
To detect a loop in a linked list using the Floyd's Cycle-Finding Algorithm (also known as the Tortoise
and Hare algorithm), we use two pointers: one moving faster (2 steps at a time) and one moving slower
(1 step at a time). If the two pointers meet, there is a loop. If they don't meet, then there is no loop.
Algorithm:
1. Initialize two pointers:

slow pointer moves 1 step at a time.
fast pointer moves 2 steps at a time.
2. Traverse the list:
Move the slow pointer by 1 step and the fast pointer by 2 steps in each iteration.
If the fast pointer or fast.next becomes `NULL`, then the list does not contain a loop (since it
has reached the end).
3. Loop Detection:
If at any point, the slow and fast pointers meet (i.e., `slow == fast`), a loop is detected in the
list.
If the fast pointer reaches the end of the list (`fast == NULL`), no loop is present.
Code Implementation in C:
#include <stdio.h>
#include <stdlib.h>
// Define a node structure for the linked list

struct Node {
int data;
struct Node* next;
};
// Function to detect a loop in a linked list

int detectLoop(struct Node* head) {
// Initialize slow and fast pointers
struct Node* slow = head;
struct Node* fast = head;
// Traverse the list

while (fast != NULL && fast->next != NULL) {
slow = slow->next; // Move slow pointer by 1 step
fast = fast->next->next; // Move fast pointer by 2 steps
// If slow and fast pointers meet, there is a loop

if (slow == fast) {
return 1; // Loop detected
}
}
return 0; // No loop detected

}
// Helper function to create a new node

struct Node* newNode(int data) {
struct Node* node = (struct Node*)malloc(sizeof(struct Node));
node->data = data;
node->next = NULL;
return node;
}
// Test the detectLoop function

int main() {
// Create a sample linked list: 1 -> 2 -> 3 -> 4 -> 5
struct Node* head = newNode(1);
head->next = newNode(2);
head->next->next = newNode(3);
head->next->next->next = newNode(4);
head->next->next->next->next = newNode(5);
// Create a loop: 5 -> 3

head->next->next->next->next->next = head->next->next; // 5 points to 3
// Check if the list contains a loop

if (detectLoop(head)) {
printf("Loop detected in the linked list.\n");
} else {
printf("No loop detected in the linked list.\n");
}
return 0;
}
Explanation:
1. Node Structure:
The `Node` structure represents each element in the linked list, which contains an integer data
and a pointer to the next node.
2. detectLoop Function:
The function accepts the head of the linked list as input.
It initializes two pointers: `slow` and `fast`, both starting at the head.
It enters a `while` loop, where the fast pointer moves two steps and the slow pointer moves
one step.
If at any point, the slow pointer and fast pointer meet, it means there is a cycle (loop) in the
linked list.
If the fast pointer reaches the end of the list (i.e., `fast == NULL` or `fast->next == NULL`), the
function returns 0, indicating no loop.
3. Creating the Linked List:
In the `main` function, we create a simple linked list and intentionally introduce a loop where
the last node points back to the third node.
4. Output:
The program prints whether a loop was detected or not.
Time Complexity:
Time Complexity: O(n), where n is the number of nodes in the linked list. This is because, in the
worst case, both the slow and fast pointers will traverse the list only once.
Space Complexity: O(1), since we are only using two pointers (`slow` and `fast`), and we are not
using any additional data structures.
Conclusion:
This algorithm efficiently detects loops in a linked list with linear time complexity and constant space
complexity, making it ideal for detecting cycles in linked lists or similar data structures.
There is a rat running from one door to another door. The owner of the house is a lazy person and
waits at own room only. Design an algorithm of the path in such a
way that after a regular interval, the owner will get the opportunity to get catch hold of the rat.
Use the concept of circular linked list.
To design an algorithm where the rat moves from one door to another, and the owner waits at regular
intervals to catch the rat, we can model this situation using a circular linked list. In this setup:
The rat moves in a circular manner, visiting each door.

The owner, who is located at a specific room, waits at regular intervals.
After each interval, the owner has the opportunity to catch the rat, depending on the position of
the rat in the circular linked list.
Circular Linked List Concept:
In a circular linked list, the last node points back to the first node, making the list circular. This allows
us to model the rat moving around in a cycle, visiting the doors in a circular order.
Approach:
1. Circular Linked List: Each node in the list represents a door. The rat moves from one door to
another in a circular fashion.
2. Owner's Wait Time: The owner checks if the rat is at the current door at regular intervals. The
interval is based on the number of doors the rat visits before the owner checks.
3. Algorithm: The rat will traverse the circular linked list, and after a fixed number of intervals, the
owner will get a chance to catch the rat if the rat is at the current door.
Algorithm Design:
1. Create a Circular Linked List to represent the doors.

2. Simulate the movement of the rat by iterating through the list in a circular manner.
3. Owner's check: At each interval, check the position of the rat. If the rat is at the current door of the
owner, the owner can catch the rat.
Algorithm Steps:
1. Node Structure:
Each node in the circular linked list represents a door.
The rat moves in a circular fashion from one door to another.
2. Movement:
The rat moves at a fixed interval from one door to the next in the circular list.
3. Owner's Check:
The owner checks if the rat is at a specific door (say the starting door) after a fixed number of
moves (for example, after every few steps).
C Code Implementation:
#include <stdio.h>
#include <stdlib.h>
// Define a node structure for circular linked list

struct Node {
int doorNumber; // Represents the door number
struct Node* next; // Pointer to the next door in the list
};
// Function to create a new node

struct Node* newNode(int doorNumber) {
node->doorNumber = doorNumber;
node->next = NULL;
return node;
}
// Function to create a circular linked list of doors

struct Node* createCircularList(int numDoors) {
struct Node* head = newNode(1);
struct Node* current = head;
for (int i = 2; i <= numDoors; i++) {

current->next = newNode(i);
current = current->next;
}
// Make the list circular

current->next = head;
return head;
}
// Function to simulate the rat's movement and the owner's check

void simulateMovementAndCheck(struct Node* head, int numDoors, int waitInterval) {
struct Node* rat = head; // Start at the first door
struct Node* owner = head; // Owner is at door 1
int moveCount = 0; // To keep track of the number of moves
while (1) {
// Move the rat one step ahead
rat = rat->next;
moveCount++;
// Check if it's time for the owner to check

if (moveCount % waitInterval == 0) {
if (rat == owner) {
printf("Owner caught the rat at door %d!\n", owner->doorNumber);
break; // The rat is caught, exit the loop
} else {
printf("Owner is waiting at door %d, but the rat is at door %d.\n",
owner->doorNumber, rat->doorNumber);
}
}
}
}
// Main function
int main() {
int numDoors = 5; // Total number of doors
int waitInterval = 3; // Owner checks every 3 moves
// Create a circular linked list of doors

struct Node* head = createCircularList(numDoors);
// Simulate the movement of the rat and the owner's check

simulateMovementAndCheck(head, numDoors, waitInterval);
return 0;
}
Explanation of the Code:
1. Node Structure: Each node represents a door and has two fields:
`doorNumber`:The door number.
`next`:
A pointer to the next door in the list.
2. createCircularList Function: This function creates a circular linked list with `numDoors` doors. The
last node's `next` pointer points to the head of the list, making it circular.
3. simulateMovementAndCheck Function:
The rat starts at the head of the list and moves in a circular manner.
The owner checks the rat's position at regular intervals (every `waitInterval` moves).
If the rat and owner are at the same door, the owner catches the rat and the simulation ends.
If the rat is not at the owner's current door, the owner continues waiting.
4. Main Function:
Initializes the number of doors and the wait interval for the owner.
Creates the circular linked list and simulates the rat's movement and the owner's checks.
Example Output:
csharp
Owner is waiting at door 1, but the rat is at door 2.

Owner is waiting at door 1, but the rat is at door 3.
Owner caught the rat at door 1!
Time Complexity:
Time Complexity: O(n), where n is the number of doors. The rat moves through the list at each
interval, and the simulation ends when the rat is caught. In the worst case, it takes O(n) steps to
catch the rat.
Space Complexity: O(n), as we are storing the circular linked list with n nodes.
Conclusion:
This algorithm effectively models the rat's movement and the owner's opportunity to catch the rat at
regular intervals using a circular linked list. The rat's circular movement and the owner's checking
mechanism provide a simple and efficient way to simulate this scenario.
"If a binary tree is full or complete, then only it will be efficient."- Analyze the justification of the
statement.
Use the concept how height of the tree influence search time in a tree.
The statement "If a binary tree is full or complete, then only it will be efficient" has some validity, but it
requires deeper analysis in the context of how the structure of the binary tree affects operations like
searching.
Key Concepts:
1. Full Binary Tree: A full binary tree is a tree where every node has either 0 or 2 children.
2. Complete Binary Tree: A complete binary tree is a tree where every level, except possibly the last,
is completely filled, and all nodes are as left as possible on the last level.
Efficiency of Search Operations:
In any binary tree, the efficiency of search operations (such as finding a value) is often dependent on the
height of the tree, because a search in a binary tree typically involves traversing from the root to a leaf
node, potentially exploring every level. The height of a tree directly influences the search time.
Height of a Tree and Search Time:
Height of the Tree (h): The height of a binary tree is the number of edges in the longest path from
the root to a leaf node.
Search Time: The search time in a binary tree is generally O(h), where h is the height of the tree.
A balanced tree (like a complete binary tree) will have a height of approximately log2 (n), where n is the

number of nodes. This means that search operations in a balanced tree are much faster, as fewer nodes
need to be examined.
Full and Complete Binary Trees:
1. Full Binary Tree:

A full binary tree is always perfectly balanced at every level, meaning that each internal node
has exactly two children. The height of a full binary tree with n nodes will be O(log n).
Since the tree is balanced, the search time will be logarithmic in relation to the number of
nodes, making search operations efficient.
2. Complete Binary Tree:
A complete binary tree is also nearly balanced, but the last level may not be fully populated.
However, it is still filled as much as possible from left to right.
The height of a complete binary tree is also O(log n). Even though the last level may be
incomplete, the tree remains balanced enough to maintain efficient search times.
Justification for Efficiency:
Full and Complete Binary Trees:
Both types of trees minimize the height, which in turn minimizes the number of comparisons
required to search for a node. Since the height is logarithmic, the search time is also
logarithmic, making it much more efficient compared to an unbalanced binary tree, where
the height could be as large as n in the worst case, resulting in a linear search time O(n).
Impact of Tree Height:
In an unbalanced tree (for example, a degenerate or pathological tree, like a linked list), the
height can be O(n). In such cases, search operations become inefficient, as the tree
degenerates into a linear search with time complexity O(n). A full or complete binary tree
helps maintain the height at a much smaller value, ensuring efficient search operations.
Example:
Consider the following two trees:
1. Full Binary Tree:
markdown
10
\ /
5 15
/ \ / \
3 7 12 20
Height = 3. Search time = O(log n), because you would traverse 3 levels at most.
2. Unbalanced Binary Tree:
markdown
10
/
5
/
3
/
2
Height = 4. Search time = O(n), because you might have to search through each node in a linear
fashion.
Conclusion:
The efficiency of a binary tree is indeed influenced by whether it is full or complete. Full and
complete binary trees are efficient because they minimize the height of the tree, resulting in faster
search times.
Search time in a binary tree is directly related to its height: O(h). For full or complete binary
trees, the height is O(log n), ensuring that search operations remain efficient.
In contrast, unbalanced trees with large heights may have inefficient search times, especially in the
worst case where the height can be as large as n.
Use a data structure to remove duplicates and sort a given set of data
{34, 8, -4, 56, 34, 9, 7, 2, -4, 8, 23, 7, 45, -5, 14, 56, 9, 65} .
Construct a BST and perform inorder traversal of the tree.
To remove duplicates and sort the given set of data `{34, 8, -4, 56, 34, 9, 7, 2, -4, 8, 23, 7, 45,
-5, 14, 56, 9, 65}`, we can use a Binary Search Tree (BST). A BST inherently stores elements in a sorted
order, and by inserting elements into the BST, we automatically remove duplicates, as the BST does not
allow duplicate values.
Steps to solve the problem:
1. Insert elements into the BST: As we insert elements into the BST, duplicates will be automatically
discarded because each node in the BST must have a unique value.
2. Inorder Traversal: Inorder traversal of a BST will visit the nodes in ascending order, giving us the
sorted data.
Algorithm:
1. Create an empty BST.

2. Insert each element from the set into the BST.
3. Perform an inorder traversal of the BST to get the sorted elements.
C Code Implementation:
#include <stdio.h>
#include <stdlib.h>
// Define the structure for a node in the BST

struct Node {
int data;
struct Node* left;
struct Node* right;
};
// Function to create a new node

struct Node* newNode(int data) {
node->data = data;
node->left = node->right = NULL;
return node;
}
// Function to insert a node into the BST

struct Node* insert(struct Node* root, int data) {
// If the tree is empty, return a new node
if (root == NULL) {
return newNode(data);
}
// Otherwise, recur down the tree

if (data < root->data) {
root->left = insert(root->left, data);
} else if (data > root->data) {
root->right = insert(root->right, data);
}
// Return the (unchanged) node pointer

return root;
}
// Function to perform inorder traversal of the BST

void inorderTraversal(struct Node* root) {
if (root != NULL) {
inorderTraversal(root->left);
printf("%d ", root->data);
inorderTraversal(root->right);
}
}
// Main function
int main() {
// Given data
int arr[] = {34, 8, -4, 56, 34, 9, 7, 2, -4, 8, 23, 7, 45, -5, 14, 56, 9, 65};
// Create an empty BST

struct Node* root = NULL;
// Insert elements into the BST

for (int i = 0; i < n; i++) {
root = insert(root, arr[i]);
}
// Perform inorder traversal and print the sorted elements

printf("Sorted elements without duplicates: ");
inorderTraversal(root);
printf("\n");
return 0;
}
1. Node Structure: Each node in the BST holds a value (`data`) and pointers to the left and right
children.
2. newNode Function: Creates a new node with the given data.
3. insert Function: Inserts a new value into the BST. If the value is smaller than the current node, it
goes to the left subtree; if it's larger, it goes to the right subtree. Duplicates are automatically
ignored.
4. inorderTraversal Function: Performs an inorder traversal of the BST, which visits the nodes in
ascending order, printing the sorted values.
5. Main Function:
Initializes the input data.
Inserts each value into the BST.
Performs an inorder traversal to print the sorted values without duplicates.
Output:
sql
Sorted elements without duplicates: -5 -4 2 7 8 9 14 23 34 45 56 65
Explanation of the Output:
The duplicates (e.g., 34, 8, -4, 7, 56, 9) have been removed during the insertion process because the
BST does not allow duplicate values.
The elements are printed in sorted order as a result of the inorder traversal of the BST.
Time Complexity:
Insertion Time: Each insertion takes O(h) time, where h is the height of the tree. In the worst
case (unbalanced tree), the height could be O(n), making the worst-case insertion time O(n).
Inorder Traversal Time: The inorder traversal visits every node once, so the time complexity is
O(n), where n is the number of nodes in the tree.
Overall Time Complexity: The overall time complexity is O(n ⋅ h), where n is the number of
elements and h is the height of the tree. In the best case (balanced tree), h is O(log n), making the
time complexity O(n log n). In the worst case (unbalanced tree), it could be O(n2 ).
Use a data structure to arrange different jobs associated with different months with their priorities,
so that office clerk can understand which order jobs need to be done. Written as (month, (priority))
pair. Small number indicates higher priority.
March(1), February (3), April (2), May(2), January(4), December(4), September (5), October(5),
June(2), July(3), August(4), November (5).
Construct a Heap tree.
To arrange the jobs associated with different months and their priorities, we can use a Min-Heap. In a
Min-Heap, the node with the smallest value (highest priority in our case) is always at the root. This will
help us efficiently determine which job (month) needs to be done first based on priority.
Data Representation:
The data will be represented as a tuple `(month, priority)`, where the priority value is an integer. A
smaller number indicates a higher priority (e.g., priority 1 is the highest).
Given data:
March(1)
February(3)
April(2)
May(2)
January(4)
December(4)
September(5)
October(5)
June(2)
July(3)
August(4)
November(5)
Step-by-Step Construction of the Min-Heap:
1. Build the Heap: Insert each month-priority pair into a Min-Heap structure.
2. Heap Property: Ensure the smallest priority value is at the root. For each parent node, the priority
of the parent should be smaller than or equal to the priorities of its children.
Algorithm (Min-Heap Insertion):
Insert the elements one by one.

After each insertion, perform a heapify-up operation to maintain the heap property.
C Code for Min-Heap Construction:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 12 // Maximum number of months
// Define the structure for each heap node (Month, Priority pair)
struct Job {
char month[20];
int priority;
};
// Function to swap two jobs

void swap(struct Job* a, struct Job* b) {
struct Job temp = *a;
*a = *b;
*b = temp;
}
// Function to heapify the tree (ensure the heap property is maintained)

void heapify(struct Job heap[], int n, int i) {
int smallest = i; // Initialize smallest as root
int left = 2 * i + 1; // Left child index
int right = 2 * i + 2; // Right child index
// If left child is smaller than root

if (left < n && heap[left].priority < heap[smallest].priority) {
smallest = left;
}
// If right child is smaller than smallest so far

if (right < n && heap[right].priority < heap[smallest].priority) {
smallest = right;
}
// If smallest is not root

if (smallest != i) {
swap(&heap[i], &heap[smallest]);
// Recursively heapify the affected subtree

heapify(heap, n, smallest);
}
}
// Function to build the heap

void buildHeap(struct Job heap[], int n) {
// Start from the last non-leaf node and heapify each node
for (int i = n / 2 - 1; i >= 0; i--) {
heapify(heap, n, i);
}
}
// Function to insert a new job into the heap

void insert(struct Job heap[], int* n, struct Job newJob) {
// Insert the new job at the end
heap[*n] = newJob;
(*n)++;
// Heapify-up: Fix the heap property if it's violated

int i = *n - 1;
while (i > 0 && heap[(i - 1) / 2].priority > heap[i].priority) {
swap(&heap[i], &heap[(i - 1) / 2]);
i = (i - 1) / 2;
}
}
// Function to print the heap (sorted order)

void printHeap(struct Job heap[], int n) {
printf("Job list in order of priority:\n");
for (int i = 0; i < n; i++) {
printf("%s(%d) ", heap[i].month, heap[i].priority);
}
printf("\n");
}
int main() {
struct Job jobs[MAX] = {
{"March", 1},
{"February", 3},
{"April", 2},
{"May", 2},
{"January", 4},
{"December", 4},
{"September", 5},
{"October", 5},
{"June", 2},
{"July", 3},
{"August", 4},
{"November", 5}
};
int n = 0;
struct Job heap[MAX];
// Insert each job into the heap

for (int i = 0; i < MAX; i++) {
insert(heap, &n, jobs[i]);
}
// Print the heap after insertion and heapification

printHeap(heap, n);
return 0;
}
1. Job Structure: We define a structure `Job` that holds the month and its corresponding priority.
2. Heap Operations:
swap: Swaps two job entries in the heap.
heapify: Maintains the heap property by checking if a node is smaller than its children and
recursively fixing the heap.
buildHeap: Constructs the heap from an array of elements. This method is used to build the
heap before performing operations.
insert: Inserts a new job into the heap, maintaining the heap property using a "heapify-up"
process.
3. printHeap: Prints the jobs in order of priority from the Min-Heap.
4. Main Function: It initializes the array of jobs, inserts each job into the heap, and then prints the
jobs in the order of their priority.
Output:
css
Job list in order of priority:

March(1) April(2) May(2) June(2) February(3) July(3) January(4) December(4) August(4) Novemb
er(5) September(5) October(5)
Heap Tree Construction:
1. Heapify Process: After inserting all the jobs, the heap tree is structured such that the smallest
priority value (highest priority) is at the root, and the rest of the elements are arranged in a tree-
like structure maintaining the heap property.
2. Heap Representation:
scss
March(1)
/ \
April(2) May(2)
/ \ / \
June(2) Feb(3) July(3) Jan(4) / \ /

Dec(4) Aug(4) Nov(5) Sep(5) /
Oct(5)
sql
### Time Complexity:

- **Insert Operation**: \( O(\log n) \), because after inserting the element at the end, we
need to perform heapify-up.
- **Build Heap**: \( O(n) \), because we start from the last non-leaf node and heapify each
subtree.
- **Print Operation**: \( O(n) \), simply printing each element of the heap.
Thus, the heap-based solution efficiently manages the jobs with priorities, ensuring that th
e highest-priority job is always accessible at the root of the tree.
In a palace, a group of kids playing hide and seek game. They place themselves in different rooms,
one person in one room. One of them has to find rest by exploring the path after finding anyone,
this procedure will continue till that kid able to find all. There may be some room where no can find
also. Suggest a method to conclude whether the kid can reach all the room or not.
Use Depth First Search algorithm to check the connectedness of any graph.
To determine if a kid can reach all the rooms, we can model the palace as a graph, where rooms are
represented as nodes and the paths between rooms as edges. The task is to check if all rooms (nodes)
are connected, meaning the kid can visit every room starting from any one room.
Problem Breakdown:
If the graph (representing rooms and paths) is connected, the kid can reach all the rooms starting
from any room.
To check the connectivity of the graph, we can use the Depth-First Search (DFS) algorithm. If the
DFS traversal visits all the rooms starting from any room, then the graph is connected; otherwise, it
is not.
Depth-First Search (DFS) Algorithm:
DFS explores as far as possible along each branch before backtracking. We can use it to explore the
graph and mark visited rooms. If, after the DFS, all rooms have been visited, it means the graph is
connected, and the kid can reach all rooms.
Algorithm Steps:
1. Start from any room (node) in the palace.

2. Perform DFS traversal on the graph starting from that room.
3. Keep track of visited rooms.
4. After the traversal, if all rooms are visited, the palace is connected, and the kid can reach all rooms.
If some rooms are not visited, then the graph is disconnected, and the kid cannot reach all rooms.
Assumptions:
The palace is represented as an undirected graph, where each room has a path to other rooms.
If a room has no path to any other room, it's disconnected.
Pseudocode for DFS:
#include <stdio.h>
#include <stdbool.h>
#include <stdlib.h>
#define MAX_ROOMS 100 // Maximum number of rooms
// Adjacency list representation of the graph

struct Graph {
int rooms;
bool adj[MAX_ROOMS][MAX_ROOMS]; // Adjacency matrix
};
// Function to perform DFS traversal

void dfs(struct Graph *g, int room, bool visited[]) {
// Mark the current room as visited
visited[room] = true;
// Visit all the adjacent rooms

for (int i = 0; i < g->rooms; i++) {
if (g->adj[room][i] && !visited[i]) {
dfs(g, i, visited);
}
}
}
// Function to check if the palace (graph) is connected

bool isConnected(struct Graph *g) {
bool visited[g->rooms]; // Array to keep track of visited rooms
// Initialize visited array to false

visited[i] = false;
}
// Start DFS from the first room (room 0)

dfs(g, 0, visited);
// Check if all rooms were visited

if (!visited[i]) {
return false; // Not all rooms were visited, graph is disconnected
}
}
return true; // All rooms were visited, graph is connected

}
int main() {
struct Graph g;
int n; // Number of rooms
int m; // Number of paths between rooms
// Input the number of rooms and paths

printf("Enter number of rooms (nodes): ");
scanf("%d", &n);
printf("Enter number of paths (edges): ");
scanf("%d", &m);
g.rooms = n;
// Initialize the adjacency matrix

for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
g.adj[i][j] = false;
}
}
// Input the paths (edges) between rooms

printf("Enter the paths (edges) in the format (room1, room2):\n");
for (int i = 0; i < m; i++) {
int room1, room2;
scanf("%d %d", &room1, &room2);
g.adj[room1][room2] = true;
g.adj[room2][room1] = true; // Because it's an undirected graph
}
// Check if the palace is connected

if (isConnected(&g)) {
printf("The kid can reach all rooms.\n");
} else {
printf("The kid cannot reach all rooms.\n");
}
return 0;
}

1. Graph Representation:
We use an adjacency matrix (àdj[][]`) to represent the graph. If there's a path between two
rooms, àdj[room1][room2]` and àdj[room2][room1]` are set to `true` (since the graph is
undirected).
2. DFS Function:
The `dfs` function takes the graph, the current room, and a visited array as parameters.
It marks the current room as visited and recursively visits all adjacent rooms that haven't
been visited yet.
3. Connectivity Check:
The ìsConnected` function starts the DFS from room 0 and checks if all rooms are visited.
If any room is not visited after the DFS, the graph is disconnected, and the kid can't reach all
rooms.
4. Main Function:
The program first takes the number of rooms and paths as input.
It then takes the paths between rooms and stores them in the adjacency matrix.
Finally, it checks if the graph is connected using the ìsConnected` function and prints the
result.
Example Input/Output:
Input:
java
Enter number of rooms (nodes): 5

Enter number of paths (edges): 4
Enter the paths (edges) in the format (room1, room2):
0 1
1 2
2 3
3 4
Output:
css
The kid can reach all rooms.
Input:
java
Enter number of rooms (nodes): 5

Enter number of paths (edges): 2
Enter the paths (edges) in the format (room1, room2):
0 1
2 3
Output:
css
The kid cannot reach all rooms.
Time Complexity:
The time complexity of DFS is O(V + E), where:

V is the number of rooms (nodes).
E is the number of paths (edges).
This is because we visit each room once and check each path once during the DFS traversal.
Thus, this algorithm efficiently checks if all rooms are connected and whether the kid can reach all the
rooms in the palace.
Analyze the requirement of sorted data in regular intervals for the application of interpolation
search. Explain with an example.
Take two types of sorted data, one with regular interval and another with irregular interval. Apply
te algorithm and count number of steps to find the data.
Interpolation Search Analysis
Interpolation Search is an efficient search algorithm that works on sorted data, specifically when the
data is uniformly distributed (or nearly uniformly distributed) across the range. The primary idea behind
interpolation search is to estimate the position of the search key based on its value, similar to how one
might interpolate between data points in a continuous function.
The formula used in interpolation search is:
(key − arr[low]) ⋅ (high − low)

Position = low + ( )
arr[high] − arr[low]

This formula calculates a position based on the assumption that the key will lie at a specific index based
on its value and the distribution of values between the low and high indices.
Conditions for Interpolation Search:
Sorted data: The data must be sorted in increasing (or decreasing) order.
Uniformly distributed data: For best performance, the data should be approximately uniformly
distributed. The search performance is drastically improved when the values are regularly spaced,
as it avoids unnecessary steps.
Example 1: Data with Regular Interval
Consider an array àrr = [10, 20, 30, 40, 50, 60, 70, 80, 90, 100]` where each element is spaced by
a constant difference of 10.
Search Key: 70
Steps in Interpolation Search:
1. Initial low = 0, high = 9, and the key is 70.

2. Estimate the position using the interpolation formula:
(70 − 10) ⋅ (9 − 0) 60 ⋅ 9
Position = 0 + ( )=0+( )=6
100 − 10 90

3. Check àrr[6] = 70`. The key is found at index 6.
Total Steps:
Only 1 step required to find the element.
Example 2: Data with Irregular Interval
Consider an array àrr = [10, 20, 40, 80, 150, 300, 500, 800, 1200, 1500]` where the elements are
not uniformly distributed.
Search Key: 300
Steps in Interpolation Search:
1. Initial low = 0, high = 9, and the key is 300.

2. Estimate the position using the interpolation formula:
(300 − 10) ⋅ (9 − 0) 290 ⋅ 9

Position = 0 + ( )=0+( ) ≈ 1.74
1500 − 10 1490

The calculated position is 1. However, the value at index 1 is `20`, and we know the value must be
larger.
3. Now adjust the search to the range between indices 1 and 9.
4. Recalculate the position and repeat the process until you find the key.
After several recalculations, the key `300` will be found at the correct index (5).
Total Steps:
It takes several recalculations, but the number of steps will be more than 1 step due to the
irregular intervals and need for adjusting the range.
Step Count Comparison:
Data Type Regular Interval Search Steps Irregular Interval Search Steps
Sorted Data with Regular Multiple recalculations (more than 1

1 step (direct hit)
Interval step)
Sorted Data with Irregular N/A (not ideal for interpolation
Several steps, recalculation needed
Interval search)
Analysis:
1. Regular Interval Data:

Interpolation search performs very well because the search key's estimated position is
usually close to the actual position. The search can pinpoint the key in one step if the
distribution is perfect, as the key is evenly spaced across the array.
2. Irregular Interval Data:
In this case, interpolation search struggles because the positions of the elements are not
evenly distributed. The formula gives a rough estimate that often needs to be adjusted
multiple times. This causes more steps than in the regular interval case, potentially
approaching a linear search in performance.
When the distribution is highly skewed, interpolation search can even perform worse than
binary search.
Time Complexity:
Best Case: O(log log n) when the data is uniformly distributed.

Average Case: O(log log n) for moderately distributed data.
Worst Case: O(n), when the data is irregularly distributed or highly skewed.
Conclusion:
Interpolation search is an efficient algorithm when applied to uniformly distributed and sorted data.
However, its performance significantly drops with irregularly spaced data because the algorithm
cannot accurately estimate the key's position, leading to increased steps. For data with irregular
intervals, a more reliable search algorithm like binary search should be preferred.
Analyze the performance of quick sort if input data is already sorted.
Discuss worst case scenario of quick sort.
Performance of Quick Sort on Sorted Data
Quick sort is a divide-and-conquer algorithm that, in the best case, splits the array into two nearly equal
parts and performs a recursive sort on each part. The performance of quick sort heavily depends on the
choice of the pivot and how the data is distributed.
When the input data is already sorted, quick sort's performance can degrade, especially when using
naive pivot selection strategies. The behavior depends on how the pivot is selected during the
partitioning step.
Common Pivot Selection Strategies:
1. First Element as Pivot:

If the pivot is always selected as the first element (or last element), the sorted data leads to an
unbalanced partition. The algorithm will end up creating one partition with n − 1 elements
and another partition with 0 elements (i.e., one sub-array is empty).
This results in O(n) recursive calls, with each partitioning step taking O(n) time, leading to a
time complexity of O(n^2).
2. Random Pivot Selection:
Even with random pivot selection, if the data is already sorted, there is still a chance that the
pivot ends up being near the extremes (first or last element) in many cases, especially in small
partitions, causing a suboptimal partitioning.
The worst case still can approach O(n^2) in certain conditions.
3. Median-of-Three Pivot Selection:
This strategy generally works better by selecting the pivot as the median of the first, middle,
and last elements. Although this improves the partitioning for sorted or nearly sorted data, it
can still degrade to O(n^2) if the pivot selection doesn't create balanced partitions.
Worst Case Scenario of Quick Sort
The worst-case scenario for quick sort occurs when the pivot selected at each step is the smallest or
largest element, leading to unbalanced partitions. This happens when:
The array is already sorted or nearly sorted (increasing or decreasing order).

The pivot selection strategy is poor (e.g., always selecting the first or last element).
In the worst case:
Partitioning: Each partition only reduces the problem size by 1 (i.e., one sub-array contains n − 1
elements, and the other contains 0).
Recursive Depth: This leads to a recursion depth of O(n).
Time Complexity: The time taken to partition the array is O(n) for each recursive call, and since
there are O(n) recursive calls, the overall time complexity is O(n^2).
Analysis of Worst Case:
1. Pivot Selection and Array Size:

At each step, the array is partitioned into two sub-arrays: one with n − 1 elements and the
other with 0 elements.
This creates unbalanced splits, meaning that quick sort performs much worse than its
average case where it splits the array more evenly.
2. Worst Case Time Complexity:
The time complexity of quick sort in the worst case is O(n^2) because it needs to perform
O(n) comparisons in each of O(n) recursive calls, leading to quadratic performance.
Example of Worst Case for Quick Sort:
Consider the sorted array:

`[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]`
If we choose the first element as the pivot:
1. First partition: Pivot = 1, sub-arrays are `[]` (left) and `[2, 3, 4, 5, 6, 7, 8, 9, 10]` (right).
2. Second partition: Pivot = 2, sub-arrays are `[]` (left) and `[3, 4, 5, 6, 7, 8, 9, 10]` (right).
3. Repeat the same process for each subsequent pivot, resulting in a recursion depth of O(n) and
O(n^2) comparisons.
Mitigating the Worst Case:
Randomized Quick Sort: Randomly selecting the pivot ensures that, on average, the algorithm will
perform better than O(n2 ), even for sorted data. The expected time complexity becomes O(n log
n).
Median-of-Three: This strategy is another optimization that can reduce the likelihood of
unbalanced partitions in sorted data.
Conclusion:
Time Complexity:
Best case: O(n log n), when the array is divided evenly.
Worst case: O(n2 ), when the array is sorted and the pivot selection leads to unbalanced
partitions.
Average case: O(n log n), which is typically the case when the pivot divides the array fairly
evenly.
Impact on Sorted Data:
Quick sort's performance can degrade to O(n^2) if the data is already sorted and poor pivot
selection is used.
To avoid the worst-case scenario, randomized pivot selection or median-of-three pivot
selection is often used to ensure better performance in most cases.
In a office, similar types of confidential documents are kept in the same vaults. Similar types of
documents can be
recognized by their level of confidentiality. Also, vaults are of limited capacity, each of them can
keep 'x' number of documents. If
there are total 'n' number of documents, then suggest a method to manage this situation.
A heap tree can be used to categorize files as per their confidentiality level. As it is a complete tree,
calculate the minimum size of the array (number of vaults). Also, calculate the maximum number
of vaults and use a simple modulo hash function to accommodate files with linear probing.
Problem Breakdown
You have a total of n confidential documents, and the goal is to categorize and store them in vaults
based on their confidentiality levels. Given that each vault can store x documents, we can use a heap
tree to categorize the documents according to their confidentiality level.
1. Heap Tree for Categorization
A heap is a complete binary tree where:
In a max-heap, each parent node has a greater or equal value than its children.
In a min-heap, each parent node has a smaller or equal value than its children.
In this case, we can assume that the confidentiality level is represented as a value, and we use a max-
heap or min-heap to prioritize the documents.
2. Minimum Number of Vaults (Array Size)
The minimum size of the array (number of vaults) is essentially the number of unique confidentiality
levels or the number of different categories of documents. The heap tree will help us categorize the
documents into these levels. If there are m different levels, then you will need at least m vaults to store
documents from each level.
However, to calculate the minimum number of vaults in terms of space management, we consider
the heap's structure. For a heap of n documents:
The number of nodes in the heap is n.

A heap is a complete binary tree, and its total number of nodes can be represented by an array of
size n.
Thus, the minimum size of the array (or the number of vaults) is n, as each document will be assigned
a vault based on its confidentiality level.
3. Maximum Number of Vaults
To calculate the maximum number of vaults, we consider the worst-case scenario where every vault
might only contain one document. In this case, the number of vaults will be equal to the number of
documents, i.e., n vaults.
4. Modulo Hash Function for Vault Assignment
To distribute the documents across the vaults efficiently, we can use a hash function based on the
document's confidentiality level. A simple hash function is:
javascript
hash(document) = document.confidentiality_level % number_of_vaults
If two documents collide (i.e., they hash to the same vault), we can use linear probing to find the next
available vault.
Linear Probing: If the vault is already occupied, check the next vault (increment by 1) until an
empty vault is found.
5. Summary of Method
1. Categorize documents using a heap tree:

Construct a max-heap or min-heap to organize documents by their confidentiality level.
The heap structure ensures that documents with higher (or lower) levels are placed correctly
based on priority.
2. Determine the minimum and maximum number of vaults:
Minimum vaults: Equal to the number of documents, i.e., n.
Maximum vaults: One vault per document, i.e., n vaults.
3. Use a hash function for efficient vault assignment:
Apply modulo hash to map documents to vaults based on their confidentiality level.
Use linear probing for collision resolution if two documents hash to the same vault.
6. Example
Assume we have 10 documents, with the following confidentiality levels: `[5, 8, 10, 3, 7, 1, 9, 6, 2,
4]`
We need to store these documents in vaults, each vault holding up to 3 documents.

Use a max-heap to prioritize them based on confidentiality level.
Let's say we have 5 vaults (i.e., we want to store documents in 5 vaults).
1. Heapify the documents:

Arrange the documents in a heap structure based on their confidentiality levels.
2. Hash function:
For simplicity, assume the confidentiality level modulo 5 (i.e., 5 vaults) will determine where
each document goes:
scss
hash(5) = 5 % 5 = 0
hash(8) = 8 % 5 = 3
hash(10) = 10 % 5 = 0 (collision with hash(5))
hash(3) = 3 % 5 = 3 (collision with hash(8))
3. Resolve collisions with linear probing:

Place the documents in the vaults using linear probing to resolve any hash collisions.
Final Vaults:
Vault 0: [5, 10]

Vault 1: [1]
Vault 2: [2]
Vault 3: [8, 3]
Vault 4: [4, 7, 9]
The algorithm efficiently categorizes and places documents in vaults based on their confidentiality
levels, and uses linear probing to resolve hash collisions.
Consider a double hashing scheme in which the primary hash function is

h1(k)=k mod 23, and the secondary hash function is h2(k)=1+(k mod 19).
Assume that the table size is 23. Then calculate the address returned by probe 1 in the probe
sequence (assume that the probe sequence begins at probe 0) for key value k=90.
Study double hashing method
Double Hashing Scheme
In double hashing, two hash functions are used:
1. Primary hash function: h1 (k)
2. Secondary hash function: h2 (k)
When a collision occurs (i.e., the address returned by h1 (k) is already occupied), the secondary hash

function is used to compute a step size for the next probe. The next probe address is calculated using
the formula:
Address at probe i = (h1 (k) + i × h2 (k)) mod Table Size

Where:
i is the probe number (starting at 0 for the first probe).

h1 (k) is the primary hash function.

h2 (k) is the secondary hash function.

Table Size is the size of the hash table, which is 23 in this case.
Given Data
Primary Hash Function: h1 (k) = k mod 23

Secondary Hash Function: h2 (k) = 1 + (k mod 19)
Table Size: 23
Key: k = 90
Step 1: Calculate h1 (k)
Using the primary hash function:
h1 (90) = 90 mod 23 = 90 − (23 × 3) = 90 − 69 = 21

So, h1 (90)
= 21.
Step 2: Calculate h2 (k)
Using the secondary hash function:
h2 (90) = 1 + (90 mod 19) = 1 + (90 − (19 × 4)) = 1 + (90 − 76) = 1 + 14 = 15

So, h2 (90)
= 15.
Step 3: Calculate the Address for Probe 1
Now, to find the address at probe 1:
Address at probe 1 = (h1 (90) + 1 × h2 (90)) mod 23

Substitute the values of h1 (90) and h2 (90):

Address at probe 1 = (21 + 1 × 15) mod 23 = (21 + 15) mod 23 = 36 mod 23 = 13
Final Result
The address returned by probe 1 in the probe sequence for key k = 90 is 13.
Explain the concept of Insertion Sort and how it works to sort a list of elements. Provide a step-by-
step example to illustrate the sorting process. Discuss the time complexity of Insertion Sort and its
best and worst-case scenarios.
Discuss the working process of insertion sort
Concept of Insertion Sort
Insertion Sort is a simple and efficient comparison-based sorting algorithm that builds the final sorted
list one item at a time. It works similarly to how you might sort playing cards in your hands: you take one
card at a time and place it in its correct position among the already sorted cards.
Working Process of Insertion Sort
1. Initial State: The algorithm starts with the second element (since a single element is trivially
sorted) and compares it with the element(s) before it, shifting elements to the right as needed.
2. Key Element: The current element is called the "key" and is compared to the elements before it to
find its correct position.
3. Shifting Elements: If the current element is smaller than an element before it, that element is
shifted one position to the right.
4. Insert Key: Once the correct position is found (where all elements before are smaller and all after
are larger), the key element is inserted at that position.
5. Repeat: The process repeats for every element in the list until the entire list is sorted.
Step-by-Step Example
Let's consider the list of elements:
`[5, 2, 9, 1, 5, 6]`
Step 1: Start with the second element (key = 2)
Compare 2 with 5. Since 2 is smaller than 5, shift 5 to the right.

Insert 2 in the first position.
List after this step: `[2, 5, 9, 1, 5, 6]`
Step 2: Move to the next element (key = 9)
Compare 9 with 5. Since 9 is larger than 5, no shift is needed.

Insert 9 in its current position.

Insert 1 in the first position.

Compare 5 with 5. Since 5 is equal to 5, no shift is needed.
Insert 5 in the third position.

Compare 6 with 5. Since 6 is larger than 5, no shift is needed.
Insert 6 in the fifth position.
Final Sorted List: `[1, 2, 5, 5, 6, 9]`
Time Complexity of Insertion Sort
Best-case scenario: When the list is already sorted (or nearly sorted), the time complexity is O(n).
This is because each element only needs to be compared once with its predecessor, and no shifting
occurs.
Worst-case scenario: When the list is in reverse order, every element needs to be compared with
all previous elements and shifted. In this case, the time complexity is O(n²).
Average-case scenario: The average time complexity is also O(n²), as on average, each element
will have to be compared and shifted about half of the previous elements.
Time Complexity Breakdown

Time Complexity:
Best Case: O(n) (Already sorted or nearly sorted)
Worst Case: O(n²) (Reverse order)
Average Case: O(n²) (Random order)
Space Complexity: O(1), because insertion sort is an in-place sorting algorithm, meaning it only
uses a constant amount of extra space.
Summary
Insertion Sort is efficient for small datasets or nearly sorted lists.

It is easy to implement and understand but performs poorly on large datasets due to its O(n²) time
complexity in the average and worst cases.
Its best case is O(n) when the list is already sorted or nearly sorted.

Module 4

Uploaded by

Copyright:

Available Formats

Module 4

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Module 4

Uploaded by

Copyright:

Available Formats

Module 4

Worst-Case Scenario for Linear Search:

Based on the Hint:

1. Not present in the array.

1. Procedure of Linear Search:

1. Initialize a loop starting from the first element.

Program (in C):

int linearSearch(int arr[], int n, int key) {

Best Case: O(1) (Element is at the first position).

Number of Interchanges Required for Bubble Sort:

Based on the Hint:

Given the array: 5, 1, 6, 24

Step-by-Step Bubble Sort:

1 interchange in the first pass.

Relate to a method of sorting which resembles the technique of playing cards.

Relating to Playing Cards:

Insertion Sort Process:

1. Start with 1 (second element). It is smaller than 5, so it is inserted before 5.

Test radix sort on the following list:

Radix Sort Process (Least Significant Digit to Most Significant Digit):

Steps for Radix Sort:

1. Sort by Least Significant Digit (unit place):

Final Sorted List:

Start by recalling the meaning of time complexity of different searching techniques

Time Complexity of Searching Techniques:

Binary Search Algorithm:

Steps of Binary Search:

Target 17 is found at index 5.

Time Complexity Analysis:

Merge Sort is a divide and conquer sorting algorithm. It works by:

1. Dividing the array into two halves.

Optimizing Merge Sort for a Partially Sorted Array:

1. Check for Sorted Subarrays:

Optimized Algorithm (Hybrid Merge Sort):

void insertionSort(int arr[], int left, int right) {

void merge(int arr[], int left, int mid, int right) {

int L[n1], R[n2];

void optimizedMergeSort(int arr[], int left, int right) {

for (int i = 0; i < n; i++) {

Explanation of the Optimized Approach:

Recall different collision resolution strategies in hashing.

Collision Resolution Strategies in Hashing:

Proposed New Approach: Dynamic Hybrid Hashing (DHH)

1. Dynamic Hybrid Hashing (DHH):

// Function to perform Insertion Sort

// Function to print the array

printf("Original array: \n");

insertionSort(arr, n); // Call Insertion Sort

printf("Sorted array: \n");

Best Case: O(n) (when the array is already sorted).

Binary Search Procedure for the Given List

Binary Search Procedure:

1. Initialize the start and end indices:

Steps to Find the Key `85`:

The key `85` is found at index 7 in the array.

function binarySearch(arr, start, end, key):

Write the name of the sorting technique which is

Perform insertion sort in this sorting technique.

Insertion Sort Procedure:

Insertion Sort Algorithm for the List: