๐ฉ ์ฝ์ ์ ๋ ฌ์ ์ฅ์ ์ ์ด๋ฆฌ๊ณ , ๋จ์ ์ ๋ณด์ํ์ฌ ์ข ๋ ๋น ๋ฅด๊ฒ ์ ๋ ฌํ๋ ์๊ณ ๋ฆฌ์ฆ
์ฝ์ ์ ๋ ฌ์ ๋ณด์
์ฝ์ ์ ๋ ฌ์ ์ด๊ธฐ ๋ฆฌ์คํธ๊ฐ "๊ฑฐ์ ๋ณด์"๋์ด ์์ ๊ฒฝ์ฐ ํจ์จ์
์ ๋ ฌ๋์ง ์์์ํ์ ๋ฐฐ์ด์ ๋ํด ๋จ์ํ๊ฒ ์ฝ์ ์ ๋ ฌ์ ์ ์ฉํ๋ ๊ฒ์ด ์๋๋ผ
'4-์ ๋ ฌ', '2-์ ๋ ฌ'์ฒ๋ผ ์กฐ๊ธ์ด๋ผ๋ ์ ๋ ฌ์ด ๋ ์ํ์ ๊ฐ๊น์ด ๋ฐฐ์ด๋ก ๋ง๋ ๋ค์ ๋ง์ง๋ง ์ฝ์ ์ ๋ ฌ์ ํ๋ ๊ฒ
์ ๋ ฌํด์ผ ํ๋ ํ์๋ ๋์ง๋ง, ์ ์ฒด์ ์ผ๋ก ์์ ์ด๋ ํ์๊ฐ ์ค์ด๋ค์ด ํจ์จ์ ์ธ ์ ๋ ฌ์ ํ ์ ์๋ค.
๐ฉ ์์
1. ์ ๋ ฌํ ๋ฐฐ์ด์ ์์๋ฅผ ๊ทธ๋ฃน์ผ๋ก ๋๋ ๊ฐ ๊ทธ๋ฃน๋ณ๋ก ์ฝ์ ์ ๋ ฌ ์ํ
2. ๊ทธ ๊ทธ๋ฃน์ ํฉ์น๋ฉด์ ์ ๋ ฌ์ ๋ฐ๋ณตํ์ฌ ์์์ ์ด๋ ํ์๋ฅผ ์ค์ธ๋ค
3. ์์ ๊ณผ์ ์ ๊ทธ๋ฃน์ ๊ฐ์๊ฐ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
๐ฉ ๋๋๋ ๊ฐ๊ฒฉ k
๊ฐ๊ฒฉ k์ ์ด๊น๊ฐ : (๋ฐ์ดํฐ์ ๊ฐฏ์) / 2
๋งค ํ์ ๋ง๋ค k๋ ์ ๋ฐ์ผ๋ก ๋๋๋ค. ํญ์ ํ์๊ฐ ๋๋๋ก ๊ฐ์ ์์ ํ๋ค(์ง์์ธ ๊ฒฝ์ฐ + 1)
k๊ฐ 1์ด ๋ ๋๊น์ง ๋ฐ๋ณต
'k-์ ๋ ฌ'์ด๋ผ ๋ถ๋ฆ ์) 5-์ ๋ ฌ
๐ฉ ์ฅ๋จ์
(์ฅ) ์ฐ์์ ์ด์ง ์์ ๋ฆฌ์คํธ์ ๊ตํ์ด ์ผ์ด๋๋ฉด ๋ ํฐ ๊ฑฐ๋ฆฌ๋ฅผ ์ด๋
(์ฅ) ๊ตํ๋๋ ์์๋ค์ด ์ฝ์ ์ ๋ ฌ๋ณด๋ค ์ต์ข ์์น์ ์์ ๊ฐ๋ฅ์ฑ์ด ๋ ๋์์ง๋ค.
(๋จ) k ๊ฐ๊ฒฉ์ ์๋ชป ์ค์ ํ๋ค๋ฉด ์ฑ๋ฅ์ด ๊ต์ฅํ ์ ์ข์์ง ์ ์๋ค.
๐ ๋ณดํต ์ ์ฒด์์ h/2๋ฅผ ํ์ง๋ง ์ด๋ณด๋ค h/3 + 1์ด ๋ ๋น ๋ฅด๋ค.
๐ฉ ์๊ฐ๋ณต์ก๋
O(n^1.5)
ShellSort(A[ ], n) {
int i, j, temp;
int gap = len / 2;
while (gap > 0) {
for (i = gap; i < len; i++) {
temp = arr[i];
j = i;
while (j >= gap && arr[j - gap] > temp) {
arr[j] = arr[j - gap];
j -= gap;
}
arr[j] = temp;
}
gap /= 2;
}
}
'๐ฉโ๐ป ํ๋ก๊ทธ๋๋ฐ > ๐ ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํฉ๋ณ ์ ๋ ฌ(Merge Sort) (0) | 2024.04.12 |
---|---|
ํต ์ ๋ ฌ(Quick Sort) (0) | 2024.04.12 |
์ฝ์ ์ ๋ ฌ(Insertion Sort) (1) | 2024.04.12 |
๋ฒ๋ธ ์ ๋ ฌ(Bubble Sort) (0) | 2024.04.12 |
์ ํ ์ ๋ ฌ(Selection Sort) (0) | 2024.04.12 |