๊ธฐ์ ์ ๋ ฌ์ด๋?
๋ฎ์ ์๋ฆฌ์๋ถํฐ ๋น๊ตํ์ฌ ์ ๋ ฌํด๊ฐ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ฉฐ ๋น๊ต ์ฐ์ฐ์ด ๋ถํ์ํ ์ ๋ ฌ์ด๋ค.
์๋ฆฟ์์ ํด๋น๋๋ ๊ฐ์ ๋ฐ๋ผ ๋ฒํท์ ๋ฐ์ดํฐ๋ค์ ์ฝ์ ํ๊ธฐ ๋๋ฌธ์ ๋น๊ต ์ฐ์ฐ์ด ๋ถํ์ํ์ง๋ง ์๋ฆฟ์๋งํผ์ ์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ํ์ํ๋ค. (๋ํ ์๋ฆฟ์๋งํผ์ ์ถ๊ฐ์ ์ธ ๋ก์ง๋ ํ์ํ๋ค)
์๋ฆฟ์๊ฐ ๋น์ ์์ ์ผ๋ก ํฐ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋ค๋ฉด ์ธ๋ฐ์๋ ๋ฉ๋ชจ๋ฆฌ์ ํฌ๊ธฐ๋ฅผ ์ฐจ์งํ๊ฒ ๋๋ค.
๊ตฌํ๊ณผ ์๊ฐ ๋ณต์ก๋
์๋ฐ๋ฅผ ์ด์ฉํ ๊ตฌํ
public static void main(String[] args) {
RadixSort radixSort = new RadixSort();
for(int i=0; i<10; i++) {
buckets.add(new LinkedList<>());
}
// 1
int digit = radixSort.getMaximumDigit();
// 2
for(int i=1; i<=digit; i++) {
// 2-1
for (int number : numbers) {
// 2-1-1
int digitValue = radixSort.getDigitValue(number, i);
// 2-1-2
buckets.get(digitValue).offer(number);
}
/ 2-2
int idx = 0;
for (LinkedList<Integer> bucket : buckets) {
while (!bucket.isEmpty()) {
numbers[idx++] = bucket.poll();
}
}
}
System.out.println(Arrays.toString(numbers));
}
private int getMaximumDigit() {
int max = 0;
for (int number : numbers) {
max = Math.max((int) Math.log10(number)+1, max);
}
return max;
}
private int getDigitValue(int number, int digit) {
return (int) (number / Math.pow(10, digit-1)) % 10;
}
1. ์๋ฆฟ์๋ฅผ ๊ตฌํ๋ค. (digit)
2. 1์ ์๋ฆฌ๋ถํฐ digit ์๋ฆฌ๊น์ง ๋ฐ๋ณตํ๋ค. O(d)
2-1. ๋ชจ๋ ๋ฐ์ดํฐ์ ๋ํด์ ๋ฐ๋ณตํ๋ค. O(n)
2-1-1. ์๋ฆฟ์์ ํด๋น๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ฝ์๋ธ๋ค.
2-1-2. ๋ฝ์๋ธ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํ์ฌ ํด๋น๋๋ Bucket์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ค.
2-2. bucket์ ๋ค์ด๊ฐ ์์๋๋ก ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๋ค.
์๊ฐ ๋ณต์ก๋
๋ชจ๋ ์๋ฆฟ์์ ๋ํด ๋ฐ๋ณตํ๊ธฐ ๋๋ฌธ์ O(์๋ฆฟ์)
๊ทธ๋ฆฌ๊ณ ์๋ฆฟ์๋ง๋ค ๋ชจ๋ ๋ฐ์ดํฐ์ ๋ํด ์ ๋ ฌ์ ์ํํ๊ธฐ ๋๋ฌธ์ O(๋ฐ์ดํฐ ์)
๋ฐ๋ผ์ ๊ธฐ์ ์ ๋ ฌ์ ์๊ฐ ๋ณต์ก๋๋ O(์๋ฆฟ์ * ๋ฐ์ดํฐ ์)
์ฆ, O(dn) (d๋ ์ต๋ ์๋ฆฟ์) ์ด๋ค.