Scribd
Upload
5 views3 pages

DAA Lab 3

The document discusses three sorting algorithms: Bucket Sort, Dutch National Flag Algorithm, and Merge Intervals. Bucket Sort distributes elements into buckets for sorting, while the Dutch National Flag Algorithm sorts an array with three distinct values efficiently. The Merge Intervals problem involves merging overlapping intervals, utilizing a greedy approach with a time complexity of O(n log n) due to sorting.

Uploaded by

id.yogeshgarg
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
5 views3 pages

DAA Lab 3

The document discusses three sorting algorithms: Bucket Sort, Dutch National Flag Algorithm, and Merge Intervals. Bucket Sort distributes elements into buckets for sorting, while the Dutch National Flag Algorithm sorts an array with three distinct values efficiently. The Merge Intervals problem involves merging overlapping intervals, utilizing a greedy approach with a time complexity of O(n log n) due to sorting.

Uploaded by

id.yogeshgarg
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 3

Experiment -3

Bucket Sort and Other Problems


(1) Bucket Sort

Description:
Bucket Sort is a sorting algorithm that distributes elements into a number of buckets, sorts each bucket
individually (often using another sorting algorithm like insertion sort), and then concatenates the sorted
buckets. It is efficient when input values are uniformly distributed over a known range.

Algorithm Code (C++):


void bucket_sort(vector<float> &arr) {
int n = arr.size(); int main() {
vector<vector<float>> buckets(n); vector<float> arr = {0.42, 0.32, 0.23, 0.52,
for (int i = 0; i < n; i++) { 0.25, 0.47, 0.51};
int index = n * arr[i]; // Assuming values are bucket_sort(arr);
in the range [0,1)
buckets[index].push_back(arr[i]); for (float x : arr) {
} cout << x << " ";
for (int i = 0; i < n; i++) { }
sort(buckets[i].begin(), buckets[i].end()); return 0;
} }
int index = 0;
for (int i = 0; i < n; i++) { Output:
for (float value : buckets[i]) {
arr[index++] = value;
}
}
}

Analysis:
- Worst case: When all elements fall into a single bucket, causing sorting within that bucket to be inefficient.
- Best case: When elements are uniformly distributed across buckets, and each bucket has very few elements.
- Average case: O(n + k), where n is the number of elements and k is the number of buckets. If an efficient
sorting algorithm like insertion sort is used inside buckets, it can perform close to O(n) for small buckets.

Optimization:
- Adaptive Bucket Size: Choosing the right number of buckets dynamically instead of a fixed count can
improve efficiency.
- Efficient Sorting Inside Buckets: If the number of elements in each bucket is small, using Insertion Sort
(O(n²)) is optimal, while Quick Sort or Merge Sort can be used for larger buckets.
Complexity Analysis Table:

Case Time Complexity Space Complexity

Best Case O(n + k) O(n + k)


Average Case O(n + k) O(n + k)

Worst Case O(n²) (if all elements fall into one bucket) O(n + k)

(2) Dutch National Flag Algorithm

Description:
The Dutch National Flag Algorithm is a sorting algorithm that efficiently sorts an array containing three
distinct values, typically 0, 1, and 2. It works by maintaining three pointers (low, mid, and high) and swapping
elements to place them in the correct partition. This algorithm is commonly used to solve problems involving
three-way partitioning, such as sorting colors in an array where: 0 represents red, 1 represents white and 2
represents blue.

Algorithm Code (C++):


void dutch_national_flag(vector<int> &arr) { int main() {
int low = 0, mid = 0, high = arr.size() - 1; vector<int> arr = {2, 0, 2, 1, 1, 0};
while (mid <= high) { dutch_national_flag(arr);
if (arr[mid] == 0) {
swap(arr[low], arr[mid]); for (int x : arr) {
low++; cout << x << " ";
mid++; }
} else if (arr[mid] == 1) { return 0;
mid++; }
} else {
swap(arr[mid], arr[high]); Output:
high--;
}
}}

Analysis:
- Worst case: O(n) when all elements must be moved.
- Best case: O(n) since each element is processed at most once.
- Average case: O(n) as only a single pass is required.

Optimisation:
- Efficient Memory Usage: Operates in O(1) extra space since sorting is done in place.
- Linear Time Complexity: Unlike traditional sorting algorithms (O(n log n)), this runs in O(n), making it
optimal for sorting three distinct elements.

Complexity Analysis Table:

Case Time Complexity Space Complexity

Worst O(n) O(1)

Best O(n) O(1)


Average O(n) O(1)

(3)Merge Subintervals

Description:
The Merge Overlapping Intervals problem involves merging intervals that overlap into a single interval.
Given a list of intervals where each interval is represented as [start, end], the goal is to merge overlapping
intervals while maintaining non-overlapping intervals as they are.
The greedy approach ensures that we process intervals in sorted order, merging only when necessary, which
leads to an optimal O(n log n) time complexity due to sorting.

Algorithm Code (C++):


vector<vector<int>>merge_intervals(vector<vecto int main() {
r<int>> &intervals) { vector<vector<int>> intervals = {{1, 3}, {2, 6},
if (intervals.empty()) return {}; {8, 10}, {15, 18}};
sort(intervals.begin(), intervals.end()); vector<vector<int>> result =
vector<vector<int>> merged; merge_intervals(intervals);
merged.push_back(intervals[0]);
for (int i = 1; i < intervals.size(); i++) { for (auto interval : result) {
if (merged.back()[1] >= intervals[i][0]) { cout << "[" << interval[0] << ", " <<
merged.back()[1] = max(merged.back()[1], interval[1] << "] ";
intervals[i][1]); }
} else { return 0;
merged.push_back(intervals[i]);} }
} Output:
return merged;
}

Analysis:
- Worst case: O(n log n) (due to sorting)
- Best case: O(n) (if already sorted and non-overlapping)
- Average case: O(n log n) (sorting + linear traversal)

Optimisation:
1. Sorting in O(n log n): Sorting ensures intervals are processed in order.
2. Single Pass Merging: The merging step runs in O(n), making the approach efficient.
3. In-place Merging Possible: Can be optimized further by modifying the input list.

Complexity Analysis Table:

Case Time Complexity Space Complexity

Worst O(n) O(1) (if modifying input)

Best O(n log n) O(n) (new merged intervals)


Average O(n log n) O(n)

You might also like