01) ์๋ฃ๊ตฌ์กฐ์ ์๊ณ ๋ฆฌ์ฆ
- ์๋ฃ๊ตฌ์กฐ์ ๊ฐ๋
๋ฌธ์ ํด๊ฒฐ์ ์ํ ์๋ฃ์ ๊ณต๊ฐ ๋ฐ ์๊ฐ์ ์๋ฏธ์ ํจ์จ์ ์ฌ์ฉ(์ฒ๋ฆฌ)๋ฅผ ์ํด ๊ตฌ์กฐํํ ๊ฒ.
- ๋ฐ์ดํฐ ์ ๋ณด
์ ํ๊ตฌ์กฐ(๋ฐฐ์ด), ๋น์ ํ๊ตฌ์กฐ(ํฌ์ธํฐ)
- ์ ๋ณด์ฒ๋ฆฌ
- ๋จ์
Bit – Byte – Field – Record – File – DB
Bit๋ ์ ๋ณดํํ์ ์ต์๋จ์ (on/off) Binary Digit(2์ง์)
Byte(= 4 Bit) ๋ฌธ์ ํํ์ ์ต์๋จ์, ์ ๋ ์ฃผ์๊ฐ ์์.
Field๋ ๋ฌธ์๊ฐ ๋ชจ์ธ ์๋ฏธ์๋ ํ๋์ ๋ฐ์ดํฐ ๋จ์. (๋ ผ๋ฆฌ์ ์๋ฃ ๋จ์)
Record๋ ์ฐ๊ด๋ ํ๋๋ค์ ๋ชจ์.
File์ด๋ ์ฐ๊ด๋ ๋ ์ฝ๋๋ค์ ๋ชจ์. ๊ธฐ์ต์ฅ์์ ์ ์ฅ๋์ด ์ฐ์์ ์ธ ๋ฌธ์์ด๋ค์ ๋ชจ์.
- ํํ
์์น๋ฐ์ดํฐ : ์ ์์ ์ค์, 2์ง๋ฒ 8์ง๋ฒ 16์ง๋ฒ 10์ง๋ฒ.
- ์๊ณ ๋ฆฌ์ฆ์ ์ ์
์ด๋ค ํน์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํ ์ ์ฐจ์ ๋ฐฉ๋ฒ์ ๋ช ํํ๊ฒ ๊ธฐ์ ํด ๋์ ๋ช ๋ น๋ค์ ์งํฉ.
- ์๊ณ ๋ฆฌ์ฆ 5๋ ์กฐ๊ฑด
์ ๋ ฅ, ์ถ๋ ฅ, ๋ช ํ์ฑ, ์ ํ์ฑ, ์ค์ ์ฑ
0๊ฐ ์ด์ ์ ๋ ฅ๋ฐ์ดํฐ ํ์, ํ๋ ์ด์ ๊ฒฐ๊ณผ ์ถ๋ ฅ, ๋ช ๋ น์ด ์ ๋งค๋ชจํธX ๋ช ํํ๊ฒ ์กด์ฌ, ์ ํ ๋ฒ ์คํ ํ ๋ฐ๋์ ์ข ๋ฃ๋์ด์ผํจ, ์ค์ง์ ์ผ๋ก ์คํ ๊ฐ๋ฅํด์ผํจ.
- ์๊ณ ๋ฆฌ์ฆ ๋ถ์ 3๊ฐ ๋ฐฉ๋ฒ
์๊ฐ ๋ณต์ก๋(์ํ๋) ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ๋ถ์ํจ. (์ํ๋์ ์ฐจ์(Degree)๋ก ํํ)
big-o ํํ๋ฒ > ์๊ณ ๋ฆฌ์ฆ ์ํ์ ์์ด ์ฐ์ฐ ์ฐจ์๊ฐ ๊ฐ์ฅ ๋์ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฐจ์๋ก ํํ.
big-omega ํํ๋ฒ > “” ์ฐจ์๊ฐ ๊ฐ์ฅ ๋ฎ์ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฐจ์๋ก ํํ
big-theta ํํ๋ฒ > ์ค์ ์ค๋ฉ๊ฐ ํํ๋ฒ ๊ต์ฐจ๋๋ ๋ถ๋ถ. ์ต์ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ํํ.
- ๋คํญ์๊ฐ, ์ง์์๊ฐ, ์์ฌ์ฝ๋
๋คํญ์๊ฐ = ์ด๋ ํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ (big-O ํํ๋ฒ)
์ง์์๊ฐ = ์๊ฐ๋ณต์ก๋
02) ์ถ์ ๋ฐ์ดํฐ ํ์ ๊ณผ ๋ฐฐ์ด
- ๋ฐ์ดํฐ ์ถ์ํ 3๊ฐ์ง
1. float f = 3.14; - ๋ฐ์ดํฐ ํ์ . ์ถ์์๋ฃํ ์ ์ธ.
2. #include <stdio.h>
3. ๊ฐ์ฒด(Object) – ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์ฌ์ฉ๋๋๋ ํจ์(๋ฉ์๋) ํฉ์น ๊ฒ
์บก์ํ
- ๋ฐฐ์ด์ ์ ์
์ฐ์์ ์ธ ๊ธฐ์ต์ฅ์น์ 1๊ฐ์ ๋ธ๋ก์ผ๋ก ์ ์ฅ๋๋ ๊ฒ.
์ฐ์์ ์ผ๋ก ๋ฐฐ์น๋ ๊ธฐ์ต์ฅ์์ ์์น, ์ธ๋ฑ์คํ ๊ฐ์ mappingํ์ฌ ์ฌ์ฉ.
- ๋ฐฐ์ด์์์ ์์ ์์น (n์ฐจ์ ๋ฐฐ์ด C์ธ์ด๋ก ํํ, index๊ฐ 1์ธ๊ฒฝ์ฐ์ 0์ธ ๊ฒฝ์ฐ ์์น๊ณ์ฐ
<0๋ฒ์ง ์ฃผ์ ์๋๋>
1์ฐจ์ ๋ฐฐ์ด : A[0]์ ์์น์ฃผ์ + (I * ์์ํฌ๊ธฐbyte)
2์ฐจ์ ๋ฐฐ์ด : A(u1,u2)์์ (i1,i2)์ ํน์ ์์น๋
location = i1 * u2 +i2
3์ฐจ์ ๋ฐฐ์ด : A(u1,u2,u3)์์ (i1,i2,i3)์ ํน์ ์์น๋
location = i*u2*u3 + i2*u3 + i3
(๋ฌธ์ํ = 1Byte, ์ ์ํ = 2Byte, ์ค์ํ = 3Byte)
<์๋ ํน์ ์์น์ ๋>
2์ฐจ์ ๋ฐฐ์ด : location(row) = u2*(i1-1)+i2
location(column) =
- ํฌ์ํ๋ ฌ์ ํน์ฑ
2์ฐจ์ ๋ฐฐ์ด์์ 0์ธ ์์๊ฐ ๋ง์ ๋ฐฐ์ด. m*n์ ํ๋ ฌ์์ 0์ด ์๋ ์์๋ค๋ก๋ง ๊ณจ๋ผ ํ๋ ฌ์ ๋ค์ ๊ตฌ์ฑํ๊ธฐ์ ๋ฐ์ดํฐ๊ฐ m*n๊ฐ ๋ณด๋ค ํจ์ฌ ์ ์ผ๋ฏ๋ก ๊ธฐ์ต์ฅ์๋ฅผ ์ ์ฝํ๊ณ ๋น ๋ฅธ ํ์์ ์ํํ ์ ์๋ค.
03) ๋ฆฌ์คํธ
- ์ ํ๋ฆฌ์คํธ ์ ์
๋ฐ์ดํฐ๊ฐ ๊ธฐ์ต์ฅ์์ ์ฐ์์ ์ผ๋ก ์ ์ฅ๋์ด, ์์ฐจ์ ์ผ๋ก ์ฒ๋ฆฌ๋จ์ผ๋ก ๊ธฐ์ต์ฅ์ ํ์ฉ๋๊ฐ ๋์ผ๋ฉฐ, ์์ฃผ ๋ณ๊ฒฝํ์ง ์๋ ๋ฐ์ดํฐ์ ์ ์ฅ์ ์ ๋ฆฌํ๋ค.
๋ฐ์ดํฐ ์ถ๊ฐ์์ ์ฌ๋ถ์ ๊ธฐ์ต๊ณต๊ฐ์ ํ๋ณดํด์ผ ํ๊ณ , ๋ฐ์ดํฐ์ ์ถ๊ฐ์ ์ญ์ ์ ๋ง์ ๋ฐ์ดํฐ์ ์ด๋์ด ํ์ํ๋ค.
์์ฐจ๋ฆฌ์คํธ๋ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์ ํ๋ฆฌ์คํธ ๊ตฌ์กฐ๋ก ํํํ ๊ฒ.
- ์ฝ์ ๊ณผ ์ญ์ ๋ฐฉ๋ฒ
n๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋ ์ ํ๋ฆฌ์คํธ์์ k๋ฒ์งธ์ ๋ฐ์ดํฐ ์ถ๊ฐ์ (n-k+1) ๋ฐ์ดํฐ ์ด๋ ๋ฐ์.
n๊ฐ์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋ ์ ํ๋ฆฌ์คํธ์์ k๋ฒ์งธ์ ๋ฐ์ดํฐ ์ญ์ ์ (n-k) ๋ฐ์ดํฐ ์ด๋ ๋ฐ์.
- ๋ฐ์ดํฐ ์ด๋์ ๋ฌธ์ ์
ํ๊ท ์ ์ผ๋ก n/2 ๋งํผ (์ ๋ฐ) ์ด๋ํจ์ผ๋ก, ๋ง์ ์๊ฐ ๋ญ๋น.
๋ค์ํ ํฌ๊ธฐ์ ์์๋ฅผ ๋ฆฌ์คํธ ํํ์ ์ํด ์ต๋๊ณต๊ฐ์ ๊ฐ๋ ๊ธฐ์ต์ฅ์๋ฅผ ํ ๋นํ๋ฉด์ ๊ธฐ์ต๊ณต๊ฐ์ ๋ญ๋น.
๋ง์ผ ๊ธฐ์ต์ฅ์๋ฅผ ์๊ฒํ๋ค๋ฉด, ๋ฆฌ์คํธ์์ ์ฝ์ ์ฐ์ฐ์ด ๋ฐ์ํ์ฌ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ๋ฉด ์ฌ์ฉ ๊ฐ๋ฅํ ์์ญ์ ์ด๊ณผํ ๊ฒ์ผ๋ก ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์๋๋ค.
- ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๊ฐ๋
ํน์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง ๋ ธ๋๊ฐ ๋ค์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํฌ์ธํฐ(์ฃผ์)๋ฅผ ๊ฐ์ง๊ณ ์ฒ๋ฆฌํ๋ ๊ตฌ์กฐ.
ํฌ์ธํฐ๋ ๋ค์ ๋ฐ์ดํฐ์ ์ฃผ์๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ฐ์ดํฐ์ ์ฃผ์๋ฅผ ํ๋์ ๋ ธ๋์ ํํํจ์ผ๋ก ๊ตฌ์กฐ์ฒด๋ฅผ ์ฌ์ฉ.
๋ฐ์ดํฐ์ ์ถ๊ฐ์ ์ญ์ ๊ฐ ๊ฐ๋จํ๋ฉฐ, ๋ฐ์ดํฐ ์ด๋์ด ํ์์๋ค.
- ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ข ๋ฅ
๋จ์ ์ฐ๊ฒฐ๋ฆฌ์คํธ
ํํ ์ฐ๊ฒฐ๋ฆฌ์คํธ
์ด์ค ์ฐ๊ฒฐ๋ฆฌ์คํธ
์ด์ค ํํ ์ฐ๊ฒฐ๋ฆฌ์คํธ
- ์ถ๊ฐ, ์ญ์ ์๊ณ ๋ฆฌ์ฆ + ๊ธฐ์ต๊ณต๊ฐ ํ ๋นํด์
04) ์คํ๊ณผ ํ
- ์คํ์ ๊ฐ๋
๋ฐ์ดํฐ์ ์ ์ถ๋ ฅ์ด ํ์ชฝ๋ฐฉํฅ์์๋ง ์ํ๋๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ (LIFO)
Top ํฌ์ธํฐ ์ฌ์ฉํ๋ฉฐ, Push๋ ์ ๋ ฅ, Pop์ ์ถ๋ ฅ.
- ์ถ๊ฐ ์ญ์ ์๊ณ ๋ฆฌ์ฆ
<์ถ๊ฐ> if(TOP>=N) {printf(“Overflow”);
else{
s[top] = data;
top = top+1;
}
<์ญ์ >
if(top==0) {printf(“Underflow”)}
else{
top=top-1;
s[top]=NULL;
- ์คํ์ ์ด์ฉ๋ถ์ผ
์๋ ๋ณ์์ ์ฌ์ฉ. (c์ธ์ด ๋ณ์์ ์ฌ์ฉ๋ฒ์ ์ง์ )
์์ ์ฐ์ฐ์ ์ด์ฉ. (์ฐ์ฐ์ ์คํ๊ณผ ํผ์ฐ์ฐ์ ์คํ์ ์ฌ์ฉ)
์์์ ํํ๊ณผ ์ฐ์ฐ์ ์ฌ์ฉ.
- ํ์ ๊ฐ๋
๋ฐ์ดํฐ์ ์ ์ถ๋ ฅ์ด ์ ํ๋ฆฌ์คํธ์ ์์ชฝ ๋์์ ๋ชจ๋ ์ํ์ด ๋๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ(FIFO)
์ ๋ ฅ์ tail ํฌ์ธํฐ ์ฌ์ฉ, ์ถ๋ ฅ์ head ํฌ์ธํฐ ์ฌ์ฉ.
- ํ์ ์ถ๊ฐ ์ญ์ ์๊ณ ๋ฆฌ์ฆ
<์ถ๊ฐ> if(tail>=n) printf(“Overflow”)
Q[tail]=data;
tail= tail+1
<์ญ์ > if(head == 0 && tail ==0) {printf(“Underflow”)}
if(head < tail){
Q[head] = NULL;
head = head +1;
if (head == tail) { //์ธ๋ํ๋ก์ฐ
return
}
}
circular queue
์ถ๊ฐ
tail=(tail+1)%n
if(head==tail){
if(Q[tail]==NULL){
Q[tail] = data
printf(“overflow”);
return}
05) ํธ๋ฆฌ
- ํธ๋ฆฌ์ ์ ์
๋งํฌ๋๋ฆฌ์คํธ ์ฌ์ฉํ์ฌ ์ ๋ณด์ ๊ฐ ํญ๋ชฉ๋ค์ ๊ณ์ธต์ ์ผ๋ก ์ฐ๊ด๋๋๋ก ๊ตฌ์กฐํ ์ํค๋ ๋น์ ํ ์๋ฃ๊ตฌ์กฐ.
๋จํ๋์ ๋ฃจํธ๋ ธ๋๊ฐ ์กด์ฌ, ๋ฃจํธ๋ ธ๋์์ ๊ฐ์ (edge)์ผ๋ก ๋ค๋ฅธ ๋ ธ๋ ์ฐ๊ฒฐ.
- ํธ๋ฆฌ์ ์ข ๋ฅ
์ผ๋ฐํธ๋ฆฌ : 3๊ฐ ์ด์์ ๋งํฌ๋ฅผ ๊ฐ์ง ํธ๋ฆฌ
์ด์งํธ๋ฆฌ : ํธ๋ฆฌ์ ์ฐจ์๊ฐ 2 ์ดํ์ธ ํธ๋ฆฌ.
์ ์ด์งํธ๋ฆฌ(full binary) : ๋ ธ๋์ ์๊ฐ 2^k – 1 ์ธ ํธ๋ฆฌ
์ ์ด์งํธ๋ฆฌ(complete binary) : ๋ ธ๋์ ์๊ฐ s^(k-1) < n < s^k -1 ์ธ ํธ๋ฆฌ
skwed tree : ํ์ชฝ๋ฐฉํฅ์ผ๋ก ์น์ฐ์น ํธ๋ฆฌ.
Threaded binary tree : ํธ๋ฆฌ์์ ์ฌ์ฉ๋์ง ์๋ NULL ํฌ์ธํฐ ๊ฐ์ ํธ๋ฆฌ ์ดํ์ ์ฌ์ฉ.
์ ์์ฐ๊ฒฐ์ด๋ฉด 1, ์๋๋ฉด 0. ํ๋ณด์ .
- ํธ๋ฆฌ์ ๊ตฌํ(ํํ)
๋ฐฐ์ด์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ :
๋ถ๋ชจ๋ ธ๋ ์ ๊ทผ ์ฉ์ด. ์ ์ด์ง ํธ๋ฆฌ๋ ๊ธฐ์ต์ฅ์๋ญ๋น ์ ์. ๋ฐ์ดํฐ ์ถ๊ฐ์ญ์ ์ ๋ฐ์ดํฐ ์ด๋ ๋ฐ์. ์ฌํฅ์ด์งํธ๋ฆฌ๋ ๊ธฐ์ต์ฅ์ ๋ญ๋น.
๋งํฌ๋๋ฆฌ์คํธ ์ด์ฉํ๋ ๋ฐฉ๋ฒ :
๋ ธ๋์ ํฌ์ธํฐ ๊ฐ์ ์ฌ์ฉํ๋ฉฐ ํธ๋ฆฌ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ.
n๊ฐ์ ๋ ธ๋๋ฅผ ๊ฐ์ง k์ง ํธ๋ฆฌ๋ n*k๊ฐ์ ๋งํฌ์๋ฅผ ๊ฐ์ง. n(k-1)+1 ๊ฐ์ ๋(NULL) ๋งํฌ ์๋ฅผ ๊ฐ์ง.(Threaded binary tree ํ)
- ํธ๋ฆฌ์ ์ดํ(์ํ)
ํธ๋ฆฌ ๋ด ํน์ ๋ ธ๋๋ฅผ ํ์ํ๋ ์์๋ฅผ ๊ฒฐ์ ํ๋ฉฐ, ํธ๋ฆฌ ๋ด์ ํน์ ๋ ธ๋๋ 1๋ฒ๋ง ์ฐธ์กฐ.
Inorder : Left, Root, Right node ์์ผ๋ก ๋ฐฉ๋ฌธ.
Preorder : Root, Left, Right node ์์ผ๋ก ๋ฐฉ๋ฌธ.
Postorder : Left, Right, Root nood ์์ผ๋ก ๋ฐฉ๋ฌธ.
06) ๊ทธ๋ํ
- ์ ์
๊ฐ ๋จ์ ์ ๋ณด๋ฅผ ์ ์ ์ผ๋ก ํํ. ๊ฐ ์ ์ ์ ๊ฐ์ ์ผ๋ก ์ฐ๊ฒฐํ์ฌ ๊ตฌ์กฐํ์ํจ ์๋ฃ๊ตฌ์กฐ.
๊ทธ๋ํ G๋ ์ ์ (Vertex)๊ณผ ๊ฐ์ (edge)๋ก ๊ตฌ์ฑ๋. Cycle์ ํ์ฑํจ.
- ์ฉ์ด
Adjacency(์ธ์ ), Path(๊ฒฝ๋ก), length(๊ฐ์ ์ ์), loop(๊ฒฝ๋ก๊ธธ์ด=1, ์๊ธฐ์์ ), cycle(์์์ ์์ ๋์์ค๋ ๊ฒฝ์ฐ), distancy(์ต๋จ๊ฒฝ๋ก๊ธธ์ด), degree(์ฐจ์. ํ ์ ์ ์ด ๊ฐ์ง๋ ๊ฐ์ ์ ์)
- ๊ทธ๋ํ์ ํํ
์ธ์ ํ๋ ฌ : ๊ทธ๋ํ๋ฅผ 2์ฐจ์ ๋ฐฐ์ด๋ก ํํ. ์ธ์ ํ๋ ฌ์ด A๋ผ ํ ๋ A(i,j) ๊ฐ 1์ด๋ฉด i์ j ์ ์ ์ฐ๊ฒฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ผ๋ก ํํ
- ๊ทธ๋ํ์ ์ดํ(๊ตฌํ)
DFS(Depth First Search) ๊น์ด์ฐ์ ํ์
1. ์์์ ์ v๋ฅผ ๊ฒฐ์ ํ๊ณ ๋ฐฉ๋ฌธ
2. V์ ์ธ์ ํ ์ ์ ๊ฐ์ด๋ฐ ๋ฐฉ๋ฌธ๋์ง ์์ ์ ์ ๋ฐฉ๋ฌธ.
3. ๋ชจ๋ ์ ์ ๋ฐฉ๋ฌธํ๋ฉด, ๋ฐฉ๋ฌธ๋์ง ์์ ์ธ์ ํ ๋ง์ง๋ง ์ ์ ๋ฐฉ๋ฌธ.
4. ๋ชจ๋ ์ ์ ๋ฐฉ๋ฌธํ๋ฉด ์ข ๋ฃ
BFS(Breadth First Search) ๋๋น์ฐ์ ํ์
1. ์์์ ์ v๋ฅผ ๊ฒฐ์ ํ๊ณ ๋ฐฉ๋ฌธ
2. V๋ฅผ ํ์ ์ ์ฅํ๊ณ ๋ด์ฉ ์ถ๋ ฅ
3. ํ์ ์ธ์ ํ ์ ์ ์ ๊ฐ์ง๊ณ (2)์ํ
4. ํ๊ฐ Underflow ๋๋ฉด ์ข ๋ฃ.
- ๊ทธ ์ธ
์ ์ฅํธ๋ฆฌ(Spanning Tree) : ๊ทธ๋ํ G์ ๋ชจ๋ ์ ์ ์ ํฌํจํ ํธ๋ฆฌ
์ต๋จ๊ฒฝ๋ก(Shortest Path) : ํ ์ ์ ์์ ์์์ ์ ์ ์ต๋จ ๊ฒฝ๋ก์ ๊ฐ.
A^k[i][j] > k๋ณด๋ค ํฐ ์ ์ ์ง๋์ง ์๊ณ i์์ j๋ก ๊ฐ๋ ๊ฒฝ๋ก.
07) ํ์
- ํ์์ข ๋ฅ
์์ฐจํ์(Sequential Search) : ์ธ๋ฑ์ค ์ฆ๊ฐor๊ฐ์ ์์ผ ์ฐจ๋ก๋๋ก ๋น๊ตํ์
Binary ํ์ : ์ ๋ ฌ๋ ์ํ์์ 1/2์ฉ ๋ฒ์ ์ค์ด๋ฉด์ ํ์
Fibonacci ํ์ : ํผ๋ณด๋์น ์์ด ๊ฐ ์ธ๋ฑ์ค๋ก ์ฌ์ฉํด ํ์
Interpolation ํ์ : ์ ๋ ฌ๋ ๋ฐ์ดํฐ์ ํธ์ฐจ๋ฒ์๊ฐ ์ผ์ ํ ๋ ํจ์จ์
Block ํ์ : ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ๋ธ๋ก๋จ์๋ก ๊ตฌ๋ถ. ๋ธ๋ก๋ด ๊ฐ์ฅ ํฐ๊ฐ์ ์ ์ฅํ์ฌ ์ด ๊ฐ๊ณผ ์ฐพ๊ณ ์ํ๋ ๊ฐ์ด ์ด๋ ๋ธ๋ก์ ํฌํจ๋์ด ์๋์ง ํ๋จํ ์์ฐจํ์ํ๋ค.
08) ์ด์งํ์ ํธ๋ฆฌ - ๊ฐ๋ ๋ง ์๊ธฐ
์ข์ธก์ ๋ฃจํธ๋ณด๋ค ์์๊ฐ, ์ฐ์ธก์ ๋ฃจํธ๋ณด๋ค ํฐ๊ฐ.
09) ํด์ฑ
- ํด์ฑ์ ๊ฐ๋
ํด์ํจ์์ ์ํ์ฌ ๊ณ์ฐ๋ ํค ๊ฐ์ ์ฃผ์๋ก ์ง์ ์ ๊ทผ.
“key-to-address transformation”
ํน์ ๊ท์น์ ๋ฐ๋ผ ์ฃผ์ด์ง ํค ๊ฐ์ ์ฃผ์๋ก ๋ณํํ์ฌ ํด์ ํ ์ด๋ธ์ด๋ผ๋ ๊ธฐ์ต๊ณต๊ฐ์ ํค์ ๋ ์ฝ๋๋ฅผ ์ ์ฅ.
ํด์ํจ์๋ฅผ ์ด์ฉํ์ฌ ํ์ํ ๋ ์ฝ๋์ ์ฃผ์๋ฅผ ์ฐ์ถํจ์ผ๋ก์ ๊ฒ์์์ ์ํ.
- ํด์ ํจ์ ์ค๋ช
์ ๋ ฅ๋ ํค ๊ฐ์ ํด์ ํ ์ด๋ธ์ ์ฃผ์๋ก ๋ณํ์ํค๋ ํจ์.
์ค๊ฐ์ ๊ณฑํจ์, ๋๋๊ธฐํจ์, Foldingํจ์, ๊ธฐ์๋ณํ๋ฒ, ์ซ์๋ถ์๋ฒ
- ์ถฉ๋์ ์ค๋ฒํ๋ก ํด๊ฒฐ ๋ฐฉ๋ฒ
๋ฒํท์ด ์ฌ๋ฌ ์ฌ๋กฏ์ผ๋ก ๊ตฌ์ฑ๋์ด ์์ผ๋ฉด ๋ค๋ฅธ ์ฌ๋กฏ์ ์ ์ฅ.
๊ทธ๋ฌ๋ ๋ชจ๋ ์ฌ๋กฏ์ด ์ฑ์์ก๋ค๋ฉด ๋ค๋ฅธ ๊ธฐ์ต์ฅ์๋ฅผ ์ฐพ์ ํค ๊ฐ์ ์ ์ฅํจ.
๊ฐ๋ฐฉ์ฃผ์๋ฒ : ํ ๋ ์ฝ๋(Data)์ ํค๋ก๋ถํฐ ๊ด๋ จ๋ ์ผ๋ จ์ ๋ฒํท ์ฃผ์ ์์ฑ.
์ถฉ๋ ๋ฐ์ํ๋ฉด ๊ทธ ๋ฒํท์ ์ฃผ์๋ก๋ถํฐ ๋น์ด์๋ ๋ฒํท ๋ฐ๊ฒฌํ ๋๊น์ง ์ฐพ์.
ํ์์ฃผ์๋ฒ(์ฒด์ธ๋ฒ) : ์ถฉ๋์ด ๋ฐ์ํ๋ ๋์์ด ๋ณ๋ก ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ์ ์ฅํ๋ ๋ฐฉ๋ฒ.
ํฉ๋ณ ์ฒด์ธ๋ฒ, ๋ถ๋ฆฌ ์ฒด์ธ๋ฒ ์ผ๋ก ๋๋จ.
11) ์ ๋ ฌ
- ์ ๋ ฌ์ ์ ์
๋ฌด์ง์ํ ๋ฐ์ดํฐ๋ฅผ ์ผ์ ํ key๊ฐ์ ์ํด ์ฌ๋ถ๋ฅํ๋ ๊ณผ์ .
์์ ๊ฒฐ๊ณผ๋ฅผ ์ค๋ฆ์ฐจ์, ๋ด๋ฆผ์ฐจ์์ผ๋ก ๊ตฌ๋ถ.
- ์ ๋ ฌ์ ์ข ๋ฅ
์ฝ์ ๋ฒ : insertion sort, shell
๊ตํ๋ฒ : bubble, selection, quick
์ ํ๋ฒ : heap
๋ณํฉ๋ฒ : z-way-merge
๋ถ๋ฐฐ๋ฒ : radix
- 8๊ฐ์ง ์ค 5๊ฐ ๋ฐฉ๋ฒ๋ก + ์ฝ๋ฉ๋ฐฉ๋ฒ
Bubble Sort : ๊ฐ์ฅ ํฐ๊ฐ์ ๋งจ ๋ค๋ก ์ด๋ํด๊ฐ๋ฉด์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ. ๋จ๊ณ์ ์ผ๋ก ํฐ ๊ฐ์ ์ ์ธํ๋ค.
Select Sort : ๊ฐ์ฅ ์์๊ฐ์ ๋งจ ์์ผ๋ก ์ด๋ํด๊ฐ๋ฉด์ ์ ๋ ฌํ๋ ๋ฐฉ๋ฒ. ๋จ๊ณ์ ์ผ๋ก ์์๊ฐ์ ์ ์ธํ๋ค.
Quick Sort (์ฌ๊ทํจ์) : ํน์ ํค๊ฐ์ธ ํผ๋ฒ์ค์ ํ์ฌ ์์๊ฐ ํฐ๊ฐ ๋ ์ฝ๋ ๋ถ๋ฆฌํ์ฌ ์๋ธ๋ฆฌ์คํธ ๊ตฌ์ฑ. ๊ฐ์ฅ๋น ๋ฅธ์ ๋ ฌ์ํ.
Insertion Sort( ์ฝ์ ์ ๋ ฌ) ์์๊ฐ ์ ํด์ ์์์ง ํฐ์ง ๋น๊ต.
Shell Sort : ์ผ์ ํ ๊ฑฐ๋ฆฌ๋งํผ ๋จ์ด์ง 2๊ฐ์ ๋ฐ์ดํฐ ๋น๊ตํ์ฌ ํฌ๋ฉด ๋ณด๊ดํ๋ ๊ณผ์ ์ ๋ฐ๋ณตํด ์ ๋ ฌ.
Heap Sort : ๋ฐ์ดํฐ๋ฅผ ํธ๋ฆฌ๋ก ํํ. ์ตํ์ ๋ ๋ฒจ์ ์ฐ์ธก ๋ ธ๋๋ถํฐ ๋ถ๋ชจ๋ ธ๋์ ๋น๊ต. ์๋ ธ๋ ๊ฐ์ด ์ค๋ฉด ๋ถ๋ชจ๋ ธ๋์ ๊ตํ.
๋ฃจํธ๋ ธ๋์ ๊ฐ์ฅ ํฐ๊ฐ์ด ์์นํ๋ฉด ์ตํ์ ๋ ๋ฒจ์ ์ฐ์ธก ๋ง์ง๋ง ๋ ธ๋์ ๊ตํ ๋ค , ์ด ๊ฐ์ ๋ค์ heap์์ ์ ์ธํ๋ค.