Counting sort
Counting sort is a sorting algorithm that works on integer keys within a specific range. It works by counting the number of objects with each distinct key value and using arithmetic to determine the position of each object in the output sequence without comparing elements. The algorithm uses three arrays: an input array, an output array, and a counting array. It iterates through the input array to count the frequency of each key value in the counting array. Then iterates through the counting array to calculate cumulative frequencies, and finally iterates through the input array again to place each object in the output array based on its key value's counted position. Counting sort runs in O(n+k) time where n is the number of elements and k is the maximum key
![Counting sort assumes that each of the n input elements is an integer
in the range 0 to k. that is n is the number of elements and k is the
highest value element.
Consider the input set : 4, 1, 3, 4, 3. Then n=5 and k=4.
The algorithm uses three array:
Input Array: A[1..n] store input data where A[j] ∈ {1, 2, 3, …, k}
Output Array: B[1..n] finally store the sorted data
Temporary Array: C[0..k] store data temporarily](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-4-320.jpg)
![1. Counting-Sort(A, B, k)
2. Let C[0…..k] be a new array
3. for i=0 to k [Loop 1]
4. C[i]= 0;
5. for j=1 to A.length( or n) [Loop 2]
6. C[ A[j] ] = C[ A[j] ] + 1;
7. for i=1 to k [Loop 3]
8. C[i] = C[i] + C[i-1];
9. for j=n or A.length down to 1 [Loop 4]
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-5-320.jpg)
![[LOOP1]
For i=0 to k
c[i]=0;
2 5 3 0 2 3 0 3
0 0 0 0 0 0
B:
C:
A:
1 2 3 4 5 6 7 8
0 1 2 3 4 5
1 2 3 4 5 6 7 8](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-6-320.jpg)
![[Loop 2]
5. for j=1 to A.length( or n)
6. C[ A[j] ] = C[ A[j] ] + 1;
2 5 3 0 2 3 0 3
2 0 2 3 0 1
B:
C:
A:
1 2 3 4 5 6 7 8
0 1 2 3 4 5
1 2 3 4 5 6 7 8](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-7-320.jpg)
![[Loop 3]
7. for i=1 to K
8. C[i] = C[i] + C[i-1];
2 5 3 0 2 3 0 3
2 0 2 3 0 1
C:
C:
A:
0 1 2 3 4 5
1 2 3 4 5 6 7 8
2 2 2 3 0 1
0 1 2 3 4 5](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-8-320.jpg)
![[Loop 3]
7. for i=1 to K
8. C[i] = C[i] + C[i-1];
2 5 3 0 2 3 0 3
2 0 2 3 0 1
C:
C:
A:
0 1 2 3 4 5
1 2 3 4 5 6 7 8
2 2 4 7 7 8
0 1 2 3 4 5](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-9-320.jpg)
![9. for j=n or A.length down to 1
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;
2 5 3 0 2 3 0 3
B:
C:
A:
0 1 2 3 4 5
1 2 3 4 5 6 7 8
2 2 4 7 7 8
[Loop 4]
1 2 3 4 5 6 7 8
3
3
7
7
3](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-10-320.jpg)
![9. for j=n or A.length down to 1
10. B[ C[ A[j] ] ] = A[j];
11. C[ A[j] ] = C[ A[j] ] - 1;
2 5 3 0 2 3 0 3
B:
C:
A:
0 1 2 3 4 5
1 2 3 4 5 6 7 8
2 2 4 6 7 8
[Loop 4]
3
1 2 3 4 5 6 7 8
0
0
2
2
0](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-11-320.jpg)
![END OF LOOP [Loop 4]
2 5 3 0 2 3 0 3
0 2 2 4 7 7
B:
C:
A:
0 1 2 3 4 5
1 2 3 4 5 6 7 8
0 0 2 2 3 3 3 5
1 2 3 4 5 6 7 8](https://image.slidesharecdn.com/countingsort-181212171303/85/Counting-sort-12-320.jpg)
Counting sort
- 2. TODAY’S TOPIC ABOUT COUNTING SORT BY:SYED SALAHUDDIN AHMED AND IMDAD-UL-HAQ
- 3. COUNTING SORT Counting sort is a sorting technique based on keys between a specific range. It works by counting the number of objects having distinct key values (kind of hashing). Then doing some arithmetic to calculate the position of each object in the output sequence. In this sorting we didn’t compare elements while sorting.
- 4. Counting sort assumes that each of the n input elements is an integer in the range 0 to k. that is n is the number of elements and k is the highest value element. Consider the input set : 4, 1, 3, 4, 3. Then n=5 and k=4. The algorithm uses three array: Input Array: A[1..n] store input data where A[j] ∈ {1, 2, 3, …, k} Output Array: B[1..n] finally store the sorted data Temporary Array: C[0..k] store data temporarily
- 5. 1. Counting-Sort(A, B, k) 2. Let C[0…..k] be a new array 3. for i=0 to k [Loop 1] 4. C[i]= 0; 5. for j=1 to A.length( or n) [Loop 2] 6. C[ A[j] ] = C[ A[j] ] + 1; 7. for i=1 to k [Loop 3] 8. C[i] = C[i] + C[i-1]; 9. for j=n or A.length down to 1 [Loop 4] 10. B[ C[ A[j] ] ] = A[j]; 11. C[ A[j] ] = C[ A[j] ] - 1;
- 6. [LOOP1] For i=0 to k c[i]=0; 2 5 3 0 2 3 0 3 0 0 0 0 0 0 B: C: A: 1 2 3 4 5 6 7 8 0 1 2 3 4 5 1 2 3 4 5 6 7 8
- 7. [Loop 2] 5. for j=1 to A.length( or n) 6. C[ A[j] ] = C[ A[j] ] + 1; 2 5 3 0 2 3 0 3 2 0 2 3 0 1 B: C: A: 1 2 3 4 5 6 7 8 0 1 2 3 4 5 1 2 3 4 5 6 7 8
- 8. [Loop 3] 7. for i=1 to K 8. C[i] = C[i] + C[i-1]; 2 5 3 0 2 3 0 3 2 0 2 3 0 1 C: C: A: 0 1 2 3 4 5 1 2 3 4 5 6 7 8 2 2 2 3 0 1 0 1 2 3 4 5
- 9. [Loop 3] 7. for i=1 to K 8. C[i] = C[i] + C[i-1]; 2 5 3 0 2 3 0 3 2 0 2 3 0 1 C: C: A: 0 1 2 3 4 5 1 2 3 4 5 6 7 8 2 2 4 7 7 8 0 1 2 3 4 5
- 10. 9. for j=n or A.length down to 1 10. B[ C[ A[j] ] ] = A[j]; 11. C[ A[j] ] = C[ A[j] ] - 1; 2 5 3 0 2 3 0 3 B: C: A: 0 1 2 3 4 5 1 2 3 4 5 6 7 8 2 2 4 7 7 8 [Loop 4] 1 2 3 4 5 6 7 8 3 3 7 7 3
- 11. 9. for j=n or A.length down to 1 10. B[ C[ A[j] ] ] = A[j]; 11. C[ A[j] ] = C[ A[j] ] - 1; 2 5 3 0 2 3 0 3 B: C: A: 0 1 2 3 4 5 1 2 3 4 5 6 7 8 2 2 4 6 7 8 [Loop 4] 3 1 2 3 4 5 6 7 8 0 0 2 2 0
- 12. END OF LOOP [Loop 4] 2 5 3 0 2 3 0 3 0 2 2 4 7 7 B: C: A: 0 1 2 3 4 5 1 2 3 4 5 6 7 8 0 0 2 2 3 3 3 5 1 2 3 4 5 6 7 8
- 13. TIME COMPLEXITY • So the counting sort takes a total time of: O(n + k) •Pro’s: • –Fast • –Asymptotically fast - O(n+k) • –Simple to code • Con’s: •–Doesn’t sort in place. • –Requires O(n+k) extra storage.
- 14. TIME COMPLEXITY OF SORTING
- 15. Thank You