์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ ์ฌํ ๋ถ์: O(n²)๋ถํฐ Timsort๊น์ง
๋ชฉ์ฐจ
01. ๋ฒ๋ธ / ์ ํ / ์ฝ์ - O(n²)์ ์ฑ๋ฅ ์ฐจ์ด
์ ๋ค ์๊ฐ ๋ณต์ก๋๋ O(n^2)์ด์ง๋ง, ์ค์ ๋์ ๋ฐฉ์์ ๋ฐ๋ผ ์ฑ๋ฅ ์ฐจ์ด๊ฐ ๋ฐ์ํฉ๋๋ค.
- ์ ํ ์ ๋ ฌ (Selection Sort): ๋งค ๋ผ์ด๋ ์ต์๊ฐ์ ์ฐพ์ ๋งจ ์๊ณผ ๊ตํํฉ๋๋ค. ๋น๊ต ํ์๋ ํญ์ n(n-1)/2๋ก ๊ณ ์ ์ด๋ฉฐ, ์ด๋ฏธ ์ ๋ ฌ๋ ์ํ๋ผ๋ ์ฑ๋ฅ์ด ๊ฐ์ ๋์ง ์์ ์ค์ฉ์ฑ์ด ๋ฎ์ต๋๋ค.
- ๋ฒ๋ธ ์ ๋ ฌ (Bubble Sort): ์ธ์ ํ ๋ ์์๋ฅผ ๋น๊ตํ๋ฉฐ ๊ตํํฉ๋๋ค. ๊ตํ(swap) ์์ ์ด ๋น๋ฒํ๊ฒ ์ผ์ด๋๊ณ ์บ์ ํจ์จ์ด ๋๋น ์ค์ ์ฑ๋ฅ์ด ๊ฐ์ฅ ๋จ์ด์ง๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค.
- ์ฝ์ ์ ๋ ฌ (Insertion Sort): ์ ๋ ฌ๋ ๋ถ๋ถ์ ์ ์ ํ ์์น์ ์์๋ฅผ ์ฝ์ ํฉ๋๋ค. ๋ฐ์ดํฐ๊ฐ ๊ฑฐ์ ์ ๋ ฌ๋ ์ํ๋ผ๋ฉด O(n)์ ์๋ ดํ๋ ๊ฐ๋ ฅํ ํน์ง์ด ์์ด Timsort์ ํต์ฌ ์๋ธ๋ฃจํด์ผ๋ก ์ฌ์ฉ๋ฉ๋๋ค.
02. ํต ์ ๋ ฌ - ํ๊ท O(n log n), ์ต์ O(n^2)
๋ถํ ์ ๋ณต์ ์๋ฆฌ
ํผ๋ฒ(Pivot)์ ๊ธฐ์ค์ผ๋ก ๋ฐฐ์ด์ ๋ฐ์ฉ ๋๋๋๋ค. ์ด์์ ์ผ๋ก ์ ๋ฐ์ฉ ๋๋๋ค๋ฉด ์ฌ๊ท ๊น์ด๋ log n์ด ๋๊ณ , ๊ฐ ๋จ๊ณ์์ n๋ฒ ๋น๊ตํ๋ฏ๋ก O(n log n)์ด ๋ฉ๋๋ค.
์ต์ ์ ์ํฉ (O(n^2))
์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐฐ์ด์์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ํผ๋ฒ์ผ๋ก ์ ํํ๋ฉด, ๋ถํ ์ด [1๊ฐ] + [n-1๊ฐ]๋ก๋ง ์ด๋ฃจ์ด์ ธ ์ฌ๊ท ๊น์ด๊ฐ n๊น์ง ๋์ด๋ฉ๋๋ค.
[2, 3, 4, 5] → pivot:2 → [] + [3,4,5] (์ฌ๊ท n๋ฒ ๋ฐ์)
์ค๋ฌด์์์ ๋์
ํผ๋ฒ์ ๋๋คํ๊ฒ ์ ํ๊ฑฐ๋ ์ฒซ/์ค๊ฐ/๋ ๊ฐ ์ค ์ค๊ฐ๊ฐ์ ํผ๋ฒ์ผ๋ก ์ฐ๋ Median-of-Three ๊ธฐ๋ฒ์ ์ฌ์ฉํฉ๋๋ค. Java์ Dual-Pivot Quicksort๋ ํผ๋ฒ 2๊ฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ฑ๋ฅ์ ๋์ด๊ณ , ์ฌ๊ท๊ฐ ๋๋ฌด ๊น์ด์ง๋ฉด ํ ์ ๋ ฌ๋ก ์ ํํ๋ ํ์ด๋ธ๋ฆฌ๋ ๋ฐฉ์์ ์ทจํฉ๋๋ค.
03. ๋ณํฉ ์ ๋ ฌ์ด '์์ ์ ๋ ฌ'์ธ ์ด์
๋ณํฉ ์ ๋ ฌ์ ์์๊ฐ ํ๋๊ฐ ๋ ๋๊น์ง ์ชผ๊ฐ ํ, ๋ค์ ํฉ์น๋ฉด์ ์ ๋ ฌํ๋ ๋ฐฉ์์ ๋๋ค.
๐ก ํต์ฌ: ์์ ์ฑ(Stability)์ ๊ฒฐ์ ํ
๋ณํฉ(Merge) ์ ๋์ผํ ๊ฐ์ ๋ง๋๋ฉด ๋ฐ๋์ ์ผ์ชฝ ๋ฐฐ์ด์ ์์๋ฅผ ๋จผ์ ๊ฒฐ๊ณผ์ ๋ด์ต๋๋ค.
temp[k++] = arr[i++]; // ๋ฑํธ(=)๊ฐ ์์๋ฅผ ์ ์งํจ
}
๋ง์ฝ <= ๋์ <๋ฅผ ์ฌ์ฉํ๋ฉด ๋์ผ ๊ฐ์ผ ๋ ์ค๋ฅธ์ชฝ ๋ฐฐ์ด์ ์์๊ฐ ๋จผ์ ๋ค์ด๊ฐ ์์๊ฐ ๋ค์งํ๊ฒ(Unstable) ๋ฉ๋๋ค.
04. Java Arrays.sort()์ Timsort
| ์ ๋ ฌ ๋์ | ์ฌ์ฉ ์๊ณ ๋ฆฌ์ฆ |
|---|---|
| Primitive Type (int[], double[]...) | Dual-Pivot Quicksort (์๋ ์ฐ์ ) |
| Object Type (String[], Custom Class...) | Timsort (์์ ์ฑ ๋ณด์ฅ) |
์ ๊ฐ์ฒด ์ ๋ ฌ์๋ Timsort์ธ๊ฐ?
๊ฐ์ฒด ์ ๋ ฌ์ ์์ ์ ๋ ฌ์ด ํ์์ ์ ๋๋ค. Timsort๋ ๋ณํฉ ์ ๋ ฌ + ์ฝ์ ์ ๋ ฌ์ ํ์ด๋ธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก, ์ค์ธ๊ณ ๋ฐ์ดํฐ์ '๋ถ๋ถ ์ ๋ ฌ ์ํ'๋ฅผ ์ต๋ํ ํ์ฉํ์ฌ ์ต์ ์ ๊ฒฝ์ฐ O(n), ์ต์ ์ ๊ฒฝ์ฐ์๋ O(n log n)์ ๋ณด์ฅํฉ๋๋ค.
05. ์ฌํ ๊ฐ๋ ๋ฐ ์ฉ์ด ์ ๋ฆฌ
๋ฒ๋ธ ์ ๋ ฌ์ ์ต์ ํ: Swap Flag
boolean swapped = false; // swap flag
for (int j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(arr, j, j + 1);
swapped = true;
}
}
if (!swapped) break; // ๊ตํ ์์ผ๋ฉด ์กฐ๊ธฐ ์ข ๋ฃ (์ต์ O(n))
}
Timsort๋?
Python ๊ฐ๋ฐ์ Tim Peters๊ฐ ๊ณ ์ํ ํ์ด๋ธ๋ฆฌ๋ ์ ๋ ฌ. ์ด๋ก ์ ์ต์ ์ ๋์ด ์ค์ ๋ฐ์ดํฐ ํ๊ฒฝ์์ ์ต์์ ํผํฌ๋จผ์ค๋ฅผ ๋ด๋๋ก ์ค๊ณ๋จ.
์๋ธ๋ฃจํด(Subroutine)์ด๋?
ํน์ ์์ ์ ์ํํ๊ธฐ ์ํด ํธ์ถ๋๋ ๋ถํ ํจ์. Timsort๊ฐ ๊ฐ ๊ตฌ๊ฐ์ ์ ๋ ฌํ ๋ ์ฌ์ฉํ๋ '์ฝ์ ์ ๋ ฌ'์ด ๋ฐ๋ก ์๋ธ๋ฃจํด์ ์์.
'๐งฉ Algorithm > ๊ฐ๋ ๋ฐ ์๋ฃ๊ตฌ์กฐ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [Algorithm] ์ต์ ํ(Min Heap) (3) | 2024.11.16 |
|---|---|
| [Algorithm] Two-Pointers(ํฌ ํฌ์ธํฐ) (3) | 2024.11.15 |
| [์๊ณ ๋ฆฌ์ฆ] DP (Dynamic Programming, ๋์ ๊ณํ๋ฒ) (0) | 2023.09.25 |
| [์๊ณ ๋ฆฌ์ฆ] ์๋ผํ ์คํ ๋ค์ค์ ์ฒด (1) | 2023.09.23 |
| [์๊ณ ๋ฆฌ์ฆ] BFS/DFS ์๊ณ ๋ฆฌ์ฆ (๊ทธ๋ํ ํ์) (0) | 2023.05.15 |