Scribd
Upload
4 views

DSA Lab Manual(Counting sort)

The document provides a lab manual for implementing the Counting Sort algorithm in C++, detailing its objectives, theory, steps, advantages, and disadvantages. It includes the algorithm's code, sample input/output, and viva questions to assess understanding. The conclusion emphasizes Counting Sort's efficiency for known range datasets while noting its limitations with large ranges.

Uploaded by

Irfan Ul Haq
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
4 views

DSA Lab Manual(Counting sort)

The document provides a lab manual for implementing the Counting Sort algorithm in C++, detailing its objectives, theory, steps, advantages, and disadvantages. It includes the algorithm's code, sample input/output, and viva questions to assess understanding. The conclusion emphasizes Counting Sort's efficiency for known range datasets while noting its limitations with large ranges.

Uploaded by

Irfan Ul Haq
Copyright
© © All Rights Reserved
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 4

Data Structures and Algorithms Lab Manual

Experiment: Counting Sort Implementation

Objective:

To understand and implement the Counting Sort algorithm using C++ and analyze its working.

Theory:

Counting Sort is a non-comparison-based sorting algorithm that sorts integers by counting the
occurrences of each element. It works efficiently for integers or objects that can be mapped to a
range of integers. The algorithm assumes that the range of the input data is known beforehand.

Steps of Counting Sort:

1. Determine the range of the input (minimum and maximum values).


2. Create a count array to store the frequency of each element.
3. Update the count array to hold cumulative counts.
4. Build the sorted array by placing elements at their correct positions using the cumulative
count array.
5. Copy the sorted array back to the original array.

Advantages:

 Time complexity is O(n + k), where n is the number of elements and k is the range of
input values.
 Suitable for sorting datasets with small integer ranges.

Disadvantages:

 Requires extra space for the count array.


 Not efficient for large ranges.

Algorithm:

void countingSort(int arr[], int n) {


// Step 1: Find the maximum element
int max = *max_element(arr, arr + n);
int min = *min_element(arr, arr + n);
int range = max - min + 1;

// Step 2: Create count array and initialize to 0


vector<int> count(range, 0);
// Step 3: Store frequency of each element
for (int i = 0; i < n; i++) {
count[arr[i] - min]++;
}

// Step 4: Update count array to store cumulative counts


for (int i = 1; i < range; i++) {
count[i] += count[i - 1];
}

// Step 5: Build the sorted array


vector<int> output(n);
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}

// Step 6: Copy the sorted array back to the original array


for (int i = 0; i < n; i++) {
arr[i] = output[i];
}
}

Program Code:

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

void countingSort(int arr[], int n) {


int max = *max_element(arr, arr + n);
int min = *min_element(arr, arr + n);
int range = max - min + 1;

vector<int> count(range, 0);

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


count[arr[i] - min]++;
}

for (int i = 1; i < range; i++) {


count[i] += count[i - 1];
}

vector<int> output(n);
for (int i = n - 1; i >= 0; i--) {
output[--count[arr[i] - min]] = arr[i];
}

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


arr[i] = output[i];
}
}
int main() {
int n;
cout << "Enter the number of elements: ";
cin >> n;

int arr[n];
cout << "Enter the elements: ";
for (int i = 0; i < n; i++) {
cin >> arr[i];
}

countingSort(arr, n);

cout << "Sorted array: ";


for (int i = 0; i < n; i++) {
cout << arr[i] << " ";
}
return 0;
}

Sample Input/Output:

Input:

Enter the number of elements: 6


Enter the elements: 4 2 2 8 3 3

Output:

Sorted array: 2 2 3 3 4 8

Observations:

Test Case Input Output


1 422833 223348
2 1412752 1122457
3 10 20 15 10 5 30 5 10 10 15 20 30

Viva Questions:

1. What is the time complexity of Counting Sort?


2. Can Counting Sort handle negative numbers? Why or why not?
3. How does Counting Sort differ from comparison-based sorting algorithms?
4. What is the space complexity of Counting Sort?
5. In which scenarios would Counting Sort not be a suitable choice?
Conclusion:

The Counting Sort algorithm is an efficient method for sorting data with a known range. It
avoids comparisons by using frequency counts, making it faster for certain datasets. However, it
is not ideal for datasets with large ranges due to high space requirements.

You might also like