์ฝ์ ์ ๋ ฌ(Insertion Sort) ์ด๋?
์ด๋ฏธ ์ ๋ ฌ๋์ด ์๋ i๊ฐ ์ง๋ฆฌ์ ๋ฐฐ์ด์ ํ๋์ ์์๋ฅผ ๋ ๋ํ์ฌ ์ ๋ ฌ๋ i+1 ๊ฐ์ ๋ฐฐ์ด์ ๋ง๋๋ ๊ณผ์ ์ A[n] ๊น์ง ๋ฐ๋ณตํ๋ ์๊ณ ๋ฆฌ์ฆ ์ด๋ค.
์ฐจ์ด์ ์ด ์๋ค๋ฉด ์ง๊ธ๊น์ง ํ๋ ์ ํ ์ ๋ ฌ
์ด๋ ๋ฒ๋ธ ์ ๋ ฌ
์ n ๊ฐ์ ๋ฐฐ์ด์์ ์์ํ์ฌ ํ๋์ฉ ์์๋ฅผ ์ค์ด๋๋ฐ ๋ฐํ์ฌ ์ฝ์
์ ๋ ฌ์ ๊ทธ ํฌ๊ธฐ๋ฅผ ํ๋์ฉ ๋๋ฆฌ๋ ์ ๋ ฌ์ด๋ค.
ํ์ง๋ง ์ ํ ์ ๋ ฌ
์ด๋ ๋ฒ๋ธ ์ ๋ ฌ
์ ๋นํ์ฌ ๊ตฌํํ๊ธฐ ์กฐ๊ธ ๊น๋ค๋กญ๋ค๋ ์ ์ด ์๋ค.
๋ฐฑ๋ฌธ์ด ๋ถ์ฌ์ผํ ๋ผ๊ณ pseudo ์ฝ๋๋ฅผ ํ ๋ฒ ๊ฐ๋ณ๊ฒ ๋ณด๊ณ ์ง์ ์๊ฐํด๋ณด์.
insertionSort(A[], n){ .... 1
for i <- 2 to n .... 2
A[1 ... i]์ ์ ํฉํ ์๋ฆฌ์ A[i]๋ฅผ ์ฝ์
ํ๋ค. ....3
}
- 1๋ฒ์ for ๋ฃจํ๋ ๋ฌธ์ ์ ํฌ๊ธฐ๋ฅผ ํ๋์ฉ, ์ฆ ์ ๋ ฌํ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋๋ ค ์๋กญ๊ฒ ์์๋ฅผ ์ถ๊ฐํ๋ ์ญํ ์ ํ๋ค.( ์์๋ฅผ ์ถ๊ฐํ๋ ์์ ์ ํญ์ ์ ๋ ฌ์ด ๋์ด์๋ค.)
- 2๋ฒ์ ์ํํ๊ณ ๋๋ฉด A[1...i] ๊น์ง ์ ๋ ฌ์ด ๋๋ค. ์ฆ ์ด๋ฏธ ์ ๋ ฌ๋ ์์ A[1...i-1]์ ์๋กญ๊ฒ A[i]๋ฅผ ์ถ๊ฐ์ํค๊ณ ์ฌ๊ธฐ์ ์กฐ๊ฑด์ด ์๋ค.
A[i]
>A[i-1]
์ด๋ฉดA[i]
๋A[1..i-1]
์ ๋ชจ๋ ์์๋ณด๋ค ํฌ๋ฏ๋ก ๊ทธ๋ฅ ์ ์๋ฆฌ์ ๋๊ณ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋๋กA[i]
๊ฐ ๋ค์ด๊ฐ ์๋ฆฌ๋ฅผ ์ฐพ์๊ฐ๋ฉด ๋๋ค.
insertionSort(A[], n){
for i <- 2 to n {
loc <- i-1;
newItem <- A[i];
while(loc>=1 and newItem<A[loc]){
A[loc+1] <- A[loc];
loc --;
}
A[loc+1] <- newItem;
}
}
- ์ ๋ ฌ๋์ง ์์ ๋ฐฐ์ด
A[] = {7, 22, 31, 4, 11}
์ด ์๋ค๊ณ ์น์. ๊ฐ ์ ๋ ฌ์ A[0] ๋ถํฐ ์์ํด ์ ์ฐจ ์ธ๋ฑ์ค๋ฅผ ํ๋์ฉ ๋๋ ค๊ฐ๋ฉฐ ์ ๋ ฌ์ ํ ๊ฒ์ด๋ค.
์ฒซ ๋ฒ์งธ ์ ๋ ฌ
- ๋ฐฐ์ด์ ์ํ: {7}
๋ฐฐ์ด์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๋ค.
-> A[i] = A[i+1]
-> 22 ๊ฐ 7๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ํฌ๋ฏ๋ก ๊ทธ ์๋ฆฌ ์ ์ง : {7, 22}
๋ฐฐ์ด์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๋ค.
-> A[i] = A[i+1]
-> 31 ์ด 22๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ํฌ๋ฏ๋ก ๊ทธ ์๋ฆฌ ์ ์ง : {7, 22, 31}
๋ฐฐ์ด์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๋ค.
-> A[i] = A[i+1]
-> 4 ๊ฐ 31 ๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ์์ผ๋ฏ๋ก ์์ ์์น ๊ฒ์ฌ
ใด> ๋ฐฐ์ด 7์ด 4๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ํฌ๋ฏ๋ก 7์ ์๋ฆฌ์ 4 ์ฝ์
: {4, 7, 22, 31}
๋ฐฐ์ด์ธ๋ฑ์ค๋ฅผ ์ถ๊ฐํ๋ค.
-> A[i] = A[i+1]
-> 11์ด 31 ๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ์์ผ๋ฏ๋ก ์์ ์์น ๊ฒ์ฌ
ใด> ๋ฐฐ์ด 4๊ฐ 11๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ์์ผ๋ฏ๋ก ๋ฐฐ์ด ์ธ๋ฑ์ค ํ ์นธ ๋
-> 7์ด 11๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ์์ผ๋ฏ๋ก ๋ฐฐ์ด์ธ๋ฑ์ค ํ ์นธ ๋
->22๊ฐ 11๋ณด๋ค ํฐ์ง ๊ฒ์ฌ
-> ํฌ๋ฏ๋ก 22์๋ฆฌ์ 11 ์ฝ์
: {4, 7, 11, 22, 31}
์ฝ์ ์ ๋ ฌ(Insertion Sort)์ ์๊ฐ ๋ณต์ก๋
์์ pseudo ์ฝ๋์์ ๋ณด๋ฉด ๋ฐ๋ณต์ ์ด ๋ ๋ฒ ๋ฑ์ฅํ๋ค
1 ๋ฒ์ for
๋ฌธ ๊ทธ๋ฆฌ๊ณ 3๋ฒ์ ์ํด์๋ while
๋ฌธ. ์
๋ ฅ์ ํฌ๊ธฐ๊ฐ n ์ผ ๋ ๋ฐ๋ณต์ n ์ ๊ด๋ จ์ด ์์ผ๋ฏ๋ก O(n^2)์ ์๊ฐ์ด ๋ ๋ค.
ํ์ง๋ง ๋ง์ฝ ๋ฐฐ์ด์ด ์์ ํ ์ ๋ ฌ๋ ์ฑ๋ก ์ ๋ ฅ๋๋ค๋ฉด while ๋ฃจํ๋ ํ ๋ฒ๋ ์ํ๋์ง ์์ผ๋ฏ๋ก O(n)์ ๊ฐ๊น์ด ์๊ฐ๋ณต์ก๋๊ฐ ์์ฑ๋๋ค. ์ด๋ฐ ๋งค๋ ฅ ๋ฅ๊ตฐ์ ๋ค๋ฅธ ์ ๋ ฌ์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ์ํฉ์ ๋ฐ๋ผ ๊ฐ๋ ์ฝ์ ์ ๋ ฌ์ ์์ด์ ์ฐ๋ ๊ฒ๋ ๊ถ์๋๋ค.
์ฝ์ ์ ๋ ฌ(Insertion Sort)์ ํน์ง
์ฅ์
- ์์ ํ ์ ๋ ฌ ๋ฐฉ๋ฒ์ด๋ค.
- ๋ฐฐ์ด์ ์๊ฐ ์ ์ ์๋ก ๋ค๋ฅธ ์ ๋ ฌ ๋ฐฉ๋ฒ๋ณด๋ค ์๊ณ ๋ฆฌ์ฆ ์์ฒด๊ฐ ๊ฐ๋จํ๋ฏ๋ก ์ ๋ฆฌํ ์ ์๋ค.
- ์ด๋ฏธ ๋ฐฐ์ด์ด ์ ๋ ฌ๋์์ ๊ฒฝ์ฐ ๊ทน์์ ํจ๊ณผ๋ฅผ ๋ณผ ์ ์๋ค.
๋จ์
- ์๊ฐ๋ณต์ก๋์ ๊ด์ ์์ ๋ดค์ ๋ O(n^2)์ด๋ฏ๋ก ์ ผํ ํจ์จ์ ์ด์ง ์๋ค.
์ฝ์ ์ ๋ ฌ(Insertion Sort)์ ์๋ฐ ์ฝ๋
'๐ป Computer Science > - Data Structure, Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ-์ด๋ก ] ์ด์ง ๊ฒ์ ํธ๋ฆฌ(Binary Search Tree) (0) | 2019.11.23 |
---|---|
[์๊ณ ๋ฆฌ์ฆ-์ด๋ก ] ํต ์ ๋ ฌ (Quick Sort) (0) | 2019.11.23 |
[์๊ณ ๋ฆฌ์ฆ-์ด๋ก ] ๋ณํฉ ์ ๋ ฌ(Merge Sort) (0) | 2019.11.23 |
[์๊ณ ๋ฆฌ์ฆ-์ด๋ก ] ๋ฒ๋ธ ์ ๋ ฌ (Bubble Sort) (0) | 2019.11.23 |
[์๊ณ ๋ฆฌ์ฆ-์ด๋ก ] ์ ํ ์ ๋ ฌ(Selection Sort) (0) | 2019.11.23 |
๋๊ธ