[HackerRank - Java] Day 2 - 3. Counting Sort 1

Counting Sort 1

Comparison Sorting

Quicksort usually has a running time of $n$ x $log(n)$, but is there an algorithm that can sort even faster? In general, this is not possible. Most sorting algorithms are comparison sorts, i.e. they sort a list just by comparing the elements to one another. A comparison sort algorithm cannot beat $n$ x $log(n)$ (worst-case) running time, since $n$ x $log(n)$ represents the minimum number of comparisons needed to know where to place each element. For more details, you can see these notes (PDF).

Alternative Sorting

Another sorting method, the counting sort, does not require comparison. Instead, you create an integer array whose index range covers the entire range of values in your array to sort. Each time a value occurs in the original array, you increment the counter at that index. At the end, run through your counting array, printing the value of each non-zero valued index that number of times.

Example

$arr = [1, 1, 3, 2, 1]$

All of the values are in the range $[0 ... 3]$, so create an array of zeros, $result = [0, 0, 0, 0]$. The results of each iteration follow:

i	arr[i]	result
0	1	[0, 1, 0, 0]
1	1	[0, 2, 0, 0]
2	3	[0, 2, 0, 1]
3	2	[0, 2, 1, 1]
4	1	[0, 3, 1, 1]

The frequency array is $[0, 3, 1, 1]$. These values can be used to create the sorted array as well: $sorted = [1, 1, 1, 2, 3]$.

Note

For this exercise, always return a frequency array with 100 elements. The example above shows only the first 4 elements, the remainder being zeros.

Challenge

Given a list of integers, count and return the number of times each value appears as an array of integers.

Function Description

Complete the countingSort function in the editor below.

countingSort has the following parameter(s):

• arr[n]: an array of integers

Returns

• int[100]: a frequency array

Input Format

The first line contains an integer $n$, the number of items in $arr$.
Each of the next $n$ lines contains an integer $arr[i]$ where $0 <= i < n$.

Constraints

$100 <= n <= 10^6$
$0 <= arr[i] < 100$

Sample Input

100
63 25 73 1 98 73 56 84 86 57 16 83 8 25 81 56 9 53 98 67 99 12 83 89 80 91 39 86 76 85 74 39 25 90 59 10 94 32 44 3 89 30 27 79 46 96 27 32 18 21 92 69 81 40 40 34 68 78 24 87 42 69 23 41 78 22 6 90 99 89 50 30 20 1 43 3 70 95 33 46 44 9 69 48 33 60 65 16 82 67 61 32 21 79 75 75 13 87 70 33  

Sample Output

0 2 0 2 0 0 1 0 1 2 1 0 1 1 0 0 2 0 1 0 1 2 1 1 1 3 0 2 0 0 2 0 3 3 1 0 0 0 0 2 2 1 1 1 2 0 2 0 1 0 1 0 0 1 0 0 2 1 0 1 1 1 0 1 0 1 0 2 1 3 2 0 0 2 1 2 1 0 2 2 1 2 1 2 1 1 2 2 0 3 2 1 1 0 1 1 1 0 2 2

Explanation

Each of the resulting values $result[i]$ represents the number of times $i$ appeared in $arr$.

---

해설

비교 정렬

퀵정렬은 $O(nlog{}n)$ 시간복잡도를 가지고 있고 정렬 알고리즘 중 가장 빠릅니다.
보통의 정렬 알고리즘은 비교 정렬 방식인데, 비교 정렬 알고리즘은 $O(nlog{}n)$ 보다 빠른 알고리즘은 없습니다.

• 선택정렬, 삽입정렬: $O(n^2)$
• 힙정렬, 병합정렬, 퀵정렬: $O(nlog{}n)$

카운팅 정렬 (= 계수 정렬)

카운팅 정렬은 $O(n + k)$ 시간복잡도를 가진다.
비교하는 연산이 없다

전체 요소를 포함할 수 있는 카운트 배열을 만들고,
입력 배열의 각 요소들을 순회하며 카운트 배열의 인덱스에 값을 증가시킵니다
카운트 배열을 모두 완성 한 후, 입력 배열과 카운트 배열을 활용하여 정렬을 하는 방식입니다.

시간 복잡도는 낮으나 공간 복잡도가 높습니다.

이번 문제에서는 카운팅 정렬 원리 중, 카운트 배열 1단계를 만드는 것입니다.
단순하게 각 요소별 카운트 수를 담은 배열을 리턴하면 됩니다.

다만, return 조건에서 int[100] 으로 리턴하라고 쓰여있으니 이 부분을 유의하여 개발하면 됩니다.

static List<Integer> countingSort(List<Integer> arr) {
    int[] countArr = new int[100];
    arr.forEach( i -> countArr[i] += 1);
    return Arrays.stream(countArr).boxed().collect(Collectors.toList());
}