๐ ์ฃผ์ด์ง ๋ฌธ์ ๋ฅผ n๊ฐ์ ๋ถ๋ถ ๋ฌธ์ ๋ค๋ก ๋๋ ํ, ๊ฐ ๋ถ๋ถ ๋ฌธ์ ๋ค์ ํด๋ฅผ ๊ตฌํ์ฌ ์๋ ๋ฌธ์ ์ ํด๋ต์ผ๋ก ๊ฒฐํฉํ๋ ๋ฐฉ๋ฒ์ด๋ค.
๐ ๋ถ๋ถ ๋ฌธ์ ๋ค์ ์๋์ ๋ฌธ์ ์ ๊ฐ์ ์ ํ์ด๋ฉฐ, ์ฒ๋ฆฌํด์ผ ํ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ง ์๋ค.
๐ ๋ณดํต ์ํ ํธ์ถ์ ์ฌ์ฉํ์ฌ ํด๊ฒฐํ๋ค.
if(๋ฌธ์ ์ ํฌ๊ธฐ๊ฐ ์ถฉ๋ถํ ์์ผ๋ฉด) return ํด๋ต
else{
๋ฌธ์ ๋ฅผ ๋ ์์ n๊ฐ์ ๋ถ๋ถ ๋ฌธ์ ๋ค๋ก ๋๋๋ค
๋๋ ๋ถ๋ถ ๋ฌธ์ ๋ค์ ๋ํด์ ๋ค์ ์ํํธ์ถ
return ๋ถ๋ถ ๋ฌธ์ ๋ค์ ํด๋ต ๊ฒฐํฉ
}
1. ์ด์ง ํ์(์ด๋ถํ์)
1.1 ๋ฌธ์ : ์ ๋ ฌ๋ ์ํ์ ๋ฆฌ์คํธ์์ x์ ๊ฐ์ด ์กด์ฌํ๋ค๋ฉด, ๊ทธ ์์น๋ฅผ ๊ฒฐ์ ํ๋ผ
๐ ๋ถํ ์ ๋ณต ๊ธฐ๋ฒ ์ ์ฉ
n=1์ด๋ฉด(์์๊ฐ 1๊ฐ ์์ ๋) {
x=์์ return ํด
x!=์์ return -1
}
n>1์ด๋ฉด {
๊ธฐ์ค ์์๋ณด๋ค ์์ ์์๋ค ์งํฉ, ๋ค์ ์์๋ค ์งํฉ์ผ๋ก ๋๋๋ค.
x๊ฐ ๊ธฐ์ค ์์๋ณด๋ค ์์ผ๋ฉด ์ ์งํฉ๋ง ํด๊ฒฐ(→์ํํธ์ถ)
x๊ฐ ๊ธฐ์ค ์์๋ณด๋ค ํฌ๋ฉด ๋ค ์งํฉ๋ง ํด๊ฒฐ(→์ํํธ์ถ)
x๊ฐ ๊ธฐ์ค ์์์ ๊ฐ์ผ๋ฉด return
์ด ๋, combineํ๋ ๋ถ๋ถ์ ํ์ํ์ง ์๋ค.
}
1.2 ์ํ๊ด๊ณ์ : O(log n)
1.3 ๋ฐ๋ณต์ ๊ตฌ์กฐ๋ฅผ ๊ฐ๋ ์ด์ง ํ์
while(๋ฒ์ ๋ด์ 1๊ฐ ์ด์์ ์์๊ฐ ์์ ๋) {
mid = (์ค๋ฅธ์ชฝ ์์+์ผ์ชฝ ์์) / 2
if(x๊ฐ mid๋ณด๋ค ์์ผ๋ฉด) ์ค๋ฅธ์ชฝ ์์ = mid-1
else if(x๊ฐ mid๋ณด๋ค ํฌ๋ฉด) ์ผ์ชฝ ์์ = mid+1
else return mid
}
๐ ๋ฐ๋ณต๋น if๋ฅผ ํ ๋ฒ๋ง ์ฌ์ฉ, ๋ฒ์๋ฅผ ๊ณ์ ์ขํ ๋๊ฐ
while(๋ฒ์์ 1๊ฐ์ ์์๊ฐ ๋จ์ ๋ ๊น์ง) {
mid
if(x๊ฐ mid๋ณด๋ค ์์ผ๋ฉด) ์ค๋ฅธ์ชฝ ์์ = mid
else ์ผ์ชฝ ์์ = mid
}
if(x = ์ผ์ชฝ ์์) return ์ผ์ชฝ ์์
else return -1
2. ํฉ๋ณ ์ ๋ ฌ(Merge sort)
2.1 ์๊ฐ ๋ณต์ก๋ : O(n log n)
2.2 MergeSort1
if(2๊ฐ ์ด์์ ์์๊ฐ ์์ ๋) {
mid ์์น ๊ณ์ฐ
low~mid ์ํํธ์ถ
mid+1~high ์ํํธ์ถ
(low, mid, high) Combine
}
2.3 Combine ํจ์
๐ low~mid, mid+1~hith ๋ณํฉ ์ ํฉ๋ณ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ์์ ๋ฐฐ์ด์ด ํ์ํ๋ค
while(๋ ๋ฆฌ์คํธ์ ์ ํจํ ์์๊ฐ ์์ ๋์){
a์ ๋ ๋ฆฌ์คํธ ์ค ์์ ๋ฆฌ์คํธ๊ฐ b๋ก ๋ณต์ฌ
}
if(๋ค์ ๋ฆฌ์คํธ๊ฐ ๋จ์์์ผ๋ฉด) ๋ค์ ๋ฆฌ์คํธ b๋ก ๋ฃ๋๋ค
else ์์ ๋ฆฌ์คํธ b๋ก ๋ฃ๋๋ค
2.4 MergeSort2
๐ ๋งํฌ ๊ฐ์ ์ด์ฉํ์ฌ ์๊ฐ, ๊ณต๊ฐ ํจ์จ์ ์ฌ์ฉ
๐ ํ๋์ ๋ฆฌ์คํธ์ ๋งํฌ์ ์์์ ๊ฐ์ฅ ์์ ๊ฐ์ ๊ฐ์ง index
๐ ๊ทธ index๊ฐ ๊ฐ์ง ๋งํฌ๊ฐ์ ๋ฐ๋ผ ๊ฐ๋ฉด์ ์ ๋ ฌํ๋ค
if(๋ฒ์์ ํ๊ฐ ์ด์์ ์์ ์กด์ฌ์) {
mid
q = low, mid๋ก ์ํํธ์ถ(๊ทธ ์ค ๊ฐ์ด ๊ฐ์ฅ ์์ ์์์ index)
r = mid+1, high๋ก ์ํํธ์ถ(๊ทธ ์ค ๊ฐ์ด ๊ฐ์ฅ ์์ ์์์ index)
return (q, r) Combine
}
else return (1๊ฐ ์๋ ์์ index)
2.4 Combine2
while(๋ ๊ฐ์ ๋ฆฌ์คํธ๊ฐ ๋ค ์์๊ฐ ์๋ ๊ฒฝ์ฐ) {
if(a[i] < a[j]) {
link[k] = i; k = i; i = link[i];
}
else {
link[k] = j; k = j; j = link[j];
}
i์ j์ค ๋จ์์๋ ์ชฝ์ link[k]์ ๋ฃ์ด์ค๋ค
3. ํต ์ ๋ ฌ(Quick sort)
๐ ๋ถํ ๋ ๋ ๋ถ๋ถ์ ๋ฐฐ์ด์ด ๋์ค์ ํฉ๋ณ๋ ํ์๊ฐ ์๋ค.
๐ a[1]~a[k-1] / a[k] / a[k+1]~a[n]
๐ ์ด ๋, a[k]๋ ๋ถํ ์์(๋๋ ์ค์ถํค)๋ผ ํ๋ฉฐ, ์ ๋ ฌ ํ์๋ ์์น ๋ณ๋์ด ์๋ค.
๐ i๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํ๋ฉฐ ๊ธฐ์คํค๋ณด๋ค ํฐ ๊ฒ ์ฐพ๊ณ , j๋ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๋ฉฐ ๊ธฐ์คํค๋ณด๋ค ์์ ๊ฒ ์ฐพ๋๋ค.
3.1 QuickSort1
if(์์๊ฐ 2๊ฐ ์ด์ ์์ผ๋ฉด) {
Partition //a์ ์ ์ผ ์ผ์ชฝ ์์๊ฐ k ์์น์ ๋ค์ด๊ฐ๊ณ ๋ถํ , ๊ธฐ์คํค=a[k], a์ ์๋ค ๋ฆฌ์คํธ
p~k-1 ์ํํธ์ถ
k+1~q ์ํํธ์ถ
}
3.2 Partition
๋ฐ์ดํฐ ๋ค์ด์๋ ๋ฐฐ์ด, ์ ์ผ ์ผ์ชฝ ์์, ์ ์ผ ์ค๋ฅธ์ชฝ ์์+1 ๋ฅผ ๊ฐ์ง๊ณ ์ํ
i๊ฐ ๊ธฐ์คํค๋ณด๋ค ์์ ๋์ i++
j๊ฐ ๊ธฐ์คํค๋ณด๋ค ํด ๋์ j--
i๊ฐ j๋ณด๋ค ์์ผ๋ฉด ๋์ ๊ฐ ์๋ก ๊ตํ
๋ฐ๋ณต๋ฌธ ๊ณ์ ์ํํ๋ค๊ฐ
i๊ฐ j๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์์ง๋ฉด ๋ฐ๋ณต๋ฌธ ์ข ๋ฃ
3.3 ์๊ฐ ๋ณต์ก๋ : O(n^2)
3.4 ์ค๊ฐ๊ฐ ๊ท์น
๐ ์ ๋ ฌํ๊ณ ์ ํ๋ ๊ฒ ์ค ์ ์ผ ์ ์์, ๊ฐ์ด๋ฐ ์์, ๋ง์ง๋ง ์์ ์ค ์ค๊ฐ ํฌ๊ธฐ์ ๊ฐ์ ๊ธฐ์คํค๋ก ์ฌ์ฉ(๋งจ ์์ผ๋ก)
๐ ํต ์ ๋ ฌ์์ ์ต์ ์ ๊ฒฝ์ฐ๋ฅผ ํผํ๊ธฐ ์ํด ์ฌ์ฉ
4. ์ ํ(Selection)
4.1 ๋ฌธ์ : ๋ฆฌ์คํธ์ k๊ฐ ์ฃผ์ด์ง ๋ k๋ฒ์งธ ์์ ์์๋ฅผ ๊ฒฐ์ ํ์ฌ k์์น์ ๋๊ณ , k์์น ์์๋ k๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์๋ค์ด ์ค๊ณ , k์์น ๋ค์๋ k๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ ์์๋ค์ด ์ค๋๋ก ๋ฐฐ์นํ๋ผ.
4.2 ํต ์ ๋ ฌ๊ณผ์ ๊ณตํต์ ๊ณผ ์ฐจ์ด์
๐ ํต ์ ๋ ฌ์ฒ๋ผ ๋ถํ ์ ์ฌ์ฉํ๋ค. (๋ถํ ์ ๋ณต ๊ธฐ๋ฒ ์ฌ์ฉ)
๐ ํ๋ฒ์ ๋ถํ ๋ก ์ธํด์ ๊ธฐ์คํค a[k]์, a[1]~a[k-1], a[k+1]~a[n]์ผ๋ก ๊ตฌ์ฑ๋๋ค.
๐ a[k]๊ฐ k๋ฒ์งธ ์์ ์์๋ผ๋ฉด ๋ฉ์ถ๋ค. ๋ ์ด์ ๋ถํ ํ์ง ์๋๋ค.
๐ k๋ณด๋ค ๊ธฐ์คํค๋ณด๋ค ์์ผ๋ฉด ์์ชฝ, ํฌ๋ฉด ๋ค์ชฝ์์ ๋ถํ ๊ณ์ํ๋ค.
๐ ํต ์ ๋ ฌ์ ๊ธฐ์คํค์ ์, ๋ค ๋ฆฌ์คํธ์ ๋ํด "๋ชจ๋" ๋ถํ ์ ์ํํ๋ค.
๐ ์ ํ ๋ฌธ์ ๋ ์, ๋ค ๋ฆฌ์คํธ ์ค ํ๋๋ง ๋ถํ ์ ์ํํ๋ค. ๊ฒฐํฉ๋ ํ์ง ์๋๋ค.
4.3 Select
๋ถํ ํ ๋ฒ์ ์ ์ธ
Partition ์ํ, ๊ธฐ์คํค๋ฅผ k์์น์ ๋๊ณ ์ฌ๋ฐฐ์น
k๊ฐ ๊ธฐ์คํค์ ๊ฐ์์ง๋ฉด ๋, return
k๊ฐ ๊ธฐ์คํค๋ณด๋ค ์์ผ๋ฉด ์ผ์ชฝ ๋ฒ์
k๊ฐ ๊ธฐ์คํค๋ณด๋ค ํฌ๋ฉด ์ค๋ฅธ์ชฝ ๋ฒ์
4.4 ์๊ฐ๋ณต์ก๋ : O(n^2)
5. Strassen์ ํ๋ ฌ ๊ณฑ์
5.1 ์๊ฐ๋ณต์ก๋ : O(n^3)
'algorithm > theory' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์๊ณ ๋ฆฌ์ฆ ์ค๊ณ๊ธฐ๋ฒ ์ ๋ฆฌ (0) | 2021.05.19 |
---|