์ฝ์ ์ ๋ ฌ์ ๊ฐ๋
์ฝ์ ์ ๋ ฌ์ด๋?
- ์ ํ ์ ๋ ฌ๊ณผ ๋ค๋ฅด๊ฒ ๋ฐ์ดํฐ์ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ๋ ์ ๋ ฌ์ด๋ค.
- ํ์ฌ Key ์์ ์์นํ๋ ๋ฐ์ดํฐ๋ค์ ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ค์ด๋ฉฐ, ์ ๋ ฌ์ด ์๋ฃ๋ ๋ฐ์ดํฐ๋ค ์ฌ์ด์ Key์ ์์น๋ฅผ ์ฐพ๋ ๊ฒ์ด ์ฝ์ ์ ๋ ฌ์ด๋ค.
- ์ด๋ฏธ ์ ๋ ฌ๋ ๋ฐ์ดํฐ์ผ ๊ฒฝ์ฐ ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ๋น๊ต๋ฅผ ๋จ ํ๋ฒ๋ง ์ํํ๊ธฐ ๋๋ฌธ์ ์ต์ ์ ๊ฒฝ์ฐ O(N)์ ์ฑ๋ฅ์ ๋ณด์ฌ์ค๋ค.
๋์ ๋ฐฉ์
- ๋ฆฌ์คํธ ๊ธธ์ด(n)์ -1 ๋งํผ ๋ฐ๋ณตํ๋ค. (๋งจ ์์ ๋ฐ์ดํฐ๋ ์ ์ธํ๋ค.)
1-2. ํด๋น ์์น์ ์ ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ค.
1-1. ํ์ฌ ์ ํ๋ ๋ฐ์ดํฐ์ ์์ ์์นํ ์ ๋ ฌ๋ ๊ฐ๋ค์ ๋น๊ตํ๋ฉฐ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ๋๋ค.
void sort(int[] numbers) {
// 1.
for(int i=1; i<numbers.length; i++) {
int temp = numbers[i], j;
// 1-1.
for(j = i-1; j>=0 && numbers[j] > temp; j--) {
numbers[j+1] = numbers[j];
}
// 1-2.
numbers[j+1] = temp;
}
}
์ฝ์ ์ ๋ ฌ์ ์ฅ๋จ์
์ฅ์
- stable sort ๋ฐฉ๋ฒ์ด๊ธฐ ๋๋ฌธ์, ๋ ๊ฐ์ ํค๊ฐ์ ๊ฐ์ง๊ณ ์ ๋ ฌ์ ์๋ํ ์ ์๋ค.
- ๊ต์ฅํ ๋จ์ํ ๋ก์ง์ ๊ฐ์ง๊ณ ์๋ค.
- ๋๋ถ๋ถ์ ๋ฐ์ดํฐ๊ฐ ์ด๋ฏธ ์ ๋ ฌ๋์ด ์๋ ๊ฒฝ์ฐ ๋งค์ฐ ํจ์จ์ ์ด๋ค.
- ๋ฐฐ์ด ์์์ ๋ชจ๋ ๊ณผ์ ์ด ์ผ์ด๋๊ธฐ ๋๋ฌธ์ ์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ์๋ค. -> ๊ณต๊ฐ ๋ณต์ก๋ O(1)
๋จ์
- key๊ฐ ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฐ๋ฅธ ์์น์ ์ฝ์ ํด์ผ ํ๊ธฐ ์ํด์๋ ์์ ๋ชจ๋ ๋ฐ์ดํฐ๋ค์ด ํ์นธ์ฉ ์ด๋์ ํด์ผ๋ง ํ๋ค.
- ๋น๊ต์ ๋ง์ ๋ฐ์ดํฐ๋ค์ ์ด๋์ ํฌํจํ ์ ๋ฐ์ ์๋ค.
- ํ๊ท , ์ต์ ์ ๊ฒฝ์ฐ O(n^2)์ธ ๋นํจ์จ์ ์ธ ์ ๋ ฌ์ด๋ค.
์๊ฐ ๋ณต์ก๋
best case
1.๋ฆฌ์คํธ ๊ธธ์ด(n)์ -1 ๋งํผ ๋ฐ๋ณตํ๋ค. (์ฒซ๋ฒ์งธ ๊ฐ์ ์ ์ธํ n-1๊ฐ)
1-1. 1๋ฒ์งธ ๋ฐ์ดํฐ๋ถํฐ n๋ฒ์งธ ๋ฐ์ดํฐ๊น์ง ์ฝ์ ๋ ์์น๋ฅผ ์ฐพ๋๋ค.
1, 2, ....... n-1
1-2. ํด๋น ์์น์ ์ ํ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ค.
1 + 2 + 3 + ...... + n-1 = n(n-1)/2 → O(N^2)
worst case
- ๋ชจ๋ ์ ๋ ฌ์ด ๋์ด์๋ ๊ฒฝ์ฐ ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ํ๋ฒ์ฉ ๋ฐ์ ๋น๊ต๋ฅผ ํ์ง ์๊ธฐ ๋๋ฌธ์ O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ค. 1 + 1 + 1 + ..... + 1 = n → O(N)
Insertion Sort vs Selection Sort
- Selection Sort ๊ฐ์ ๊ฒฝ์ฐ์๋ ํ๋์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ๊ธฐ ์ํด ๋๋จธ์ง ๋ชจ๋ ์์๋ฅผ ํ์ํ๋ค.
- ๋ฐ๋ฉด์ Insertion Sort๋ ํ์ํ ๋งํผ์ ์์๋ฅผ ํ์ํ๋ค.
- ์ ๋ฆฌํ์๋ฉด ์ฝ์ ์ ๋ ฌ์ ๋ฐ์ดํฐ์ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ๋ ๊ฒ์ด๊ณ , ์ ํ ์ ๋ ฌ์ ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๋ ๋ฐฉ์์ด๋ค.
์ ๋ ฌ๋ค์ ๋น๊ต
https://ybdeveloper.tistory.com/117