์ 1์ฅ ์ํํธ์จ์ด๊ณตํ๊ณผ ์๋ฃ๊ตฌ์กฐ ๊ฐ์ ์ด ์ฅ์์๋ ์ํํธ์จ์ด๊ณตํ๊ณผ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ๊ฐ๋จํ ์๊ฐํ๋ค.
1.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์ํํธ์จ์ด ๊ฐ๋ฐ ์ ์ฐจ ๊ณ ํ์ง ์ํํธ์จ์ด์ ๋ชฉํ ์ํํธ์จ์ด ์ค๊ณ ๋ฐฉ๋ฒ๋ก ๊ฐ์ฒด์งํฅ ์ค๊ณ ๋ฐฉ๋ฒ๋ก ์ํํธ์จ์ด ์ ํ์ฑ ๊ฒ์ฆ ๋ฐฉ๋ฒ ์๋ฃ๊ตฌ์กฐ ๊ฐ์
1.2. ์ํํธ์จ์ด๊ณตํ
์ํํธ์จ์ด ์ ์ฐจ ์ํํธ์จ์ด์ ํฌ๊ธฐ๊ฐ ์ปค์ง๊ณ ๋ณต์กํด์ง์๋ก ์ฝ๋ฉ ์ธ์ ๋ค๋ฅธ ์ํํธ์จ์ด ์ด์์ ๋ํด ๊ด์ฌ์ ๊ฐ์ ธ์ผ ํ๋ค. ํ ํ๋ก์ ํธ ์ํ์ ๋์ฑ ์ค์ ์ํํธ์จ์ด ๊ฐ๋ฐ์ ๋จ๊ณ ๋ฌธ์ ๋ถ์: ํ๋น์ฑ ์กฐ์ฌ, ์ฑ๊ฒฉ, ๋ฒ์, ๋ชฉ์ ์๊ตฌ์ฌํญ ๋ถ์: ์ฌ์ฉ์ ๋ฐ ์์คํ ์๊ตฌ์ฌํญ ์ํํธ์จ์ด ๋ช ์ธ์: not how but what ์ค๊ณ ์ํ ๋ถ์ ๊ตฌํ ๊ฒ์ฌ์ ๊ฒ์ฆ ์ด์ ์ํํธ์จ์ด ์๋ช ์ฃผ๊ธฐ(lifecycle) ์ ์ง๋ณด์ not sequential!!!
๋ณดํต ์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ์ด๋ผ ํ๋ฉด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ด์ฉํ์ฌ ์ฝ๋ฉ์ ํ๋ ๊ฒ๋ง์ ์๊ฐํ ์ ์๋ค. ํ์ง๋ง ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ๋ค๋ ๊ฒ์ ๋จ์ํ ์ฝ๋ฉ๋ง ํ๋ ๊ฒ์ ์๋๋ฉฐ, ์ฌ๋ฌ ๊ฐ ์ง ๊ณผ์ ์ ํตํด ์ด๋ฃจ์ด์ง๋ค. ํนํ, ๋ณต์กํ ์ํํธ์จ์ด์ผ์๋ก ์ฝ๋ฉ๋ณด๋ค๋ ๋ค๋ฅธ ์ด์๋ค์ด ๋ณด ๋ค ๋ ์ค์ํด์ง ์ ์์ผ๋ฉฐ, ํ๋ก ๊ฐ๋ฐํ๋ ๊ฒ์ด ์๋๊ณ ํ์ ๊ตฌ์ฑํ์ฌ ๊ฐ๋ฐํ๋ ๊ฒฝ์ฐ์๋
- 1 -
์ด๊ฒ์ด ๋์ฑ ๋๋ ทํด์ง๋ค. ์ํํธ์จ์ด์ ๊ฐ๋ฐ์ ๋ฌธ์ ๋ถ์, ์๊ตฌ์ฌํญ ๋ถ์, ์ํํธ์จ์ด ๋ช ์ธ์ (specification) ์์ฑ, ์ค๊ณ, ๊ตฌํ, ๊ฒ์ฌ์ ๊ฒ์ฆ, ์ด์, ์ ์ง๋ณด์ ๋ฑ์ ๋จ๊ณ๋ก ๊ตฌ์ฑ๋๋ค. ํ์ง๋ง ์ด๋ฐ ๋จ๊ณ๋ฅผ ์์ฐจ์ ์ผ๋ก ์ํํ๋ ๊ฒ์ ์๋๋ค. ์ค๊ณ๋ฅผ ํ๋ค๊ฐ ์๊ตฌ์ฌํญ ๋ถ์์ ๋ค์ ํด์ผ ํ๋ ๊ฒฝ์ฐ๋ ์์ ์ ์๊ณ , ๊ตฌํ์ ํ๋ค๊ฐ ์ค๊ณ๋ฅผ ๋ค์ ํด์ผ ํ๋ ๊ฒฝ์ฐ๋ ์์ ์ ์๋ค. ๋ ํ ๋ ๋จ๊ณ๊ฐ ๋ณํ์ผ๋ก ์ํ๋ ์๋ ์๋ค.
์ํํธ์จ์ด ์ ์ฐจ โ ๊ณ์ ๋ฌธ์ /์๊ตฌ์ฌํญ ๋ถ์ํ ๋ ๊ณ ๋ ค ์ฌํญ ์ ๋ ฅ์ ํํ, ๋ฐ์ดํฐ์ ์ ํจ์ฑ ํ๋จ ๊ธฐ์ค, ์ํํธ์จ์ด๋ฅผ ์ฌ์ฉํ ์ฌ์ฉ์ ์ ํ, ์ฌ์ฉ์ ์ธํฐํ์ด์ค์ ํํ, ์์ธ์ ์ธ ํน์ํ ๊ฒฝ์ฐ์ ์กด์ฌ ์ฌ๋ถ, ๋ฏธ๋์ ์ถ๊ฐ๋ ๊ธฐ๋ฅ ๊ฐ๋ฐํ ์ํํธ์จ์ด์ ํ๋กํ ํ์ (prototype) ๋๋ ์ผ๋ถ ๊ตฌ์ฑ์์์ ํ๋กํ ํ์ ํ๋กํ ํ์ ์ ๋ง๋ค๋ฉด ๊ด๋ จ ์ฌ๋๋ค๊ฐ์ ์ปค๋ฎค๋์ผ์ด์ ์ ํฅ์์ํฌ ์ ์์ผ๋ฉฐ, ์ ๋ฌธ์ ์ ๋ํ ๋ณด๋ค ์ ํํ ๋ต์ ์ป์ ์ ์๋ค.
์ํํธ์จ์ด ๊ณตํ ์ํํธ์จ์ด ๊ณตํ(software engineering): ๊ณ ํ์ง์ ์ํํธ์จ์ด ๊ณตํ ๊ฐ๋ฐ์ ๋ชจ๋ ์ธก๋ฉด๊ณผ ๊ด๋ จ๋ ํ๋ฌธ์ ๋งํจ ์ฌ์ฉ๋๋ ๊ธฐ์ ๊ณผ ํ์(๋ฌธ์ํ, ํ์ํฌ ๋ฑ)๋ฅผ ๋ชจ๋ ํฌํจ ์ํํธ์จ์ด ํ๋ก์ธ์ค(software process): ์์คํ ์ ๊ฐ๋ฐํ๊ธฐ ์ํด ํ๋ก์ธ์ค ๊ฐ์ธ ๋๋ ์กฐ์ง์ด ์ฌ์ฉํ๋ ์ํํธ์จ์ด ๊ณตํ ๊ธฐ์ ์ ์งํฉ์ ๋งํจ ์ฌ์ฉํ๋ ์ํํธ์จ์ด ๊ธฐ์ ๋๋ ๋๊ตฌ ํ๋์จ์ด ์ํํธ์จ์ด: ์ปดํ์ผ๋ฌ, ๋๋ฒ๊ฑฐ ๋ฑ ์์ด๋์ด์จ์ด: ์ํํธ์จ์ด ๊ธฐ์ ๊ณผ ๊ด๋ จ๋ ์ง์
์ํํธ์จ์ด๊ณตํ(software engineering)์ด๋ ๊ณ ํ์ง์ ์ํํธ์จ์ด ๊ฐ๋ฐ์ ๋ชจ๋ ์ธก๋ฉด๊ณผ ๊ด๋ จ๋ ํ๋ฌธ์ ๋งํ๋ค. ์ฌ๊ธฐ์๋ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ ๋ ์ฌ์ฉ๋๋ ๊ธฐ์ ๋ฟ๋ง ์๋๋ผ ํ์๋ ํฌํจ๋ ๋ค. ์ํํธ์จ์ด ํ๋ก์ธ์ค(software process)๋ ์์คํ ์ ๊ฐ๋ฐํ๊ธฐ ์ํด ๊ฐ์ธ ๋๋ ์กฐ์ง์ด ์ฌ ์ฉํ๋ ์ํํธ์จ์ด๊ณตํ ๊ธฐ์ ์ ์งํฉ์ ๋งํ๋ค. ์ฐ๋ฆฌ๊ฐ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ ๋ ์ฌ์ฉํ๋ ์ ํํธ์จ์ด ๊ธฐ์ ์ ํฌ๊ฒ ํ๋์จ์ด, ์ํํธ์จ์ด, ์์ด๋์ด์จ์ด(ideaware)๋ก ๋๋ ์ ์๋ค. ์ด ์ค ์ด ๊ณผ๋ชฉ๊ณผ ๊ฐ์ฅ ๋ฐ์ ํ๊ฒ ์ฐ๊ด๋ ๊ฒ์ ์์ด๋์ด์จ์ด์ด๋ค. ์์ด๋์ด์จ์ด๋ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ ๋ ์ฌ์ฉํ ์ ์๋ ์ง์์ ๋งํ๋ค. ๋ํ์ ์ธ ์์ด๋์จ์ด๋ก๋ ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ผ๋ จ์ ์ ํ ์ ์ฐจ์ธ ์๊ณ ๋ฆฌ์ฆ(algorithm), ํ๋ก๊ทธ๋จ์์ ์ ๋ณด๋ฅผ ์ฒ๋ฆฌํ ๋ ์ด ์ ๋ณด๋ฅผ ๋ชจ๋ธ๋ง
- 2 -
ํ๊ธฐ
์ํด
์ฌ์ฉํ๋
์๋ฃ๊ตฌ์กฐ(data
structure),
๊ฐ์ฒด์งํฅ๊ฐ๋ฐ๋ก ๊ณผ
๊ฐ์
๊ฐ๋ฐ๋ฐฉ๋ฒ๋ก ,
UML(Unified Modeling Language)์ ๊ฐ์ ์ํํธ์จ์ด๋ฅผ ์ค๊ณํ ๋ ์ฌ์ฉํ๋ ๋์ํ ๋๊ตฌ ๋ฑ ์ด ์๋ค.
๊ณ ํ์ง ์ํํธ์จ์ด์ ๋ชฉํ ๋์ํด์ผ ํ๋ค. ๊ณ ํ์ง SW๋ ๊ทธ๊ฒ์ ์๋ฌด๋ฅผ ์ ํํ๊ณ ์์ ํ๊ฒ ์ํํด์ผ ํ๋ค. ์์ ์ฑ, ์ ํ์ฑ, ์ฌ์ฉ์ ํธ๋ฆฌ์ฑ, ํจ์จ์ฑ ๋ง์ ์๊ฐ๊ณผ ๋ ธ๋ ฅ์ ํ์ง ์๊ณ ์์ ํ ์ ์์ด์ผ ํ๋ค. ์ํํธ์จ์ด์ ๋ชจ๋ ๋จ๊ณ์์ ์์ ์ด ํ์ํ ์ ์์ ์ ์ง๋ณด์: ๊ธฐ๋ฅ์ ์ถ๊ฐ, ๊ฒ์ฌ ๊ณผ์ ์์ ๋ฐ๊ฒฌํ์ง ๋ชปํ ์ค๋ฅ ์์ ์ด ์ฉ์ดํ๊ธฐ ์ํ ์กฐ๊ฑด ์ฝ๊ณ ์ดํดํ ์ ์์ด์ผ ํ๋ค. ร ๋ฌธ์ํ ๋ค๋ฃฐ ์ ์๋ ์ ๋์ ํฌ๊ธฐ๋ก ๋๋์ด์ ธ ์์ด์ผ ํ๋ค. ร ๋ชจ๋ํ ์ฌ์ฌ์ฉ์ด ๊ฐ๋ฅํด์ผ ํ๋ค. ์๊ตฌ๋ ์๊ฐ ๋ด์ ๊ทธ๋ฆฌ๊ณ ์ฑ ์ ๋ ๋น์ฉ์ ์ด๊ณผํ์ง ์๊ณ ์์ฑ๋์ด์ผ ํ๋ค.
์ํํธ์จ์ด๊ฐ ์ฌ๋ฐ๋ฅด๊ฒ ๋์ํ๋ค๋ ๊ฒ์ ํฌ๊ฒ ๋ค์ ๋ค ๊ฐ์ง ์ธก๋ฉด์์ ์ ๊ทผ๋๋ค. z ์์ ์ฑ(completeness): ์๋ ์ํํธ์จ์ด๊ฐ ์ ๊ณตํด์ผ ํ๋ ๋ชจ๋ ๊ธฐ๋ฅ์ ์ ๊ณตํด์ผ ํ๋ค. z ์ ํ์ฑ(correctness): ๊ฐ ๊ธฐ๋ฅ์ด ์๊ตฌ๋ ๊ฒฐ๊ณผ๋ฅผ ์ฃผ์ด์ผ ํ๋ค. z ์ฌ์ฉ์ ํธ๋ฆฌ์ฑ(usability): ์ธํฐํ์ด์ค๊ฐ ์ฌ์ฉํ๊ธฐ ํธ๋ฆฌํด์ผ ํ๋ค. z ํจ์จ์ฑ(efficiency): ์ต์ํ ์๊ตฌ๋ ์์ค๋งํผ์ ํจ์จ์ฑ์ ์ ๊ณตํด์ผ ํ๋ค. ์ด์ฐฝ๊ธฐ์๋ ์์ ์ฑ๊ณผ ํจ์จ์ฑ์ ๊ฐ์กฐํ์์ง๋ง ์ปดํจํ ํ๊ฒฝ์ด ๋ฐ๋ฌํจ์ ๋ฐ๋ผ ์ฌ์ฉ์ ํธ๋ฆฌ์ฑ์ ๋ ๋ง์ ์ด์ ์ ๋๋ค. ์ด ๊ด์ ์ ์ํํธ์จ์ด๋ฅผ ์ฌ์ฉํ๋ ์ธก์ ์๊ตฌ์ฌํญ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค. ๋ฐ๋ฉด์ ์ํํธ์จ์ด ๊ฐ๋ฐ์ ์ธก๋ฉด์์ ์ด๋ฐ ํน์ฑ๋ค์ ๊ณ ๋ คํ์ฌ ๊ฐ๋ฐํ์ฌ์ผ ํ์ง๋ง ์ํํธ์จ์ด ๊ฐ๋ฐ์๋ ์ถ๊ฐ์ ์ผ๋ก ์ํํธ์จ์ด๊ฐ ์์ ๋ฐ ํ์ฅ์ด ์ฉ์ดํ๋๋ก ๊ฐ๋ฐํด์ผ ํ๋ค. ์ด๊ฒ์ ์ํ ํธ์จ์ด ์ ์ฒด ๊ฐ๋ฐ ๋น์ฉ์์ ์ด๊ธฐ ๊ฐ๋ฐ ๋น์ฉ๋ณด๋ค๋ ์ ์ง๋ณด์์ ๋ ๋ง์ ๋น์ฉ์ด ์์๋๊ธฐ ๋ ๋ฌธ์ด๋ค.
- 3 -
๋ฌธ์ ์ ์ดํด ํ๋ก๊ทธ๋๋ฐ ์์ ์ ๋ํ ์ค๋ช ์ผ๋ก ๋ถ๋์ด 12ํ์ด์ง์ธ ๋ฌธ์๊ฐ ํ์๋ค์๊ฒ ์ ์๋์๋ค. ๊ธฐ๊ฐ์ ์ผ์ฃผ์ผ์ด ์ฃผ์ด์ก๋ค. ๋ค์์ ์ด๊ฒ์ ๋ํ ํ์๋ค์ ๋ฐ์์ ์กฐ์ฌํ ๊ฒฐ๊ณผ์ด๋ค. Panic and do nothing 39% Panic and drop the course 30% Sit down at the computer and begin typing 27% Stop and think 4%
๋ฌธ์ ์ ๋ํด ์ ํํ๊ฒ ์ดํดํ๋ ๊ฒ์ด ์ํํธ์จ์ด ๊ฐ๋ฐ์ ๊ฐ์ฅ ์ฒซ ๋จ๊ณ์ด๋ค. ์๊ฐ์ ์ถฉ๋ถํ ์ง ์๊ณ ๊ฐ๋ฐ์ ์ฐฉ์ํ๊ฒ ๋๋ฉด ์ฒ์์ ์๊ฐํ ์์ด๋์ด๋ฅผ ๋ฒ๋ฆฌ๊ธฐ ์ด๋ ค์์ง๋ค. ์ด๊ฒ์ ์ธ๊ฐ ์ ์ด๋ค ๋ณธ์ง์ ์ธ ํน์ฑ ์ค ํ๋์ด๋ค. ๋ฐ๋ผ์ ๋ฌธ์ ์ ๋ํด ์ถฉ๋ถํ ์ดํดํ๊ณ ๋ถ์ํ ๋ค์์ ๊ตฌํ์ ์ฐฉ์ํด์ผ ํ๋ค.
๋ฌธ์ ์ ์ดํด โ ๊ณ์ ์์ธํ ๋ฌธ์ ์ ๋ช ์ธ์ ์์ฑ ์๋ น: ์๋๋ฆฌ์ค๋ฅผ ์๊ฐํด๋ณธ๋ค. ์๋๋ฆฌ์ค: ํ๋ก๊ทธ๋จ์ ์คํํ์์ ๋ ์ผ์ด๋ ์ ์๋ ์ผ๋ จ์ ์ฌ๊ฑด ์1.1) ATM ๊ธฐ๊ณ ๊ณ ๊ฐ์ ์ํ ์นด๋๋ฅผ ์ฝ์ ํ๋ค. ATM์ ์นด๋๋ก๋ถํฐ ๊ณ์ข๋ฒํธ๋ฅผ ์์๋ธ๋ค. ATM์ PIN ๋ฒํธ๋ฅผ ์์ฒญํ๋ฉด ๊ณ ๊ฐ์ PIN ๋ฒํธ๋ฅผ ์ ๋ ฅํ๋ค. ATM์ PIN ๋ฒํธ๋ฅผ ํ์ธํ๋ค. ATM์ ๊ฑฐ๋ ์ข ๋ฅ(์ ๊ธ, ์ด์ฒด, ์กฐํ, ์ข ๋ฃ)๋ฅผ ๋ฌผ์ด๋ณธ๋ค. ๊ณ ๊ฐ์ ์กฐํ๋ฅผ ์ ํํ๋ค. ATM์ ๊ณ์ข์ ํ์ฌ ์์ก์ ์ฝ๊ณ ๊ทธ๊ฒ์ ๋ํ๋ด์ค๋ค. ATM์ ๊ฑฐ๋ ์ข ๋ฅ๋ฅผ ๋ค์ ๋ฌผ์ด๋ณธ๋ค. ๊ณ ๊ฐ์ ์ข ๋ฃ๋ฅผ ์ ํํ๋ค. ATM์ ์ํ์นด๋๋ฅผ ๋๋๋ ค์ค๋ค.
๋ฌธ์ ๋ฅผ ์ ํํ๊ฒ ์ดํดํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๊ฐ์ฅ ๋ํ์ ์ธ ๋ฐฉ๋ฒ์ ์ํํธ์จ์ด์ ๋์ ์๋๋ฆฌ ์ค๋ฅผ ์๊ฐํด๋ณด๋ ๊ฒ์ด๋ค.
- 4 -
์ํํธ์จ์ด ์ค๊ณ ์ถ์ํ(abstraction): ํน์ ๊ด์ฐฐ์ ์ ์ฅ์์ ์์คํ ์ ํ์์ ์ธ ์ถ์ํ ์ฌํญ๋ง์ ํฌํจํ๋ ๋ณต์กํ ์์คํ ์ ๋ํ ๋ชจ๋ธ ๊ด์ฐฐ์๋ง๋ค ๋ค๋ฅผ ์ ์์ ๋ถํ์ํ ํ์ ์์ค์ ์ธ๋ถ์ฌํญ์ ๋ํ ๊ณ ๋ ค ์์ด ์ ์ ํ ์์ค์์ ๋ฌธ์ ์ ๋ํด ์ง์คํ ์ ์๋๋ก ํด์ค๋ค. (stepwise-refinement) ์ถ์ํ๋ ๊ฒ์ ์ ์ง์ ์ผ๋ก ์ธ๋ถํ๋์ด ๊ตฌ์ฒดํ๋๋ค. ํํฅ์(top-down) ์ํฅ์(bottom-up) ๊ฐ์ฒด์งํฅ ์ ๊ทผ ๋ถํ ์ ๋ณต(divide-and-conquer): ๋ณต์กํ ๋ฌธ์ ์ผ ์๋ก ํ ๋ฉ์ด๋ฆฌ๋ก ๋ถํ ์ ๋ณต ์ ๊ทผํ๋ ๊ฒ์ด ๋งค์ฐ ์ด๋ ต๋ค.
๋ฌธ์ ์ ๋ํ ์ดํด๋ฅผ ๋ฐํ์ผ๋ก ์ํํธ์จ์ด๋ฅผ ๋ถ์ํ๊ณ ์ค๊ณ๋ฅผ ํ๊ฒ ๋๋ค. ์ํํธ์จ์ด๋ฅผ ์ค๊ณ ๋ฅผ ํ ๋ ์ฒ์๋ถํฐ ์์ธํ ์ฌํญ๊น์ง ๊ณ ๋ คํ๊ฒ ๋๋ฉด ๋ฌธ์ ์ ํต์ฌ์ ๋ํด ์ง์คํ ์๊ฐ ์๋ค. ๋ฐ๋ผ์ ๊ฐ์ฅ ๋จผ์ ์ ํ๋์ด์ผ ํ๋ ๊ฒ์ ์ถ์ํ(abstraction)์ด๋ค. ์ถ์ํ๋ฅผ ํตํด ๋ถํ์ํ ํ์ ์์ค์ ์ธ๋ถ์ฌํญ์ ๋ํ ๊ณ ๋ ค ์์ด ์ ์ ํ ์์ค์์ ๋ฌธ์ ์ ๋ํด ์ง์คํ ์ ์๋ค. ์ถ ์ํํ์ฌ ๋ชจ๋ธ์ ์ ๋ฆฝํ์์ผ๋ฉด ๊ทธ๊ฒ์ ์ ์ง์ ์ผ๋ก ์ธ๋ถํํ์ฌ ๊ตฌ์ฒดํํ๊ฒ ๋๋๋ฐ, ์ด ๋ ํฌ ๊ฒ ํํฅ์, ์ํฅ์, ๊ฐ์ฒด์งํฅ ์ ๊ทผ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค. ์ด ์ค ๊ฐ์ฒด์งํฅ ์ ๊ทผ ๋ฐฉ๋ฒ์ ์ํฅ ์์ ๊ฐ๊น์ด ๋ฐฉ๋ฒ์ผ๋ก ์์คํ ์์ ๊ฐ์ฒด๋ค์ ํ๋ณด๋ฅผ ์ฐพ์ ์ด๋ค ๊ฐ์ ์ํธ์์ฉ์ ํตํด ์์คํ ์ด ๋์ํ๋๋ก ์ค๊ณ๋ฅผ ํ๋ ๋ฐฉ๋ฒ์ด๋ค.
์ํํธ์จ์ด ์ค๊ณ โ ๊ณ์ ์ ์ฒด ๋ฌธ์ ์ ์์ ์ผ๋ถ๋ถ์ ๋ชจ๋(module)์ด๋ผ ํ๋ค. ๋ชจ๋ ์ ๋ณด ์๋(information hiding): ๋ชจ๋์ ๊ทธ๊ฒ์ ๋ณต์กํ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ์๋ ์ธ๋ถ๋ก๋ถํฐ ์จ๊ธด๋ค. ๋ณต์ก์ฑ์ ์ค์ด๊ธฐ ์ํ ๋ชฉ์ ๋ชจ๋์ ๊ทธ๊ฒ์ ์ธํฐํ์ด์ค๋ฅผ ํตํด์๋ง ๋ค๋ฅธ ๋ชจ๋๊ณผ ์ํธ์์ฉํ๋ค. ๋ชจ๋์ ์๊ตฌ์ฌํญ ๋์จํ ๊ฒฐํฉ์ฑ(loosely-coupled): ๋ชจ๋์ ์ํธ ๋ ๋ฆฝ์ ์ด์ด์ผ ๊ฒฐํฉ์ฑ ํ๋ค. ํ ๋ชจ๋์ ๋ณ๊ฒฝ์ด๋ ์ค๋ฅ๊ฐ ๋ค๋ฅธ ๋ชจ๋์ ์ํฅ์ ์ฃผ์ง ์์์ผ ํ๋ค. ๋์ ์์ง์ฑ(highly-cohesive): ์ ์ ์๋ ๋จ์ผ ์์ ๋งํด์ผ ํ๋ค. ์์ง์ฑ
ํํฅ์ ์ ๊ทผ ๋ฐฉ๋ฒ์์๋ ์ ์ฒด ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋๊ณ , ์์ ๋ฌธ์ ๋ฅผ ๋ค์ ๊ทธ๋ณด๋ค ์์ ๋ฌธ์ ๋ก ๋๋๋ ๊ณผ์ ์ ๋ฐ๋ณตํ๊ฒ ๋๋ค. ์ด๋ ๊ฒ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋๋์ด ํด๊ฒฐํ๊ณ ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ถํ ์ ๋ณต ๋ฐฉ๋ฒ์ด๋ผ ํ๋ค. ๋ถํ ์ ๋ณต์ ํตํด ์ป์ด์ง๊ฒ ๋๋ ์ ์ฒด ๋ฌธ์ ์ ์์ ์ผ๋ถ๋ถ ์ ๋ชจ๋(module)์ด๋ผ ํ๋ค. ๋ชจ๋์ ๊ฐ์ฅ ํฐ ํน์ง์ ์ ๋ณด ์๋์ด๋ค. ์ฆ, ์ธ๋ถ๋ก๋ถํฐ ๊ทธ๊ฒ์ ๋ด๋ถ์ ์์ธํ ๋ด์ฉ ๋๋ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ์จ๊ธฐ๋ ๊ฒ์ด๋ค. ๋ชจ๋์ ์ค์ง ๊ทธ๊ฒ์ ์ธํฐํ์ด์ค๋ฅผ ํต
- 5 -
ํด์๋ง ์ดํด๋๋ฉด ๋๋ค. ์ด๊ฒ์ ๋ณต์ก์ฑ์ ์ค์ด๊ธฐ ์ํจ์ด๋ค. ๋ชจ๋์ ๊ฒฐํฉ์ฑ์ด ๋์จํ ์๋ก, ์ ์ง์ฑ์ด ๋์์๋ก ๋ฐ๋์งํ๋ค. ๊ฒฐํฉ์ฑ์ด ๋์จํ๋ค๋ ๊ฒ์ ๋ชจ๋ ๊ฐ์ ์์กด์ฑ์ด ์ ๋ค๋ ๊ฒ์ ๋งํ๋ค. ์ฆ, ๋ค๋ฅธ ๋ชจ๋์ ๋ณ๊ฒฝ์ ์ํฅ์ ๋ฐ์ง ์๋๋ค๋ ๊ฒ์ ๋งํ๋ค. ์์ง์ฑ์ด ๋๋ค๋ ๊ฒ์ ์ ์ ์๋ ๋จ์ผ ์์ ๋ง์ ํ๋ค๋ ๊ฒ์ ๋งํ๋ค. ํ ๋ชจ๋์์ ์ฌ๋ฌ ์์ ์ ํ ๊ฒฝ์ฐ์๋ ํน์ ์์ ์ ์ค๋ฅ๊ฐ ๋ค๋ฅธ ์์ ์ ์ํฅ์ ์ค ํ๋ฅ ์ด ๋๋ค.
์ํํธ์จ์ด ์ค๊ณ โ ๊ณ์ ๊ฐ ๋ชจ๋์ ์ค๊ณํ ๋ ์ค์ํ ๊ณ ๋ ค์ฌํญ ๋ชจ๋ ๊ฐ์ ๋ฐ์ดํฐ ํ๋ฆ(data flow) ํ๋ฆ ์ํํธ์จ์ด ๋ด์์ ๋ฐ์ดํฐ ํ๋ฆ์ ๋ช ํํ๊ฒ ํ๊ธฐ ์ํด์๋ ๊ฐ ๋ชจ๋๋ง๋ค ๋ค์์ด ๊ณ ๋ ค๋์ด์ผ ํ๋ค. (input input) ๋ชจ๋์ ์คํํ๊ธฐ ์ ์ ์ ๊ณต๋ ์ ์๋ ๋ฐ์ดํฐ๋? (assumption assumption) ๋ชจ๋์ด ์ด๋ค ๊ฒ์ ๊ฐ์ ํ๊ณ ์๋๊ฐ? (output output) ๋ชจ๋์ ํ๋์ ๋ฐ๋ผ ๋ชจ๋์ด ์คํ๋ ํ์ ๋ฐ์ดํฐ์ ๋ชจ์ต์? ํ์ ์ค๋ช ํ๋ ์ฌ์ /์ฌํ์กฐ๊ฑด๊ณผ ์ฐ๊ด๋๋ฉฐ, ํ ํ๋ก์ ํธ์์๋ ๋งค์ฐ ์ค์ํ ํต์ ์๋จ์ด ๋๋ค. ๋น๊ณ . ๋น๊ณ . ์ด๋ฐ ํ๋ฆ์ ๋ชจ๋์ ๋ด๋ถ์ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ๊ณผ๋ ๋ฌด๊ดํ๋ค.
๊ฐ ๋ชจ๋์ ์ค๊ณํ ๋ ์ค์ํ๊ฒ ๊ณ ๋ ค๋์ด์ผ ํ๋ ์ฌํญ ์ค ํ๋๋ ๋ชจ๋ ๊ฐ์ ๋ฐ์ดํฐ ํ๋ฆ์ด ๋ค. ์ด๋ฅผ ์ํด ์ค๊ณ ๊ณผ์ ์์ ๋ชจ๋ ๊ฐ์ ๋ฐ์ดํฐ์ ํ๋ฆ๋๋ฅผ ์์ฑํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ๊ฐ ๋ชจ๋ ์ธก๋ฉด์์ ๋ฐ์ดํฐ์ ํ๋ฆ์ ํฌ๊ฒ ์ธ ๊ฐ์ง ์ธก๋ฉด์์ ๊ณ ๋ ค๋๋ค. ์ฒซ์งธ, ๋ชจ๋์ ์คํํ๊ธฐ ์ ์ ๋ชจ๋์ ์ ๊ณต๋๋ ๋๋ ์ ๊ณต๋ ์ ์๋ ๋ฐ์ดํฐ๊ฐ ๋ฌด์์ธ์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ๋์งธ, ๋ชจ๋์์ ์ฌ์ฉํด์ผ ํ๋ ๊ฐ์ ์ ๊ฒฐ์ ํด์ผ ํ๋ค. ์ ์งธ, ๋ชจ๋์ ํ๋๊ณผ ์ ๋ ฅ ๋ฐ์ดํฐ์ ๋ฐ๋ผ ๋ชจ๋์ด ์ค ํ๋ ํ์ ๋ฐ์ดํฐ์ ๋ชจ์ต์ด ์ด๋ป๊ฒ ๋์ด์ผ ํ๋์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ์ด๋ฐ ๋ฐ์ดํฐ์ ํ๋ฆ์ ํ ์ ์ค๋ช ํ๋ ๋ฉ์๋์ ์ฌ์ , ์ฌํ์กฐ๊ฑด๊ณผ ๋ฐ์ ํ๊ฒ ์ฐ๊ด๋์ด ์๋ค. ๋ฐ์ดํฐ์ ํ๋ฆ์ ๋ช ํํ ๊ฒ ํ๋ ๊ฒ์ ํ ํ๋ก์ ํธ์์ ๋ชจ๋์ ๊ฐ๋ฐํ๋ ํ์ ๊ฐ์ ์ค์ํ ํต์ ์๋จ์ด ๋๋ค. ์ฌ๊ธฐ ์ ๋ค์ ํ๋ฒ ๊ฐ์กฐํด์ผ ํ๋ ๊ฒ์ ๋ฐ์ดํฐ์ ํ๋ฆ์ ๋ชจ๋์ ๋ด๋ถ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ ๋ฒ๊ณผ ๋ฌด๊ดํ๋ค๋ ๊ฒ์ด๋ค. ์ฆ, ์ผ๋ จ์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํด์ผ ํ๋ ๋ชจ๋์ด ์ด๋ค ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋์ง๋ ๊ทธ๊ฒ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ๊ณผ ๋ฌด๊ดํ๋ค๋ ๊ฒ์ด๋ค.
- 6 -
๊ฐ์ฒด์งํฅ ์ค๊ณ์ ๊ตฌ์กฐํ๋ ์ค๊ณ์ ์ฐจ์ด์ ๊ฐ์ฒด์งํฅ ์ค๊ณ(object-oriented design)๋ ๋ฌธ์ ์์ ๊ฐ์ฒด๋ฅผ ์๋ณํ๊ณ , ์ค๊ณ ์ด ๊ฐ์ฒด๋ค์ ์ด์ฉํ์ฌ ๋ชจ๋ธ๋งํ๋ค. (๋ช ์ฌ) ๋ฐ์ดํฐ ์ค์ฌ ์ค์ธ๊ณ์ ๊ฐ๊น๊ฒ ๋ชจ๋ธ๋งํ ์ ์์ ๊ตฌ์กฐํ๋ ์ค๊ณ(structured design)๋ ๋ฌธ์ ์์ ํ์๋ฅผ ์๋ณํ์ฌ ์ค๊ณ ํ์ ์์ฃผ๋ก ๋ชจ๋ธ๋งํ๋ค. (๋์ฌ) ์๊ณ ๋ฆฌ์ฆ ์ค์ฌ
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ธ๊ฐ์ง ํต์ฌ ์์ 1. ์บก์ํ(encapsulation): ๋ฐ์ดํฐ์ ํ์์ ๊ฒฐํฉ 2. ์์(inheritance): ์ฝ๋์ ์ฌ์ฌ์ฉ 3. ๋คํ์ฑ(polymorphism): ์คํ์๊ฐ์ ๊ฐ์ฒด์ ์ํด ํ์๊ฐ ๊ฒฐ์ ๋จ
ํ์ฌ ๋๋ถ๋ถ์ ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ง์ํ๋ค. ๊ฐ์ฒด์งํฅ ์ค๊ณ๋ ๊ธฐ์กด ๊ตฌ์กฐํ๋ ์ค๊ณ์ ๋นํด ์ค์ธ๊ณ๋ฅผ ๋ณด๋ค ๊ฐ๊น๊ฒ ๋ชจ๋ธ๋งํ ์ ์๋ค. ๊ฐ์ฒด์งํฅ ์ค๊ณ์ ํต์ฌ ์ ์ฃผ์ด์ง ๋ฌธ์ ์์ ๊ฐ์ฒด๋ฅผ ์๋ณํ๋ ๊ฒ์ด๋ค. ์ด๋ฐ ๊ฐ์ฒด๋ค์ ๋ฌธ์ ๋ฅผ ์ค๋ช ํ๋ ๋ฌธ์ฅ์์ ๋ช ์ฌ์ ํด๋น๋๋ค. ๋ฐ๋ฉด์ ๊ตฌ์กฐํ๋ ์ค๊ณ๋ ๋ฌธ์ ์์ ํ์๋ฅผ ์๋ณํ๋ ๊ฒ์ด ํต์ฌ์ด๋ค. ์ฆ, ๋ฌธ์ ๋ฅผ ์ค๋ช ํ๋ ๋ฌธ์ฅ์์ ํ์๋ ๋์ฌ์ ํด๋น๋๋ค. ์ด๋ฐ ์ธก๋ฉด์์ ๊ฐ์ฒด์งํฅ ์ค๊ณ๋ ๋ฐ์ดํฐ ์ค ์ฌ์ด๋ผ ํ๊ณ , ๊ตฌ์กฐํ๋ ์ค๊ณ๋ ์๊ณ ๋ฆฌ์ฆ ์ค์ฌ์ด๋ผ ํ๋ค.
๊ฐ์ฒด์งํฅ ์ค๊ณ ํด๋์ค ๋ฐ๊ฒฌ ๋ฌธ์ ์ ์์์ ๋ช ์ฌ์ ๋์ฌ๋ฅผ ์ฐพ๋๋ค. ๋ช ์ฌ๋ ๊ฐ์ฒด๋ก ๋์ฌ๋ ๊ฐ์ฒด์ ํ์๋ก ๋ณดํต ๋ชจ๋ธ๋ง๋๋ค. ๋ณดํต ์ฃผ์ ํด๋์ค๋ฅผ ๋ฐ๊ฒฌํ๋ ๊ฒ์ ์ด๋ ต์ง ์๋ค. ๊ฐ๋ฅํ๋ฉด ํด๋์ค๋ฅผ ์์ ๊ณ์ธต๊ตฌ์กฐ๋ก ์กฐ์งํํ๋ค. ๊ฐ ํด๋์ค๊ฐ ์ค์ง ํ๋์ ์ฃผ์ ์ฑ ์๋ง์ ๊ฐ์ง๋๋ก ํ๋ค. ์ถ์ํ๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ์ ์์ธํ ์ธ๋ถ์ฌํญ์ ๊ณ ๋ คํ์ง ์๋๋ค. ์ฌ๋ฌ ์ฌ๋๋ค๊ณผ ๋ธ๋ ์ธ์คํ ๋ฐ(brainstorming)์ ํ๋ค. ์ฌ๋ฌ ์๋๋ฆฌ์ค๋ฅผ ์๊ฐํด๋ณธ๋ค.
์ด๋ฏธ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ๊ฐ์ฒด์งํฅ ์ค๊ณ์ ํต์ฌ์ ๊ฐ์ฒด๋ฅผ ์๋ณํ๋ ๊ฒ์ด๋ค. ํด๋์ค๋ ๊ฐ์ ์ข ๋ฅ์ ๊ฐ์ฒด๋ฅผ ์ค๋ช ํ๋ ํ์ด๋ค. ๋ฐ๋ผ์ ๋ฌธ์ ์์ ๊ฐ์ฒด๋ฅผ ์๋ณํ๋ค๋ ๊ฒ์ ๋ฌธ์ ์์ ํด๋์ค๋ฅผ ๋ฐ๊ฒฌํ๋ค๋ ๊ฒ๊ณผ ๊ฐ์ ์๋ฏธ์ด๋ค. ํด๋์ค๋ ๋ฌธ์ ๋ฅผ ๊ตฌ์ฑํ๋ ๋ชจ๋๋ก ๋ณผ ์ ์์ผ๋ฏ๋ก ์์ ์ค ๋ช ํ ๋ชจ๋์ด ๊ฐ์ถ์ด์ผ ํ๋ ์กฐ๊ฑด์ ํด๋์ค๋ ๊ฐ์ถ์ด์ผ ํ๋ค. ์ฆ, ํ ํด๋์ค๋ ๋ค๋ฅธ ํด๋์ค ์ ๋ ๋ฆฝ์ ์ด์ด์ผ ํ๋ฉฐ, ํ ํด๋์ค๋ ์ค์ง ํ๋์ ์ฃผ์ ์ฑ ์๋ง ๊ฐ์ ธ์ผ ํ๋ค.
- 7 -
๊ฐ์ฒด์งํฅ ์ค๊ณ ์) ๋ฌธ์ ์ ์ ์: ์ฃผ์๋ก ์ฑ ์์ฑ ์ ์ฌ์ ๊ฐ์ฒด ๊ฒ์ฅ ํญ ํ์ด์ง ์ด๋ฆ ์ง์ ํ๋ฒํธ ์ ํ๋ฒํธ ํ์ฌ์ ํ๋ฒํธ ํฉ์ค๋ฒํธ ํด๋์ ํ๋ฒํธ
์๋ ์์ผ ์ฃผ์ ์ง์ฃผ์ ํ์ฌ์ฃผ์ ์ฌ์ฉ์ ์๊ตฌ์ฌํญ ํ์ฌ์ด๋ฆ - ํ์์๋ค๊ณ ํ๋จ ๋ฌ๋ ฅ ์์ ์ ์ ๋ณด ์ฌ์ฉ์ ร ์ฌ์ฉ์ ์ธํฐํ์ด์ค
์ด๋ค ์ฃผ์ด์ง ๋ฌธ์ ์์ ๊ฐ์ฒด๋ฅผ ์๋ณํ๋ ๊ณผ์ ์ ์๋ฅผ ํตํด ์ค๋ช ํ๊ณ ์ ํ๋ค. ์ฃผ์ด์ง ๋ฌธ์ ๋ ์ฃผ์๋ก ์ฑ ์์ฑ์ด๋ค. ์ฐ์ ์ค์ธ๊ณ์์ ์ฌ์ฉํ๋ ์ฃผ์๋ก์ ๊ด์ฐฐํ๊ณ ๊ฒฝํ์ ๋ฐํ์ผ๋ก ์๊ฐ๋ ๋ ์ ์ฌ์ ๊ฐ์ฒด๋ค์ ๋ชจ๋ ๋์ดํ๋ค. ๊ทธ ๋ค์ ๋์ด๋ ๊ฒ๋ค์์ ์ํํธ์จ์ด๋ก ๊ตฌํํ์์ ๋ ํ์ํ์ง ์๋ ๊ฒ, ํตํฉ๋์ด์ผ ํ๋ ๊ฒ, ์์ ๊ฐ๋ ์ ๋์ ํ ์ ์๋ ๊ฒ์ด ์๋์ง ์ดํด๋ณธ๋ค. ์๋ฅผ ๋ค์ด, ์ค์ธ๊ณ์ ์ฃผ์๋ก์ ์ฌ๋ฌ ํ์ด์ง๋ก ๊ตฌ์ฑ๋์ด ์๋๋ฐ ์ํํธ์จ์ด ์ธก๋ฉด์์๋ ํ์ด ์ง๋ผ๋ ๊ฐ๋ ์ ํ์ ์๊ณ , ํ์ด์ง๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ ์ฌ๋์ ์ฃผ์ ์ ๋ณด๋ฅผ ์ ์งํ๋ ํญ(entry)์ด ํ์ํ๋ค. ๋ ์ง์ ํ๋ฒํธ, ํ์ฌ์ ํ๋ฒํธ, ํฉ์ค๋ฒํธ ๋ฑ์ ๋ณดํต ๋ชจ๋ ๋ค๋ฅธ ๊ฐ์ฒด๋ก ํํํ์ง ์ ์ ๊ฒ์ด๋ค. ์ด๋ค์ ์ ํ๋ฒํธ๋ผ๋ ํ๋์ ํด๋์ค๋ก ๋ณดํต ๋ํ๋ผ ๊ฒ์ด๋ค. ์ด๋ฐ ๊ณผ์ ์ ๊ฑฐ์น ๋ค์์๋ ๊ฐ ๊ฐ์ฒด๋ง๋ค CRC(Class, Responsibility, Collaboration) ์นด๋๋ฅผ ์์ฑํ์ฌ, ๊ฐ ๊ฐ์ฒด ์ ์ฑ ์๊ณผ ๋ค๋ฅธ ๊ฐ์ฒด์ ์ด๋ค ์ํธ์์ฉ์ ํ๋์ง ๋ถ์ํ๋ค.
๊ฐ์ฒด์งํฅ ์ค๊ณ ์) ๊ณ์ ๊ฐ ๊ฐ์ฒด๋ง๋ค CRC(Class, Responsibility, Collaboration) ์นด๋๋ฅผ ์์ฑ ํด๋์ค ์ด๋ฆ: entry
๋ถ๋ชจ ํด๋์ค:
์์ ํด๋์ค:
์ฃผ์ ์ฑ ์: ์ฃผ์๋ก ํ ํญ์ ๋ํ ์ ๋ณด๋ฅผ ๊ด๋ฆฌํ๋ค. ์ฑ ์
ํ๋
์ ์ฒด ์ด๋ฆ์ ํ๋์ ๋ฌธ์์ด๋ก ์ ๊ณต
name ํด๋์ค๋ก๋ถํฐ ์ฑ์ name ํด๋์ค๋ก๋ถํฐ ์ด๋ฆ์
์ฃผ์ ์ ๊ณต
์์
- 8 -
๊ฐ์ฒด์งํฅ ์ค๊ณ ์) ๊ณ์ ์๋๋ฆฌ์ค ๊ฒํ ์ฌ์ฉ์๊ฐ ์ฃผ์๋ก์์ ์ฃผ์๋ฅผ ์ฐพ๊ณ ์ถ๋ค. ์ฌ์ฉ์ ์ธํฐํ์ด์ค๋ ์ฌ์ฉ์๋ก๋ถํฐ ์ด๋ฆ์ ์ ๋ ฅ๋ฐ์์ผ ํ๋ค. ์ด๋์ ์ฐพ๋? ร ์ฃผ์๋ก ์ ์ฒด๋ฅผ ๋ํ๋ด๋ ๊ฐ์ฒด๊ฐ ํ์ํจ ๋น๊ต๋ฅผ ํด์ผ ํ๋ค. ์ด๋์? ร ์ฃผ์๋ก or ํญ ํญ์์ ์ด๋ฆ์ ๋ฐ์ ์ฌ์ฉ์๊ฐ ์ ๋ ฅํ ์ด๋ฆ๊ณผ ๋น๊ตํ๋ค. ์ผ์นํ๋ ๊ฒ์ ์ฐพ์ผ๋ฉด ๊ทธ ํญ์ผ๋ก๋ถํฐ ์ฃผ์๋ฅผ ์ ๋ฌ๋ฐ๋๋ค. ๋ค๋ฅธ ์๋๋ฆฌ์ค ๊ฒํ ์ ํญ์ ์ถ๊ฐ, ๊ธฐ์กด ํญ์ ์ญ์ ๋ฑ
๋ชจ๋ ๊ฐ์ฒด์ ๋ํด CRC ์นด๋๋ฅผ ์์ฑํ์์ผ๋ฉด ๋ฐ์ ๊ฐ๋ฅํ ์ฌ๋ฌ ์๋๋ฆฌ์ค๋ฅผ ๊ฒํ ํ์ฌ ์์ฑ ๋ ๋ด์ฉ์ ๋น ์ง ๊ฒ์ ์๋์ง, ์๋ชป๋ ๊ฒ์ ์๋์ง ๊ฒํ ํ๋ค. ์๋๋ฆฌ์ค๋ฅผ ๊ฒํ ํ๋ ๋์ค์ ๋ฏธ์ฒ ์๊ฐํ์ง ๋ชปํ๋ ์ ํด๋์ค๋ฅผ ๋ฐ๊ฒฌํ ์ ์๋ค. ์ค๊ณ๊ฐ ๋๋๋ฉด ๊ตฌํ์ ์์ํ ์ ์๋ค. ์ํํธ์จ์ด ๊ตฌํ์ด ์๋ฃ๋๊ฑฐ๋ ์๋๋ฉด ๊ฐ๋ฐํ๋ ๋ ์ค์ ์ํํธ์จ์ด์ ์ ํ์ฑ์ ํ์ธํ๊ธฐ ์ํ ์ฌ๋ฌ ๊ฐ์ง ์ํ์ ํ ์ ์๋ค.
์ํํธ์จ์ด์ ์ ํ์ฑ ๊ฒ์ฆ ํ ์คํ (testing): ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ๊ธฐ ์ํด ์ค๊ณ๋ ๋ฐ์ดํฐ ์งํฉ์ ์ด์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ ์คํํ๋ ๊ณผ์ ๋๋ฒ๊น (debugging): ๋ฐ๊ฒฌ๋ ์ค๋ฅ๋ฅผ ์ ๊ฑฐํ๋ ๊ณผ์ ์น์ธ ์ํ(acceptance test): ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํ์ฌ ์ค์ ํ๊ฒฝ์์ ์์คํ ์ ํ ์คํธํ๋ ๊ณผ์ ์ค๋ฅ๋ ์ํํธ์จ์ด ๊ฐ๋ฐ ๋จ๊ณ์์ ์ผ์ฐ ๋ฐ๊ฒฌํ ์๋ก ์์ ๋น์ฉ์ด ์ ๋ ดํ๋ค. ๋ช ์ธ์ ๋๋ ์ค๊ณ ์ค๋ฅ๊ฐ ๊ฐ์ฅ ์น๋ช ์ ์ด๋ค.
ํ ์คํ ์ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ๊ธฐ ์ํด ์ค๊ณ๋ ๋ฐ์ดํฐ ์งํฉ์ ์ด์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ ์คํํ๋ ๊ณผ์ ์ ๋งํ๋ฉฐ, ๋๋ฒ๊น ์ ํ ์คํ ์ ํตํด ๋ฐ๊ฒฌ๋ ์ค๋ฅ๋ฅผ ์ ๊ฑฐํ๋ ๊ณผ์ ์ ๋งํ๋ค. ์์ฉ ์ํํธ์จ ์ด์ ๊ฒฝ์ฐ์๋ ์ถ์ํ๊ธฐ ์ ์ ์น์ธ ์ํ์ ๊ฑฐ์น๊ฒ ๋๋๋ฐ ์ด๊ฒ์ ์ค์ ์ํํธ์จ์ด๊ฐ ์ด์ฉ๋ ํ๊ฒฝ์์ ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํ์ฌ ํ ์คํธํ๋ ๊ณผ์ ์ ๋งํ๋ค. ์ค๋ฅ๋ ๊ฐ๋ฐ ๋จ๊ณ์์ ์ผ์ฐ ๋ฐ๊ฒฌํ ์๋ก ์์ ๋น์ฉ์ด ์ ๋ ดํ๋ค. ์ด๋ฐ ์ธก๋ฉด์์ ๋ช ์ธ์ ๋๋ ์ค๊ณ ์ค๋ฅ๊ฐ ๊ฐ์ฅ ์น๋ช ์ ์ด ๋ค.
- 9 -
๊ตฌํ ์ค๋ฅ ์ปดํ์ผ ์๊ฐ ์ค๋ฅ(compile-time error): ๋ฌธ๋ฒ ์ค๋ฅ ์คํ ์๊ฐ ์ค๋ฅ(run-time error) ์ ๋ชป๋ ๊ฐ์ : result = dividend / divisor ์ฌ์ฉ์ ์ ๋ ฅ ์ค๋ฅ ๋ ผ๋ฆฌ ์ค๋ฅ ์ค๋ฅ๊ฐ ๋ฐ์ํ์์ ๋ ๊ทธ๊ฒ์ ๊ทน๋ณตํ ์ ์๋ ๋ฅ๋ ฅ์ ๊ฐ๊ฑด์ฑ (robustness)์ด๋ผ ํ๋ค. ์์ธ ์ฒ๋ฆฌ(exception handling) ์ค๊ณ๋ถํฐ ์ด๋ค ๊ฐ๋ฅํ ์์ธ ์ํฉ์ด ๋ฐ์ํ ์ ์๋์ง ๊ณ ๋ คํด์ผ ํจ what, where, how
๊ตฌํ ์ค๋ฅ๋ ํฌ๊ฒ ์ปดํ์ผ ์๊ฐ ์ค๋ฅ์ ์คํ ์๊ฐ ์ค๋ฅ๋ก ๋๋ ์ ์๋ค. ์ปดํ์ผ ์๊ฐ ์ค๋ฅ๋ ๋ค๋ฅธ ๋ง๋ก ๋ฌธ๋ฒ ์ค๋ฅ๋ผ ํ๋ฉฐ, ์ด๊ฒ์ ๋ณดํต ์ฝ๊ฒ ์ ์ ํ ์ ์๋ค. ๋ฌธ๋ฒ์ ์ธ ์ค๋ฅ๊ฐ ์์ง๋ง ์คํํ์์ ๋ ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ์ป์ง ๋ชปํ๊ฑฐ๋ ํ๋ก๊ทธ๋จ์ด ์คํ ๋์ค์ ์๋ํ์ง ์๊ฒ ์ค๋จ๋ ๋ ๊ฒฝ์ฐ ๋ฑ์ ์คํ ์๊ฐ ์ค๋ฅ๋ผ ํ๋ค. ํนํ ์ด ์ค์ ๋ ผ๋ฆฌ์ ์ผ๋ก ์์ฑ์ ์๋ชปํ์ฌ ๋ฐ์๋ ์ค ๋ฅ๋ ๊ทธ๊ฒ์ ๊ทน๋ณตํ๊ธฐ๊ฐ ์ด๋ ต๋ค.
์ ํ์ฑ์ ์ํ ์ค๊ณ ์ฌ์ ์กฐ๊ฑด(precondition): ์ฌํ์กฐ๊ฑด์ด ๋ณด์ฅ๋๊ธฐ ์ํด ๋ฉ์๋์ ์ฌ์ ์กฐ๊ฑด ์ง์ ํ๊ธฐ ์ ์ ๋ฐ๋์ ๋ง์กฑํด์ผ ํ๋ ๊ฐ์ ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ์ฌ์ฉ์์ ์ฑ ์ ์ฌ์ ์กฐ๊ฑด์ด ์๋ฐฐ๋ ๊ฒฝ์ฐ์๋ ์ด๋ป๊ฒ? ๋ฐฉ๋ฒ1. ๋ฐฉ๋ฒ1. ์์ธ ์ฒ๋ฆฌ ๋ฐฉ๋ฒ2. ๋ฐฉ๋ฒ2. ์๋ฌด๊ฒ๋ ํ์ง ์๋๋ค. ์ฌํ์กฐ๊ฑด(postcondition): ์ฌ์ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋์์ ๋, ์ฌํ์กฐ๊ฑด ๊ธฐ๋๋๋ ๋ฉ์๋์ ์คํ ๊ฒฐ๊ณผ ์ด๋ป๊ฒ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ป๋์ง๋ ์ค์ํ์ง ์์ ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ ๊ฐ๋ฐ์์ ์ฑ ์ ์ฌ์ , ์ฌํ์กฐ๊ฑด์ ๋ํ ์ฌ๋ฐ๋ฅธ ์ดํด๊ฐ ์์ผ๋ฉด ์ฌ๋ฌ ๊ฐ์ง ๋ ผ๋ฆฌ ์ค๋ฅ๋ฅผ ๋ฒํ ์ ์๋ค.
์ค๋ฅ๋ ํญ์ ๋ฐ์ํ ์ ์๋ค. ์ค๋ฅ๊ฐ ๋ฐ์ํ์์ ๋ ๊ทธ ์ค๋ฅ๋ฅผ ์ฐพ์ ์์ ํ๋ ๊ฒ๋ ์ค์ํ ์ง๋ง ์ฒ์๋ถํฐ ์ค๋ฅ๊ฐ ๋ฐ์ํ์ง ์๋๋ก ๊ตฌํํ๋ ๊ฒ๋ ์ค์ํ๋ค. ์ ํํ ์ํํธ์จ์ด๋ฅผ ์ค๊ณ ํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๊ธฐ๋ฒ์ ๊ฐ ํจ์ ๋๋ ๋ฉ์๋์ ์ฌ์ ์กฐ๊ฑด๊ณผ ์ฌํ์กฐ๊ฑด์ ๋ช ๋ฐฑํ๊ฒ ์ ์ํ๋ ๊ฒ์ด๋ค. ์์น์ ์ผ๋ก ์ฌ์ ์กฐ๊ฑด์ ๊ทธ๊ฒ์ ํธ์ถํ๋ ์ธก์ ์ฑ ์์ด๋ค. ์ด ์กฐ ๊ฑด์ด ์ถฉ์กฑ๋์ง ์์ผ๋ฉด ๋ฉ์๋๋ ์ฌํ์กฐ๊ฑด์ ๋ณด์ฅํด์ค ์ฑ ์์ด ์๋ค. ๊ทธ๋ฌ๋ ๋ณดํต ๋ฉ์๋๋ฅผ ๊ตฌํํ๋ ์ธก์์๋ ์ฌ์ ์กฐ๊ฑด์ ๊ฒ์ฌํ์ฌ ๊ทธ๊ฒ์ด ์ถฉ์กฑ๋์ง ์์ผ๋ฉด ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ๊ฑฐ๋ ์๋ฌด ๊ฒ๋ ํ์ง ์๋๋ค.
- 10 -
์ ํ์ฑ์ ์ํ ์ค๊ณ โ ๊ณ์ ์ฌํ์กฐ๊ฑด์ ์ข ๋ฅ ์ข ๋ฅ 1. ๋ฐํ ๊ฐ์ ์ ํ์ฑ ์ข ๋ฅ 2. ๊ฐ์ฒด์ ์ํ ์ฌ์ , ์ฌํ์กฐ๊ฑด์ ์) void RemoveLast() ํจ๊ณผ: ๋ฆฌ์คํธ์ ์๋ ๋ง์ง๋ง ์์๋ฅผ ์ ๊ฑฐํ๋ค. ์ฌ์ ์กฐ๊ฑด: ๋ฆฌ์คํธ๊ฐ ๋น์ด์์ง ์์์ผ ํ๋ค. ์ฌํ์กฐ๊ฑด: ๋ฆฌ์คํธ์ ์๋ ๋ง์ง๋ง ์์๊ฐ ์ ๊ฑฐ๋์ด ์๋ค. WARNING If you try to execute this operation when the preconditions are not true, the results are not guaranteed
Deskchecking โ Design ๊ฐ ํด๋์ค์ ๊ธฐ๋ฅ๊ณผ ๋ชฉ์ ์ด ๋ช ํํ๊ฐ? ํฐ ํด๋์ค๋ฅผ ์ธ๋ถํํ ์ ์๋๊ฐ? ๊ณตํต๋ ์ฝ๋๋ฅผ ๊ณต์ ํ๋ ํด๋์ค๋ค์ด ์๋๊ฐ? ์์ผ๋ฉด ์ด๋ค์ ์์ ๊ณ์ธต๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ๋ํ๋ผ ์ ์๋๊ฐ? ๋ชจ๋ ๊ฐ์ ์ด ํฉ๋นํ๋ฉฐ, ๋ฌธ์์ ์ ๋ํ๋ ์๋๊ฐ? ๋ชจ๋ ์ฌ์ /์ฌํ์กฐ๊ฑด์ด ์ ๋นํ๊ฐ? ๋ช ์ธ์์ ๋น์ถ์ด ๋ดค์ ๋ ์ค๊ณ๊ฐ ์์ ํ๊ณ ์ ํํ๊ฐ?
๋ณดํต ํ ์คํ ์ด๋ ๋๋ฒ๊น ์ ๋๋ฒ๊ฑฐ์ ๊ฐ์ ์์คํ ์ํํธ์จ์ด๋ฅผ ์ด์ฉํ์ฌ ์ํํ๊ฒ ๋๋ฉฐ, ์ผ ๋ฐ์ ์ผ๋ก ํ๋ก๊ทธ๋จ์ ์คํํ๋ฉด์ ๊ฒ์ฌ๋ฅผ ํ๋ค. ๋ฐ๋ฉด์ desk checking์ด๋ ์ค๊ณ์๋ ํ๋ก๊ทธ ๋จ ์ฝ๋๋ฅผ ์ถ๋ ฅํ์ฌ ์ฑ ์ ์์ ์ฌ์ฉ์๊ฐ ์ง์ ๊ฒํ ํ๋ ํ์๋ฅผ ๋งํ๋ค. ์ด๋ฐ ๊ฒํ ๋ ์ค๊ณ์ ๊ดํ ๊ฒ์ผ ์ ์๊ณ ๊ตฌํ์ ๊ดํ ๊ฒ์ผ ์ ์๋ค.
- 11 -
Deskchecking โ Coding ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๊ธฐ๋ฅ์ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๊ณ ์๋๊ฐ? ์ค๊ณ์ ๋ํ๋ ์ธํฐํ์ด์ค์ ์ผ๊ด์ฑ ์๊ฒ ๋ฉ์๋๋ค์ด ๊ตฌํ๋์๋๊ฐ? ๋ฉ์๋ ํธ์ถ์ ์ค์ ์ธ์์ ๋ฉ์๋ ์ ์์ ์ ์ธ๋ ํ๋ผ๋ฏธํฐ๊ฐ ์ผ์นํ๋๊ฐ? ๊ฐ ๋ฐ์ดํฐ ๊ฐ๋ค์ ์ด๊ธฐํ๊ฐ ์ ๋๋ก ๋์ด ์๋๊ฐ? ๋ชจ๋ ๋ฃจํ๊ฐ ์ข ๋ฃํ๋๊ฐ? ๋งค์ง ๊ฐ๋ค์ ์๋๊ฐ? (๋งค์ง ๊ฐ์ ๊ฐ ์์ฒด๋ฅผ ๋ณด๋ฉด ๊ทธ ์๋ฏธ๋ฅผ ์๊ธฐ ์ด๋ ค์ด ๊ฐ ร ๋ช ๋ช ๋ ์์ ์ฌ์ฉ) ๊ฐ ์์, ํด๋์ค, ๋ณ์, ๋ฉ์๋์ ์ด๋ฆ์ด ์ ์ ํ๊ฐ?
ํ ์คํ โ ๋จ์ ํ ์คํ ๋ธ๋ ๋ฐ์ค ํ ์คํ (๋ฐ์ดํฐ ์์ฃผ ํ ์คํ ) ๊ธฐ๋ฅ ์์ญ: ์ ํจํ ์ ๋ ฅ์ ์งํฉ ๊ธฐ๋ฅ ์์ญ์ด ์์ผ๋ฉด ๋ชจ๋ ๊ฒฝ ์ฐ๋ฅผ ๊ฒ์ฌํ ์ ์๋ค. ๋๋ค ๊ฒ์ฌ: ๊ธฐ๋ฅ ์์ญ์์ ๋ช ๊ฐ์ ์ ๋ ฅ์ ๋๋คํ๊ฒ ์ ํํ์ฌ ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ ๊ธฐ๋ฅ ์์ญ์ ๋ถ๋ฅํ์ฌ ๊ฐ ์ ์์ญ ๋ณ ํ๋์ ์ ๋ ฅ์ ๊ฒ์ฌ ํ๋ ๋ฐฉ๋ฒ. ์) ์ ๋ ฅ์ด ์ ์: ์์, 0, ์์
ํฌ๋ช ๋ฐ์ค ํ ์คํ (์ฝ๋ ์์ฃผ ํ ์คํ ) ๋ฉ์๋์ ๊ฐ ๋ฌธ์ฅ์ ์ฐจ๋ก๋ก ์คํํ๋ฉด์ ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ ๋ถ๊ธฐ(branch): ํญ์ ์คํ ๋์ง ์๋ ์ผ๋ จ์ ๋ฌธ์ฅ ๊ฒฝ๋ก(path): ๋ฉ์๋๊ฐ ์คํ ๋์์ ๋ ์คํ๋ ์ ์๋ ๋ถ๊ธฐ์ ์กฐํฉ ๊ฒฝ๋ก ๊ฒ์ฌ(path testing): ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ๋ค ์คํํ๋ฉด์ ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ
ํ ์คํ ์ด๋ ์ค๋ฅ๋ฅผ ๋ฐ๊ฒฌํ๊ธฐ ์ํด ๋ฏธ๋ฆฌ ์ค๊ณ๋ ๋ฐ์ดํฐ ์งํฉ์ ์ด์ฉํ์ฌ ํ๋ก๊ทธ๋จ์ ์คํํ ๋ ๊ฒ์ ๋งํ๋ค. ์ด๋ฐ ํ ์คํ ์ ํฌ๊ฒ ๋ธ๋๋ฐ์ค ํ ์คํ , ํฌ๋ช ๋ฐ์ค ํ ์คํ , ๋ ๊ฐ์ง ์ข ๋ฅ๋ก ๊ตฌ๋ถ๋๋ค. ๋ธ๋ ๋ฐ์ค ํ ์คํ ์ ๊ตฌํ์ ๋ด๋ถ ๋ด์ฉ์ ๋ํ ๊ณ ๋ ค์์ด ์ด๋ค ์ ๋ ฅ์ ๋ํด ์ฌ๋ฐ๋ฅธ ์ถ๋ ฅ์ ์ฃผ๋์ง ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ์ด๋ค. ๋ฐ๋๋ก ํฌ๋ช ๋ฐ์ค ํ ์คํ ์ ๊ตฌํ์ ๋ด๋ถ ๋ด์ฉ์ ๊ณ ๋ คํ ์ฌ ์ ๋ ฅ์ ์ ํ์ฌ ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ์ด๋ค.
- 12 -
๋ฃจํ์ ์ ํ์ฑ ๊ฒ์ฆ ๋ฃจํ ๋ถ๋ณ์กฐ๊ฑด(loop invariant): ๋ฃจํธ๊ฐ ์์๋๊ธฐ ์ , ๋ฃจํ๊ฐ ๋ฐ๋ณต๋ ๋ถ๋ณ์กฐ๊ฑด ํ, ๋ฃจํ๊ฐ ์ข ๋ฃ๋ ํ์ ํญ์ ๋ง์กฑ๋์ด์ผ ํ๋ ์กฐ๊ฑด์ ๋งํ๋ค. ์ถ๊ฐ์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ ํ์ฑ์ ์ถฉ์กฑ์์ผ์ผ ํ๋ค. ์1.2) ๋ฐฐ์ด item์ ์๋ ์์๋ค์ ํฉ ๊ตฌํ๊ธฐ int sum = 0; int i = 0; while(i<n){ sum += item[i]; i++; }
๋ฃจํ ๋ถ๋ณ์กฐ๊ฑด. sum์ item[0]๋ถํฐ item[i-1]๊น์ง์ ํฉ์ด์ด์ผ ํ๋ค.
๋ฃจํ์ ์ ํ์ฑ์ ๊ฒ์ฆํ๊ธฐ ์ํด ๋ง์ด ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ฃจํ ๋ถ๋ณ์กฐ๊ฑด(loop invariant)์ ํ์ธ ํ๋ ๊ฒ์ด๋ค. ๋ฃจํ ๋ถ๋ณ์กฐ๊ฑด์ด๋ ๋ฃจํ๊ฐ ์์๋๊ธฐ ์ , ๋ฃจํ๊ฐ ๋ฐ๋ณต๋ ํ, ๋ฃจํ๊ฐ ์ข ๋ฃ๋ ํ ์ ํญ์ ๋ง์กฑ๋์ด์ผ ํ๋ ์กฐ๊ฑด์ผ๋ก์, ์๊ณ ๋ฆฌ์ฆ์ ์ ํ์ฑ๊ณผ ์ผ์น๋๋ ์กฐ๊ฑด์ด์ด์ผ ํ๋ค. ์ฆ, ๋ฃจํ๊ฐ ์ข ๋ฃ๋๋ฉด ๋ถ๋ณ์กฐ๊ฑด์ด ์ ์ง๋์ด์ผ ํ๋ฉฐ, ์ด ๋ ๊ฒฐ๊ณผ๊ฐ ์ ํํด์ผ ํ๋ค.
1.3. ์๋ฃ๊ตฌ์กฐ ๊ฐ์ ์๋ฃ๊ตฌ์กฐ(data structure)๋ ๋ฐ์ดํฐ๋ฅผ ์ปดํจํฐ์ ํํ, ์ ์ฅ, ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋งํ๋ค.
๋ฐ์ดํฐ, ๋ฐ์ดํฐ ํ์ ๋ฐ์ดํฐ: ๋ฐ์ดํฐ ํ๋ก๊ทธ๋จ์ ์ํด ์ฒ๋ฆฌ ๋๋ ์ ๋ณด ๋ณดํต ๋ฐ์ดํฐ๋ผ ํ๋ฉด ๊ฐ(value)๋ฅผ ์๋ฏธํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ ๋ฐ์ดํฐ ํ์ : ํ์ ๋ค์ ๋ ๊ฐ์ง์ ์ํด ์ ์๋๋ค. ์ด ๋ฐ์ดํฐ ํ์ ์ด ํํํ ์ ์๋ ์์๋ค์ ์งํฉ. ์1.3) ์ ์ ์ด ์์๋ค์ ์ ์ฉํ ์ ์๋ ์ฐ์ฐ์ ์งํฉ. ์1.4) ์ฌ์น์ฐ์ฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ๋ ์ข ๋ฅ์ ๋ฐ์ดํฐ ํ์ ์ ์ ๊ณตํ๋ค. ์์คํ ์ ์ ๋ฐ์ดํฐ ํ์ ๋จ์ ํ์ (์์ ํ์ , ์์ ํ์ ): ๋ ์ด์ ๋ถํดํ ์ ์๋ ํ์ ํ์ ๋ณตํฉ ํ์ : ํ์ ์ฌ๋ฌ ์์๋ก ๊ตฌ์ฑ๋์ด ์๋ ํ์ ร ์์ ์ ๊ทผ ์ฐ์ฐ ๊ตฌ์กฐํ๋ ํ์ ๊ณผ ๋น๊ตฌ์กฐํ๋ ํ์ ์ฌ์ฉ์ ์ ์ ๋ฐ์ดํฐ ํ์
๋ฐ์ดํฐ๋ ํ๋ก๊ทธ๋จ์ ์ํด ์ฒ๋ฆฌ๋๋ ์ ๋ณด๋ฅผ ๋งํ๋ค. ๋ฐ์ดํฐ ํ์ ์ ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์๋ณํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ์ฉ์ด๋ก์, ์ด ํ์ ์ผ๋ก ํํํ ์ ์๋ ์์๋ค์ ์งํฉ๊ณผ ์ด ์์๋ค ์ ์ ์ฉํ ์ ์๋ ์ฐ์ฐ์ ์งํฉ์ ์ํด ์ ์๋๋ค. ๋ณดํต ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ค์ ์์คํ ์ ์ ํ์ ๊ณผ ์ฌ์ฉ์ ์ ์ ํ์ ๋ ๊ฐ์ง ์ข ๋ฅ์ ๋ฐ์ดํฐ ํ์ ์ ์ ๊ณตํ๋ค. ์์คํ ์ ์ ํ์ ์ ๋ค ์ ํฌ๊ฒ ๋จ์ ํ์ ๊ณผ ๋ณตํฉ ํ์ ์ผ๋ก ๋๋์ด์ง๋ฉฐ, ๋จ์ ํ์ ์ ๋ ์ด์ ๋ฐ์ดํฐ๋ฅผ ๋ถํดํ ์
- 13 -
์๋ ํ์ ์ด๊ณ , ๋ณตํฉํ์ ์ ๋ฐฐ์ด์ฒ๋ผ ์ฌ๋ฌ ์์๋ก ๊ตฌ์ฑ๋์ด ์๋ ํ์ ์ด๋ค. ๋ณตํฉ ํ์ ์์ ๋ ๊ฐ ์์๋ฅผ ์ ๊ทผํ๋ ์ฐ์ฐ์ด ์ค์ํ๋ค.
์ถ์ํ ์ ์ฐจ์ ์ถ์ํ(procedural abstraction) ์ถ์ํ ๋ฉ์๋์ ๋ชฉ์ ๊ณผ ๊ทธ๊ฒ์ ๊ตฌํ์ ๋ถ๋ฆฌ ๋ฐ์ดํฐ ์ถ์ํ(data abstraction, encapsulation) ์ถ์ํ ๋ฐ์ดํฐ์ ๊ฐ๋ฅํ ์ฐ์ฐ๊ณผ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐฉ๋ฒ ๋ฐ ์ฐ์ฐ ๊ตฌํ์ ๋ถ๋ฆฌ ์ถ์ ๋ฐ์ดํฐ ํ์ (ADT, Abstract Data Type) ํ์ ํน์ ๊ตฌํ๊ณผ ๋ฌด๊ดํ๊ฒ ํน์ฑ์ด ๋ช ์๋ ๋ฐ์ดํฐ ํ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ ๊ณตํ๋ int ํ์ ์ญ์ ADT๋ก ๋ณผ ์ ์๋ค. ๊ทธ๊ฒ์ ๋ด๋ถ ๊ตฌํ์ ๋ชฐ๋ผ๋ ์ฌ์ฉํ ์ ์๋ค.
๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํจ์ ์์ด์๋ ์ถ์ํ๋ ๋งค์ฐ ์ค์ํ๋ค. ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์ ๊ณต ๋๊ณ ์๋ ์ ์ํ ํ์ ์ธ int์ ๊ฒฝ์ฐ์๋ ์ฐ๋ฆฌ๋ ๊ทธ๊ฒ์ด ๋ด๋ถ์ ์ผ๋ก ์ด๋ป๊ฒ ์ ์ฅ๋์ด ์๊ณ , ๊ทธ๊ฒ๊ณผ ๊ด๋ จ๋ ์ฐ์ฐ๋ค์ด ์ด๋ป๊ฒ ๊ตฌํ๋์ด ์๋์ง ์์ธํ ๋ชจ๋ฅด๋ ์ํ์์ ์ฌ์ฉํ๊ณ ์๋ค. ์ด ๊ณผ๋ชฉ์์ ๋ฐฐ์ฐ๋ ์๋ฃ๊ตฌ์กฐ์ ๊ฐ์ฅ ํฐ ํต์ฌ์ ๊ฐ ์ข ๋ฐ์ดํฐ๋ฅผ ์ปดํจํฐ์ ํํ, ์ ์ฅ, ๊ด๋ฆฌ ํ๊ธฐ ์ํ ์๋ก์ด ๋ฐ์ดํฐ ํ์ ์ ๊ตฌํํ๋ ๊ฒ์ด๋ฉฐ, ์ด ๋ ๊ฐ๋ฐ๋ ๋ฐ์ดํฐ ํ์ ์ ๊ทธ๊ฒ์ ์ ์ธํ ๋ด๋ถ ๊ตฌํ์ ์์ง ๋ชปํ์ฌ๋ ์ฌ์ฉํ ์ ์์ด์ผ ํ๋ค. ์ด์ ๊ฐ์ ํน์ฑ์ ์ถ์ ๋ฐ์ดํฐ ํ ์ (ADT, Abstract Data Type)์ด๋ผ ํ๋ค.
์๋ฃ๊ตฌ์กฐ ์๋ฃ๊ตฌ์กฐ(data structure) ์๋ฃ๊ตฌ์กฐ ์ ์1. ์ ์1. ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฐฉ๋ฒ๊ณผ ๊ด๋ จ๋ ๊ฒ์ผ๋ก์ ๋ฐ์ดํฐ ์์๋ค ์ ๋ชจ์์ ๋ชจ์ ๋งํ๋ค. ์ด ๋ชจ์์ ๋ ผ๋ฆฌ์ ๊ตฌ์ฑ์ ๊ฐ๋ณ ์์ ๊ฐ์ ๋ ผ๋ฆฌ์ ๊ด๊ณ๋ฅผ ๊ด๊ณ ๋ํ๋ธ๋ค. ์ ์2. ์ ์2. ๋ฐ์ดํฐ์ ๋ชจ์์ ์ ์ฅํ๊ธฐ ์ํด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ์ด์ฉํ์ฌ ์ ์ํ ์ ์๋ ๊ตฌ์กฐ ์๋ฃ๊ตฌ์กฐ๋ ๊ฐ๋ณ ๋ฐ์ดํฐ ์์๋ฅผ ๊ฒ์ํ๊ณ ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ์ ๊ทผ ์ฐ์ฐ์ ์ํด ํน์ง์ง์ด์ง๋ค. ํน์ง ์๋ฃ๊ตฌ์กฐ๋ ADT๋ก ๊ตฌํ๋๋ค.
์ ์์ ๊ฐ์ ๋จ์ ํ์ ์ ์นด์ดํฐ๋ ๋ฐฐ์ด์ ์์ธ๊ณผ ๊ฐ์ ์ ๋ณด๋ฅผ ๋ํ๋ด๊ธฐ ์ํด์๋ ์ ์ฉํ๊ฒ ์ฌ์ฉ๋ ์ ์๋ค. ํ์ง๋ง ์ค์ ์ํํธ์จ์ด์์ ์ฐ๋ฆฌ๊ฐ ๋ค๋ฃจ๋ ๋ง์ ๋ฐ์ดํฐ๋ ์ ์์ ๊ฐ์ ๋จ ์ ํ์ ์ผ๋ก ํํํ ์ ์๋ ๊ฒ์ด ๋ ๋ง๋ค. ๋ณดํต์ ์ฌ์ฉ์๊ฐ ์๋กญ๊ฒ ์ ์ํ ๋ณตํฉ ํ์ ์ ๋ง ์ด ์ด์ฉํ๋ค. ์๋ฅผ ๋ค์ด ์ฑ์ ์ฒ๋ฆฌ ํ๋ก๊ทธ๋จ์์๋ ํ์์ ๊ดํ ์ฌ๋ฌ ์ ๋ณด๋ฅผ ์ ์งํ๊ธฐ ์ํด
- 14 -
๋ณตํฉ ํ์ ์ ์ ์ํ์ฌ ์ฌ์ฉํ ๊ฒ์ด๋ค. ๊ทธ๋ฐ๋ฐ ์ด ๋ ํ ํ์์ ์ ๋ณด๋ง์ ์ ์งํ๋ ๊ฒฝ์ฐ๋ ๋๋ฌผ๋ฉฐ, ์ฌ๋ฌ ํ์๋ค์ ์ ๋ณด๋ฅผ ๋ชจ์ ์ ์งํ๋ ๊ฒ์ด ๋ณดํต์ด๋ค. ์ด์ฒ๋ผ ๋ฐ์ดํฐ ์์๋ค์ ๋ชจ์ ์ ์๋ฃ๊ตฌ์กฐ๋ผ ํ๋ฉฐ, ์ด ๋ ๊ฐ ์์๋ ๋ณตํฉ ํ์ ์ผ ์๋ ์๊ณ , ๋จ์ ํ์ ์ผ ์๋ ์๋ค. ์ด๋ฐ ์๋ฃ๊ตฌ์กฐ๋ ๊ฐ๋ณ ์์๋ฅผ ์ ๊ทผํ๋ ์ฐ์ฐ์ ๋ฐ๋ผ ๊ทธ ํน์ง์ด ์ ์๋๋ค. ํนํ, ์๋ฃ๋ฅผ ์ด๋ป๊ฒ ์กฐ์งํ๋๋์ ๋ฐ๋ผ ๊ฐ ์ ๊ทผ ์ฐ์ฐ์ ์ฑ๋ฅ์ ํฐ ์ํฅ์ ์ค๋ค.
์๋ฃ๊ตฌ์กฐ โ ๊ณ์ ์๋ฃ๊ตฌ์กฐ์ ํน์ฑ ๊ตฌ์ฑ ์์๋ก ๋ถํด๋ ์ ์๋ค. ์์๋ค์ด ์กฐ์ง๋์ด ์๋ ํํ๋ ๊ฐ ๊ฐ๋ณ ์์์ ๋ํ ์ ๊ทผ ๋ฐฉ๋ฒ์ ์ํฅ์ ์ค๋ค. ์กฐ์ง๋์ด ์๋ ํํ์ ์ ๊ทผ ๋ฐฉ๋ฒ์ ๋ชจ๋ ์บก์ํํ ์ ์๋ค. ์๋ฃ๊ตฌ์กฐ์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ์ฐ์ฐ์ ๋ถ๋ฅ ์์ฑ์: ์์ฑ์ ์ ์ธ์คํด์ค๋ฅผ ์์ฑํ ๋ ์ฌ์ฉ๋๋ ์ฐ์ฐ ๊ธฐ์กด ๊ฐ์ฒด์ ๋ด์ฉ์ ์ด์ฉํ์ฌ ์ ๊ฐ์ฒด๋ฅผ ์์ฑํ๋ ์์ฑ์๋ฅผ ๋ณต์ฌ ์์ฑ์(copy constructor)๋ผ ํ๋ค. ์์ ์: ์์ ์ ๋ฐ์ดํฐ์ ๊ฐ๋ค์ ์ํ๋ฅผ ๋ณ๊ฒฝํ ๋ ์ฌ์ฉ๋๋ ์ฐ์ฐ ๊ด์ฐฐ์: ๊ด์ฐฐ์ ๋ฐ์ดํฐ์ ๊ฐ๋ค์ ์ํ๋ฅผ ์ด๋ํ ๋ ์ฌ์ฉ๋๋ ์ฐ์ฐ ๋ฐ๋ณต์(iterator): ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์๋ ๋ชจ๋ ๊ตฌ์ฑ์์๋ฅผ ์์ฐจ์ ์ผ๋ก ๋ฐ๋ณต์ ์ฒ๋ฆฌํ ์ ์๋๋ก ํด์ฃผ๋ ์ฐ์ฐ
์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฐ์ดํฐ ์๊ณ ๋ฆฌ์ฆ(algorithm): ์ ํ ๋จ๊ณ ๋ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ๋ณ๋ก ๊ธฐ์ ํ ๊ฒ์ ๋งํ๋ค. ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ฐ์ดํฐ๋ ์๋ก ๋งค์ฐ ๋ฐ์ ํ๊ฒ ๊ด๋ จ๋์ด ์์ ์๋ฃ๊ตฌ์กฐ์ ๋ฐ๋ผ ๊ทธ๊ฒ์ ์ ์ฉํ ์ ์๋ ์๊ณ ๋ฆฌ์ฆ์ด ๋ฌ๋ผ์ง๋ค. ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌ๋ ์ํ๋ก ์ ์งํ๊ณ ์์ ์ ๊ทผ์ ์ ๊ณตํ๋ ๊ตฌ์กฐ๋ ์ด์ง ๊ฒ์์ด ๊ฐ๋ฅํ๋ค.
์๊ณ ๋ฆฌ์ฆ์ ์ ํ ๋จ๊ณ ๋ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๋จ๊ณ๋ณ๋ก ๊ธฐ์ ํ ๊ฒ์ ๋งํ๋ค. ์ด๋ค ๋ฌธ ์ ๊ฐ ์ฃผ์ด์ก์ ๋ ๊ทธ๊ฒ์ ํด๊ฒฐํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ฌด์ํ ๋ง์ ์ ์๋ค. ์ํํธ์จ์ด ๊ฐ๋ฐ์๋ ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ฌ๋ฌ ์๊ณ ๋ฆฌ์ฆ์ด ์ฃผ์ด์ก์ ๋ ์ฃผ์ด์ง ์กฐ๊ฑด์์ ๊ฐ์ฅ ์ ํฉํ ์๊ณ ๋ฆฌ์ฆ ์ ์ ํํ ์ ์์ด์ผ ํ๋ค. ์๊ณ ๋ฆฌ์ฆ์ ๊ทธ๊ฒ์ด ์ฒ๋ฆฌํ๋ ๋ฐ์ดํฐ์ ๋ฐ๋ผ ์ ํ๋ ์ ์๋ค. ์ ๋ฅผ ๋ค์ด ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌ๋ ์ํ๋ก ์ ์งํ๊ณ ์์ ์ ๊ทผ์ ์ ๊ณตํ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ ๊ฒฝ์ฐ์ ๋ ์ ํ ๊ฒ์์ด ์๋ ์ด์ง ๊ฒ์์ ํ ์ ์๋ค.
- 15 -
์ 2์ฅ ์๋ฐ ๋ณต์ต ์ด ์ฅ์์๋ ์๋ฐ์ ๋ํด ๋ณต์ตํ๋ค.
2.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์๋ฐ์ ํน์ฑ ์ดํด์ ๋ณต์ต
2.2. ์๋ฐ์ ์ญ์ฌ
์๋ฐ ์ญ์ฌ 1991๋ : Sun Microsystems ์ฌ์ James Gosling๊ณผ Patrick Naughton์ด ๊ฐ๋ฐํ ๊ณ ๊ธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ํ๋ก์ ํธ ์ฝ๋๋ช : Green ์๋๋ ์ง๋ฅํ TV์ ๊ฐ์ ๊ฐ์ ์ฉ ๊ฐ์ ์ ํ์ ์ฌ์ฉ๋ ์ธ์ด๋ก ๊ฐ๋ฐ๋จ ๊ฐ ์ ์กฐ์ ์ฒด๋ ๋ค๋ฅธ CPU๋ฅผ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก ํน์ ์ปดํจํฐ ๊ตฌ์กฐ์ ๋ ๋ฆฝ์ฑ์ ๊ฐ์ง๋ ๊ฒ์ด ๊ฐ์ฅ ์ค์ํ ์ค๊ณ ๋ชฉํ์๋ค. ๊ธฐ๊ณ์ด์ ๋ ๋ฆฝ์ ์ธ ์ค๊ฐ ์ฝ๋(intermediate code)๋ฅผ ์์ฑํ๋ ์ฝ๋ ์ด๋ ๊ฐ๋ฅ ์ธ์ด ๊ฐ๋ฐ (write-once run anywhere) C++ ๊ธฐ๋ฐ: ๊ฐ์ฒด์งํฅ ์ธ์ด ์ ๊ณ ๋ฐ์: ๋๋
1991๋ Sun ์ฌ์ James Gosling๊ณผ Patrick Naughton์ ์ผ์ด๋ธ TV ์ค์์น ๋ฐ์ค์ ๊ฐ์ ๊ฐ ์ ์ ํ์ ์ฌ์ฉ๋ ์ ์๋ ์์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ฅผ ๊ฐ๋ฐํ๊ณ ์ ํ์๋ค. ๊ฐ์ ์ ํ์ ๊ฐ ์ ์กฐ ์ ์ฒด๋ ๋ค๋ฅธ CPU๋ฅผ ์ฌ์ฉํ ์ ์๊ธฐ ๋๋ฌธ์ ์ด์์ฑ(portability)์ด ์ด๋ค์๊ฒ ๊ฐ์ฅ ์ค์ํ ์ค ๊ณ ๋ชฉํ๊ฐ ๋์๋ค. ๊ทธ ๊ฒฐ๊ณผ ๊ธฐ์กด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ฒ๋ผ ๊ธฐ๊ณ์ ์์กด์ ์ธ ์คํ ํ์ผ์ ๋ง๋ค์ด
- 17 -
์คํํ๋ ๋ฐฉ์์ด ์๋ ๊ธฐ๊ณ์ ๋ ๋ฆฝ์ ์ธ ์ค๊ฐ์ฝ๋(intermediate code)๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ์์ ์ฑ ํํ์๋ค.
์ด
์ค๊ฐ์ฝ๋๋ฅผ
๋ฐ์ดํธ
์ฝ๋(bytecode)๋ผ
ํ๋ฉฐ,
์ด
์ฝ๋๋
๊ฐ์๊ธฐ๊ณ(virtual
machine)๋ฅผ ํตํด ๋ฒ์ญ(interpreter) ๋ฐฉ์์ผ๋ก ์คํ๋๋ค. Sun ์ฌ๋ UNIX ๊ธฐ๋ฐ ์ํฌ์คํ ์ด์ ์ด ์ฃผ๋ ฅ ์ ํ์ด๋ฏ๋ก ์ด๋ค์ C++ ์ธ์ด๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ์ฌ ์ธ์ด๋ฅผ ๊ฐ๋ฐํ์๋ค. ์ด๋ ๊ฒ ํ์๋ ์ธ ์ด๊ฐ ์๋ฐ์ด์ง๋ง ์ฒ์์๋ ํฐ ๋ฐ์์ ์ป์ง ๋ชปํ์๋ค.
์๋ฐ ์ญ์ฌ โ ๊ณ์ WWW์ ๊ธ์ฑ์ฅ Gosling ๋ฑ์ ์ด ์ธ์ด๋ฅผ ์ด์ฉํ์ฌ 1995๋ ๋์ HotJava๋ผ๊ณ ํ๋ ์น ๋ธ๋ผ์ฐ์ ๋ฅผ ๊ฐ๋ฐํจ ์ด ๋ธ๋ผ์ฐ์ ๋ ๊ธฐ์กด ๋ธ๋ผ์ฐ์ ์ ๋ฌ๋ฆฌ ์๋ฐ๋ก ์์ฑ๋ ์ ํ๋ฆฟ (applet)์ด๋ ํ๋ก๊ทธ๋จ์ ์น์์ ๋ค์ด๋ฐ์ ์คํํ ์ ์์ ์์ ์ฑ๊ณผ ์ด์์ฑ์ด ์ค์ํ ์ด์ ํ์ฌ๋ ๋ง์ดํฌ๋ก์ํํธ ์ธํฐ๋ท ์ต์คํ๋ก๋ฌ์์๋ ์ง์ 1996๋ : Sun Microsystems ์ฌ๋ ์๋ฐ์ ์ฒซ ๋ฒ์ ์ถ์ ์ค์ ์์ฉ์ ๊ฐ๋ฐํ๊ธฐ์๋ ๊ธฐ๋ฅ์ด ๋ฏธํก 1998๋ : Java 2 ์ถ์ ํ์ฌ๋ J2SE(Core/Desktop), J2EE(Enterprise), J2ME(Mobile) ์ธ ์ข ๋ฅ์ ๋ฒ์ ์ ์ ๊ณต
์๋ฐ๊ฐ ๊ฐ๋ฐ๋ ์๊ธฐ๋ ์ฐ์ฐํ ์ธํฐ๋ท ํนํ ์๋์์ด๋์น(WWW, World Wide Web)์ด ํญ๋ฐ ์ ์ผ๋ก ๊ธ์ฑ์ฅํ ์๊ธฐ์ ์ผ์นํ์๋ค. Gosling์ ์์ ์ด ๊ฐ๋ฐํ ์๋ฐ ์ธ์ด๋ฅผ ์ด์ฉํ์ฌ ๊ทธ ๋น ์๊น์ง๋ ์์์ ํ์ง ๋ชปํ์๋ ์๋ก์ด ๊ฐ๋ ์ ์น ๋ธ๋ผ์ฐ์ ๋ฅผ ๊ฐ๋ฐํ์๋ค. ์ด ๋ธ๋ผ์ฐ์ ๋ ์๋ฐ๋ก ์์ฑ๋ ์ ํ๋ฆฟ(applet)์ด๋ผ๊ณ ํ๋ ํ๋ก๊ทธ๋จ์ ์น์์ ๋ค์ด๋ฐ์ ์น ํ์ด์ง ๋ด์์ ์ค ํํ ์ ์์๋ค. ์ด ๊ฐ๋ ์ด ํฐ ํธ์์ ์ป์์ผ๋ฉฐ, ๊ทธ ๊ฒฐ๊ณผ ์๋ฐ ์ธ์ด๋ ์ ์ธ๊ณ์ ์ธ ๊ด์ฌ์ ๋ฐ๊ฒ ๋์๋ค. ์ดํ Sun์ฌ๋ 1996๋ ์ ์๋ฐ์ ์ฒซ ๋ฒ์ ์ ๊ณต์์ ์ผ๋ก ์ถ์ํ์๋ค. ํ์ง๋ง ์ฒซ ๋ฒ์ ์ ๋์ ์์ค์ ์์ฉ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐํ๊ธฐ์๋ ๋งค์ฐ ๋ถ์กฑํ์๋ค. 1998๋ Java 2๊ฐ ์ถ ์๋๋ฉด์ ๋ณธ๊ฒฉ์ ์ผ๋ก ๋ค๋ฅธ ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ด๊นจ๋ฅผ ๋๋ํ ํ๊ฒ ๋์๋ค.
- 18 -
2.3. ์๋ฐ์ ํน์ฑ
์๋ฐ์ ์ฅ์ ๋จ์: C++์์ ๋ชจํธํ๊ฑฐ๋ ์์ฃผ ์ฌ์ฉ๋์ง ์๋ ๊ธฐ๋ฅ ์ ๊ฑฐ ์์ ํ ๊ฐ์ฒด์งํฅ ์ธ์ด: C++๋ณด๋ค ๋ ์์ ์ฑ ํฅ์(bug-free) ํ์ ์ ๊ฐ์ ์ฑ ์๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ณผ ํด์ ์ ๊ฑฐ ร garbage collection ํฌ์ธํฐ ์ฐ์ฐ ์ ๊ฑฐ ํ ๋น ์ฐ์ฐ๊ณผ ๋น๊ต ์ฐ์ฐ ํผ๋ ์ ๊ฑฐ ๋ค์ค ์์ ์ ๊ฑฐ, ๋์ ์ธํฐํ์ด์ค ๊ฐ๋ ๋์ ํ๋ซํผ ๋ ๋ฆฝ์ฑ ์ด์์ฑ์ด ๋์ ํด์ ๊ธฐ๋ฐ(cf. ์ปดํ์ผ) ๋ค์ค ์ฐ๋ ๋ ์ง์ ๋ถ์ฐ ์ง์: TCP/IP ํต์ ์ง์
์๋ฐ๋ ๋ง์ ์ฅ์ ์ ์ง๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ค. ์ฒซ์งธ, ์๋ฐ๋ C++๋ฅผ ๊ธฐ๋ฐํ์ฌ ๋ง๋ค์ด์ง ์ธ ์ด์ด์ง๋ง C++์ ์กด์ฌํ๋ ๋ชจํธํ ๊ธฐ๋ฅ ๋๋ ์์ฃผ ์ฌ์ฉ๋์ง ์๋ ๊ธฐ๋ฅ์ ์ ๊ฑฐํ์ฌ ๋ณด๋ค ์ฝ ๊ฒ ๋ฐฐ์ฐ๊ณ ํ๋ก๊ทธ๋จ์ ์์ฑํ ์ ์๋๋ก ํ์๋ค. ๋์งธ, ์๋ฐ๋ ์์ ํ ๊ฐ์ฒด์งํฅ ์ธ์ด์ด๋ค.
C++์ ๊ฒฝ์ฐ์๋ ๊ธฐ์กด C์ฒ๋ผ ์ ํ ๊ฐ์ฒด์งํฅ ๊ฐ๋ ์ ์ฌ์ฉํ์ง ์๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ ์ ์์ง๋ง ์๋ฐ๋ ๊ทธ๋ ์ง ์๋ค. ์ ์งธ, ๋งค์ฐ ๊ฐ๊ฑดํ ์ธ์ด์ด๋ค. ์ฆ, ์ค๋ฅ๊ฐ ์๋ ์ ๋ขฐ์ฑ์ด ๋์ ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฐํ ์ ์๋ค. ํนํ, ์๋ฐ์๋ ํฌ์ธํฐ ์ฐ์ฐ์ด ์์ผ๋ฉฐ, ๋์ ์ผ๋ก ํ ๋น๋ฐ์ ๋ฉ๋ชจ ๋ฆฌ ๊ณต๊ฐ์ ํ๋ก๊ทธ๋๋จธ๊ฐ ์ง์ ๋ฐ๋ฉํ ํ์๊ฐ ์๋ค. ๋ท์งธ, ์ด์์ฑ์ด ๋งค์ฐ ๋์ ์ธ์ด์ด๋ค. ์ ๋ฐ ๊ฐ์ ๊ธฐ๊ณ๊ฐ ์์ผ๋ฉด ๊ธฐ๊ณ/์ปดํจํฐ์ ์ข ๋ฅ์ ์๊ด์์ด ์ฝ๋๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ์คํํ ์ ์ ๋ค. ์ด ์ธ์๋ ๋ค์ค ์ฐ๋ ๋ ์ง์ ๊ธฐ๋ฅ, ๋ถ์ฐ ์ง์ ๊ธฐ๋ฅ ๋ฑ ๋ง์ ์ฅ์ ์ ์ง๋๊ณ ์๋ค.
์๋ฐ์ ๋ํ ์คํด ์๋ฐ๋ HTML์ ํ์ฅ์ด๋ค. ์๋ฐ๋ ๋ฐฐ์ฐ๊ธฐ ์ฌ์ด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ค. ์๋ฐ๋ ํ๋ก๊ทธ๋จํ๊ธฐ ์ฌ์ด ํ๊ฒฝ์ ์ ๊ณตํ๋ค. ์๋ฐ๋ ๋ชจ๋ ํ๋ซํผ์ ์ํ ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ ๋ ๊ฒ์ด๋ค. ์๋ฐ๋ ๋ ๋ค๋ฅธ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ค. ๋ชจ๋ ์๋ฐ ํ๋ก๊ทธ๋จ๋ค์ ์น ํ์ด์ง ๋ด์์ ์ํ๋๋ค. ์๋ฐ applet์ ๋ณด์์ ์ผ๋ก ๋งค์ฐ ์ํํ๋ค. ์๋ฐ์คํฌ๋ฆฝํธ๋ ์๋ฐ์ ๋จ์ ๋ฒ์ ์ด๋ค.
๋ณดํต ์๋ฐ์ ๋ํด ๋ช ๊ฐ์ง ์คํด๋ฅผ ํ๊ธฐ๊ฐ ์ฝ๋ค. ์๋ฐ๋ ์น์ ์๋ ์ ํ๋ฆฟ์ ํตํด ๊ฐ์ฅ ๋ง์ด ์ ํ๊ฒ ๋๋ค. ๋ฐ๋ผ์ ์๋ฐ๊ฐ HTML์ ํ์ฅ์ผ๋ก ์คํดํ๋ ๊ฒฝ์ฐ๋ ์๋ค. ํ์ง๋ง ์๋ฐ๋ ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ด๋ฉฐ, ์น๊ณผ ์ ํ ๊ด๋ จ์ด ์๋ ํ๋ก๊ทธ๋จ๋ ๊ฐ๋ฐํ ์ ์๋ค. ์๋ฐ๋ ๋ฐฐ์ฐ๊ธฐ
- 19 -
์ฌ์ด ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์ดํดํ๋ ๊ฒฝ์ฐ๋ ๋ง๋ค. ์๋ฐ๊ฐ ๋ค๋ฅธ ์ธ์ด๋ค์ ๋นํด ๋ฐฐ์ฐ๊ธฐ๊ฐ ์ฌ์ด ์ธก๋ฉด๋ ์์ง๋ง ์๋ฐ์ฒ๋ผ ๊ฐ๋ ฅํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ค์ ๋ฅ์ํ๊ฒ ์ฌ์ฉํ๊ธฐ ์ํด์๋ ๋ง์ ๋ ธ ๋ ฅ์ด ํ์ํ๋ค. ์๋ฐ๋ ํ๋ก๊ทธ๋๋ฐํ๊ธฐ ์ฌ์ด ํ๊ฒฝ์ ์ ๊ณตํ๋ค๊ณ ์๊ฐํ ์ ์๋ค. ์ด๊ฒ์ ์ต ๊ทผ์ ์ด๋ ์ ๋ ํ์คํ๋๊ณ ์๋ค. ํ์ง๋ง ์ด์ฐฝ๊ธฐ์๋ ๋ง์ดํฌ๋ก์ํํธ Visual ์ธ์ด๋ค์ด ์ ๊ณต ํ๋ ํตํฉ ๊ฐ๋ฐ ํ๊ฒฝ๊ณผ ๊ฐ์ ๊ฐ๋ฐ ํ๊ฒฝ์ด ์์๋ค. ์๋ฐ์คํฌ๋ฆฝํธ๋ ์๋ฐ์ ๋จ์ ๋ฒ์ ์ผ๋ก ์ ๊ฐํ๋ ๊ฒฝ์ฐ๋ ์๋ค. ์ด๋ฆ๋ง ์ ์ฌํ ๋ฟ ์๋ฐ์คํฌ๋ฆฝํธ์ ์๋ฐ๋ ๋ค๋ฅธ ๊ฒ์ด๋ค. ์๋ฐ์คํฌ๋ฆฝํธ ๋ Netscape ์ฌ์์ ๊ฐ๋ฐํ ์คํฌ๋ฆฝํธ ์ธ์ด์ด๋ฉฐ, ์๋ฐ์ ์ ์ฌํ ๋ฌธ๋ฒ์ ๊ตฌ์กฐ๋ฅผ ์ง๋๊ณ ์์ด ๊ทธ๋ค์ด ์ด๋ฆ์ ์๋ฐ์คํฌ๋ฆฝํธ๋ก ๋ช ๋ช ํ ๊ฒ์ผ ๋ฟ ์๋ฐ์๋ ์ ํ ๋ค๋ฅธ ๊ฒ์ด๋ค.
2.4. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ
OOP์ ๊ธฐ๋ณธ ๊ฐ๋ ํ๋ก๊ทธ๋จ์ ๊ฐ์ฒด(object)๋ก ๊ตฌ์ฑ๋จ ๊ฐ์ฒด ๊ฐ์ฒด๋ ํ์(behavior), ์ํ(state), ์๋ณ์(identity)๋ฅผ ๊ฐ์ง ์บก์ํ(encapsulation): ๋ฐ์ดํฐ์ ํ์๋ฅผ ํ๋๋ก ๊ฒฐํฉ ๊ฐ์ฒด๋ ๋ฉ์์ง๋ฅผ ๋ฐ์ ๊ทธ๊ฒ์ ์ฒ๋ฆฌํด์ค๋ค. ๋ด๋ถ ๊ตฌํ์ ๋ํด์๋ donโt care ํ ๊ฐ์ฒด๋ ๋ค๋ฅธ ๊ฐ์ฒด์ ๋ด๋ถ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ์ง์ ์กฐ์ํ์ง ์์ ํด๋์ค(class) ํด๋์ค ๊ฐ์ ์ข ๋ฅ์ ๊ฐ์ฒด๋ค์ ๋ชจ์ ํด๋์ค๋ ์ด๋ฆ์ ๊ฐ์ง๋ฉฐ, ๋ฉค๋ฒ๋ณ์(member/instance variable, field, attribute)์ ๋ฉ์๋(method, member function)๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ํด๋์ค ๊ฐ์ ๊ด๊ณ: use, has-a(aggregation), is-a(generalization) ์ธ์คํด์ค(instance): ํด๋์ค์ ํ ๊ฐ์ฒด ์ธ์คํด์ค
์๋ฐ ์ธ์ด๋ฅผ ์ ๋๋ก ํ์ฉํ๊ธฐ ์ํด์๋ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๋ํ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์ ํํ๊ฒ ์ดํดํ๊ณ ์์ด์ผ ํ๋ค. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์์ ํ๋ก๊ทธ๋จ์ ๊ฐ์ฒด๋ก ๊ตฌ์ฑ๋๋ฉฐ, ๊ฐ์ฒด๋ค ๊ฐ์ ์ํธ์์ฉ์ ํตํด ์ํ๋ ๋ชฉ์ ์ ๋ฌ์ฑํ๋ค. ๊ฐ์ฒด๋ ํ์, ์ํ, ์๋ณ์๋ฅผ ์ง๋๋ค. ๋ณด๋ค ์ค์ ํ ๊ฒ์ ์ด์ ํ๋ก๊ทธ๋๋ฐ ๋ฐฉ์์์๋ ๋ฐ์ดํฐ์ ๊ทธ๊ฒ์ ์ฒ๋ฆฌํ๋ ํจ์๊ฐ ๋ถ๋ฆฌ๋์ด ์กด์ฌํ์ ์ง๋ง ๊ฐ์ฒด์งํฅ์์๋ ๋ฐ์ดํฐ์ ๊ทธ๊ฒ์ ์ฒ๋ฆฌํ๋ ์ฐ์ฐ์ด ๊ฒฐํฉ๋์ด ๊ฐ์ฒด๋ผ๋ ํํ๋ก ์กด์ฌํ ๋ค. ์ด๋ ๊ฒ ๋ฐ์ดํฐ์ ํ์๋ฅผ ํ๋๋ก ๊ฒฐํฉํ๋ ๊ฒ์ ์บก์ํ๋ผ ํ๋ค. ๊ฐ์ฒด๋ ๊ทธ๊ฒ์ด ์ ๊ณตํ๋ ์ธํฐํ์ด์ค๋ฅผ ํตํด ์ธ๋ถ์ ์ํธ์์ฉํ๋ค. ์ธ๋ถ์์๋ ๊ฐ์ฒด์ ๋ด๋ถ ๊ตฌํ์ ๋ํด์๋ ์ ํ์ ๊ฐ ์๋ค. ํด๋์ค๋ ๊ฐ์ ์ข ๋ฅ์ ๊ฐ์ฒด๋ค์ ๋ชจ์์ด๋ค. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด ๊ด์ ์์ ๋ณด๋ฉด ํด๋์ค๋ ๊ฐ์ฒด์ ๋ชจ์ต์ ์ ์ํ๊ณ ์๋ ํ์ด๋ค. ํด๋์ค๋ ๋ฉค๋ฒ๋ณ์์ ๋ฉ์๋๋ก ๊ตฌ์ฑ๋๋ค. ํด๋์ค ๊ฐ์ ๊ด๊ณ ๋ ํฌ๊ฒ ์ฌ์ฉ(use), ํฌํจ(has-a), ์์(is-a) ์ธ ๊ฐ์ง ์ข ๋ฅ๋ก ๋ถ๋ฅํ ์ ์๋ค. ์ฌ์ฉ ๊ด๊ณ๋ ํ ํด๋์ค์ ๊ฐ์ฒด๊ฐ ๊ทธ์๊ฒ ์ฃผ์ด์ง ์ผ์ ๋ฌ์ฑํ๊ธฐ ์ํด ๋ค๋ฅธ ํด๋์ค์ ๋์์ด ํ์ํ ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ํฌํจ ๊ด๊ณ๋ ํ ๊ฐ์ฒด๊ฐ ๋ฉค๋ฒ ๋ณ์๋ก ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ์์ ๊ด๊ณ๋ ๊ฐ์ฒด์งํฅ์์ ๊ฐ์ฅ ์ค์ํ ๊ฐ๋ ์ค ํ๋์ด๋ค. ์ด๊ฒ์ ๋ํด์๋ ๋ค์ ์ฌ๋ผ์ด๋์์ ๋ณด๋ค ์์ธํ ์ค๋ช ํ๋ค. ํด๋์ค์ ํ ๊ฐ์ฒด๋ฅผ ์ธ์คํด์ค(instance)๋ผ ํ๋ค.
- 20 -
OOP์ ๊ธฐ๋ณธ ๊ฐ๋ ์์(inheritance): is-a ๊ด๊ณ ์์ super/sub, base/derived, parent/child ์ธ๋ถํ(specialization), ์ผ๋ฐํ(generalization) ์ฌ์ฌ์ฉ ์ฉ์ดํ๊ฒ ํด์ค๋ค. ๊ด๋ จ ํค์๋: extends, super ์๋ฐ๋ ๋ค์ค ์์์ ์ง์ํ์ง ์๋๋ค. ์์ ๊ณ์ธต๊ตฌ์กฐ, ์์ ์ฒด์ธ ๋คํ์ฑ(polymorphism) ์ฐ์ฐ์ ๊ฐ์ฒด์ ๋ฐ๋ผ ๋ค๋ฅธ ํ์๋ฅผ ํ๋ค. (late binding) overloading cf. overriding
๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ์์์ ์ฝ๋์ ์ฌ์ฌ์ฉ์ ๋์ฌ ์ฃผ๋ ์ค์ํ ํน์ฑ์ด๋ค. ์๋ฅผ ๋ค์ด ํ๊ต ๊ด๋ฆฌ ์์คํ ์ ๋ง๋ค๊ณ ์ ํ๋ค. ํ๊ต ๊ด๋ฆฌ ์์คํ ์์๋ ํ๊ต์์ ๊ทผ๋ฌดํ๋ ์ ์ ๋, ์ง์์ ๊ดํ ์ ๋ณด๋ฅผ ์ ์งํด์ผ ํ ๋ฟ๋ง ์๋๋ผ ํ์๋ค์ ๊ดํ ์ ๋ณด๋ ์ ์งํด์ผ ํ๋ค. ์ด ๋ค์ ๋ชจ๋ ์ฌ๋์ด๋ผ๋ ๊ณตํต๋ ํน์ฑ์ ๊ฐ์ง๊ณ ์๋ค. ์ฆ, ์ฌ๋ ์ด๋ฆ์ฒ๋ผ ๊ณตํต์ ์ผ๋ก ๊ฐ์ง๊ณ ์๋ ํน์ฑ์ด ์๋ค. ์ด๋ฐ ํน์ฑ๊ณผ ์ด๋ฐ ํน์ฑ์ ์กฐ์ํ๋ ์ฐ์ฐ์ ๊ฐ๊ฐ ์ค๋ณตํ์ฌ ์ ์ํ๊ธฐ ๋ณด๋ค ๋ ์ฌ๋์ด๋ผ๋ ํด๋์ค๋ฅผ ๋ง๋ค์ด ์ฌ๊ธฐ์ ์ ์ํ๊ณ , ์ ์๋, ์ง์, ํ์์ ๋ชจ๋ ์ฌ๋ ํด๋์ค๋ก ๋ถํฐ ์์๋ ์์ ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ์ ์ํ๋ฉด ๋ง์ ์ฝ๋๋ฅผ ์ฌ์ฌ์ฉํ ์ ์๋ค. ๋คํ์ฑ(polymorphism)์ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ๋ ๋ค๋ฅธ ํต์ฌ ํค์๋์ด๋ค. ์ฐ๋ฆฌ๋ โ๋ฌธ์ ์ด ๋คโ, โ์ฐฝ๋ฌธ์ ์ด๋คโ์ฒ๋ผ ๊ฐ์ โ์ด๋คโ๋ผ๋ ํํ์ ์ฌ๋ฌ ์ข ๋ฅ์ ์ฌ๋ฌผ์ ์ฌ์ฉํ๋ค. ํ์ง๋ง โ์ด๋คโ ์ ๋ด๋ถ ๋ฉ์ปค๋์ฆ์ ๊ทธ๊ฒ์ ๋์์ด ๋๋ ๋ฌธ, ์ฐฝ๋ฌธ, ์๋์ ๋ฐ๋ผ ๋ค๋ฅด๋ค. ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋ ๋ฐ์์๋ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ ํด๋์ค์ ๋ฐ๋ณตํ์ฌ ์ฌ์ฉํ ์ ์๋ค. ํนํ, ๋คํ์ฑ์ ์์๊ณผ ๊ฒฐํฉํ์ฌ ์ฌ์ฉํ ๋ ๋์ฑ ๊ทธ ์ง๊ฐ๋ฅผ ๋ฐํํ๋ค. ๊ฐ์ฒด์งํฅ๊ณผ ๊ด๋ จํ์ฌ ๋ ๋ง์ด ๋ฑ์ฅํ๋ ์ฉ์ด๋ ์ค๋ฒ๋ก๋ฉ(overloading)์ด๋ค. ์ด๊ฒ์ ํ ํด๋ ์ค ๋ด์ ๊ฐ์ ์ด๋ฆ์ ๋ฉ์๋๋ฅผ ์ฌ๋ฌ ๊ฐ ์ ์ํ๋ ๊ฒ์ ๋งํ๋ค. ์ด ๋ ์ ํ์ ๋ฉ์๋์ ์๋ช ์ด ๋ฌ๋ผ์ผ ํ๋ค. ์ฆ, ๋ฉ์๋์ ํ๋ผ๋ฏธํฐ ๋ชฉ๋ก์ด ๋ฌ๋ผ์ผ ํ๋ค. ์ค๋ฒ๋ก๋ฉ๊ณผ ํผ๋ํ ์ ์๋ ์ฉ ์ด๋ก โoverridingโ์ด๋ผ๋ ์ฉ์ด๊ฐ ์๋ค. ์ด ์ฉ์ด๋ ์์๊ณผ ๊ด๋ จ๋ ์ฉ์ด๋ก์ ์์ ํด๋์ค์์ ๋ถ๋ชจ ํด๋์ค์ ์๋ ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ ๊ฒ์ ๋งํ๋ค.
- 21 -
ํด๋์ค ์ค๊ณ ์๋ น ๋ฉค๋ฒ๋ณ์๋ ํญ์ private ๋ฉค๋ฒ๋ณ์๋ก ๋ฉค๋ฒ๋ณ์๋ฅผ ํญ์ ์ด๊ธฐํํ๋ค. ํด๋์ค ๋ด์ ๊ธฐ๋ณธ ํ์ ์ ๋ง์ด ์ฌ์ฉํ์ง ๋ง๋ผ. ์) private String street; private Address addr;
private String city; private String state;
๋ชจ๋ ๋ฉค๋ฒ๋ณ์๊ฐ ์ด๋์์ ์์ ์ ๋ฉ์๋๋ฅผ ํ์๋ก ํ์ง ์๋๋ค. ํด๋์ค๋ฅผ ์ ์ํ ๋ ํ์ค ํํ๋ฅผ ์ฌ์ฉํ๋ผ. (ํด๋์ค ๋ด๋ถ ๊ตฌ์ฑ) ํด๋์ค ์ด๋ฆ: ๋๋ฌธ์๋ก ์์ ๋ฉค๋ฒ๋ณ์์ ๋ฉ์๋: camel case ํ ํด๋์ค์๊ฒ ๋๋ฌด ๋ง์ ์ฑ ์์ ์ฃผ๋ ๊ฒ์ ํผํ๋ผ. ํด๋์ค์ ๋ฉ์๋์ ์ด๋ฆ์ ์ ์ ํ๊ฒ ๋ถ์ฌํ๋ผ.
์๋ฐ ํ๋ก๊ทธ๋จ์๋ ํด๋์ค ๋ฐ์ ์์ผ๋ฉฐ, ํด๋์ค๋ฅผ ์ด๋ป๊ฒ ์ค๊ณํ๋๋์ ๋ฐ๋ผ ํ๋ก๊ทธ๋จ์ ์ฑ ๋ฅ, ๊ฐ๋ ์ฑ ๋ฑ์ด ๊ฒฐ์ ๋๋ค. ํด๋์ค๋ฅผ ์ค๊ณํ๋ ๊ธฐ๋ณธ ์๋ น์ ๋ฉค๋ฒ๋ณ์๋ ํญ์ private ๋ฉค๋ฒ๋ก ์ ์ธํ๋ค. ์์ ๋๋ฌธ์ ๋ฉค๋ฒ๋ณ์๋ฅผ protected ๋ฉค๋ฒ๋ก ์ ์ธํ๋ ๊ฒฝ์ฐ๋ ์์ง๋ง public ๋ฉค๋ฒ๋ก ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ ๊ฑฐ์ ์๋ค. ๋ํ ๋๋ฌด ๋ง์ ๋ฉค๋ฒ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ ๋ฐ๋์งํ์ง ์๋ค. ํด๋์ค์ ๋ฉค๋ฒ๋ณ์๋ ๋ฐ๋์ ์ฌ๋ฐ๋ฅด๊ฒ ์ด๊ธฐํํด์ผ ํ๋ค. ์ผ๋ฐ์ ์ผ๋ก ํ๋ก๊ทธ๋๋จธ๋ค์ ๋ฉค๋ฒ๋ณ ์๋ง๋ค ๊ทธ๊ฒ์ ๋ํ ์ด๋์์ ์์ ์ ๋ฉ์๋๋ฅผ ํญ์ ์ ์ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ํ์ง๋ง ๋ชจ๋ ๋ฉค ๋ฒ ๋ณ์๊ฐ ๋ฐ๋์ ์ด๋์, ์์ ์ ๋ฉ์๋๊ฐ ํ์ํ ๊ฒ์ ์๋๋ค. ํ ํด๋์ค์ ๋๋ฌด ๋ง์ ์ฑ ์์ ์ฃผ๋ ๊ฒ์ ํผํด์ผ ํ๋ค. ํ ํด๋์ค๊ฐ ๋๋ฌด ๋ง์ ์ผ์ ํ๊ณ ์์ผ๋ฉด ์ด ํด๋์ค๋ฅผ ์ฌ๋ฌ ๊ฐ์ ์์ ํด๋์ค๋ก ๋ถ๋ฆฌ๊ฐ ๊ฐ๋ฅํ์ง ์ดํด๋ณด์์ผ ํ๋ค. ํด๋์ค๋ฅผ ์์ฑํ ๋์๋ ํ์ค ํํ ๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ์ค์ ๋ก ์ ํด์ง ์ด๋ค ํ์ค ํํ๋ ์์ง๋ง ์ ์ฒด์ ์ผ๋ก ํต์ผ์ฑ์ด ์์ด์ผ ํ ๋ฉฐ, ๊ฐ์ข ์ด๋ฆ์ ์๋ฏธ๊ฐ ์ ์ ๋ฌ๋๋๋ก ๋ช ๋ช ํด์ผ ํ๋ค.
2.5. ์๋ฐ์ ๋ํ ์ดํด๋ฅผ ์์๋ณด๊ธฐ ์ํ ์ง๋ฌธ ๋ชฉ๋ก
์ง๋ฌธ ์๋ฐ๋ ์ฒ ์ ๊ตฌ๋ถ์ ํ๋๊ฐ? ํ ํ์ผ์ ์ฌ๋ฌ ํด๋์ค๋ฅผ ์ ์ํ ์ ์๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง) ์๋ฐ์์ ์ ๊ณตํ๋ ๊ธฐ๋ณธ ํ์ (์์ ํ์ )์? ์๋ฐ์์ ์ ๊ณตํ๋ ํ์ ์ ํฌ๊ฒ ๋ ๊ฐ์ง๋ก ๋ถ๋ฅํ๋ฉด? C์์ int ํ์ ๊ณผ ์๋ฐ์ int ํ์ ์ ์ฐจ์ด์ ์? C์์ char ํ์ ๊ณผ ์๋ฐ์ char ํ์ ์ ์ฐจ์ด์ ์? ์ง์ญ๋ณ์๋ ๋ฐ๋์ ์ด๊ธฐํํด์ผ ํ๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง) ์๋ฐ์๋ ์ด๊ฑฐํ ํ์ ์ด ์๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง) ๋ณ์ ์ ์ธ์์ final์ final ์ฉ๋๋? for(int i=0; i<10; i++) {}์์ i์ scope๋? int n = 2.5; ๋ฌธ์ฅ์ ์ค๋ฅ์ธ๊ฐ?
- 22 -
์ง๋ฌธ &&, || ์ฐ์ฐ์์ &, | ์ฐ์ฐ์์ ์ฐจ์ด์ ์? short-circuit evaluation์ด๋? dangling-else ๋ฌธ์ ๋? switch ๋ฌธ์์ โfall throughโ ํ์๋? new ์ฐ์ฐ์์ ์ฉ๋? ๋ฌธ์์ด ์์ฑ์ ํน์ดํ ์ ์? int[ ] nlist = new int[10]; int[ ] alist = nlist; alist[3]=2; ๊ทธ๋ฌ๋ฉด nlist[3]? call-by-value์ call-by-reference์ ์ฐจ์ด์ ? garbage๋, garbage collection์ด๋?
]
์ง๋ฌธ ๋ฉค๋ฒ๋ณ์๋ ๋ช ๋ฐฑํ๊ฒ ์ด๊ธฐํํ์ง ์์ผ๋ฉด ์๋์ผ๋ก ์ด๊ธฐํ ๋๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง) ์ด๊ธฐํํ๋ ๋ฐฉ๋ฒ์ ์ข ๋ฅ? ๊ฐ ๊ธฐ๋ณธ ํ์ ์ ์ด๊ธฐ๊ฐ์? public, private, protected, default access specifier๋? ์์ฑ์(constructor) ๋ฉ์๋๋? ์์ฑ์์ ์ข ๋ฅ๋? ๋ฉ์๋ ์๋ช (method signature)์ด๋? ์จ๊ฒจ์ง ์ธ์(implicit argument)๋? ๋ชจ๋ ๋ฉ์๋๋ ์จ๊ฒจ์ง ์ธ์๋ฅผ ๊ฐ์ง๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง) ์์ ์(mutator) ๋ฉ์๋์ ์ด๋์(accessor) ๋ฉ์๋๋? ๋ค๋ฅธ ๋ง๋ก transformer, observer ๋ฉ์๋
- 23 -
์ง๋ฌธ public ๋ฉค๋ฒ๋ณ์๋ ์ด๋์, ์์ ์ ๋ฉ์๋ ์์ด ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง public ๋ฉค๋ฒ๋ณ์๋ ๊ฑฐ์ ์ฌ์ฉํ์ง ์๋๋ค. ๊ทธ ์ด์ ๋? super ํค์๋? super๋ this๋ฅผ ์ด์ฉํ ์์ฑ์ ํธ์ถ์ ์ ํ์? static ๋ฉค๋ฒ๋ณ์์ ๋ฉ์๋์ ์๋ฏธ? cf. ํด๋์ค ๋ณ์ ์์๋ฅผ ์ ์ธํ ๋ ๋ณดํต ๋ค์๊ณผ ๊ฐ์ด ์ ์ธํ๋ค. public static final int MAX = 100; ์ฌ๊ธฐ์ public, static, final์ ์ฌ์ฉํ ์ด์ ๋? ํด๋์ค B๊ฐ ํด๋์ค A๋ฅผ ์์ํ์๋ค. a๋ A์ ์ธ์คํด์ค์ด๊ณ , b๋ B์ ์ธ์คํด์ค์ด๋ค. a=b์ b=a ์ค ์ด๋ ๊ฒ์ด ์ ํจํ ๋ฌธ์ฅ์ธ๊ฐ?
์ง๋ฌธ package๋? ์ด๋ค ํน์ ํจํค์ง๋ฅผ ์ฌ์ฉํ๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ? ์๋ฐ ํด๋์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค import ์์ด ์ฌ์ฉํ ์ ์๋ ํจํค์ง๋? import java.awt.*;์ ์ฌ์ฉํ๋ฉด java.awt ํจํค์ง์ ์๋ ๋ชจ๋ ํด๋์ค๊ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋ ๋ ํฌํจ๋๋ค. (์ฐธ ๋๋ ๊ฑฐ์ง)? instanceof ์ฐ์ฐ์์ ๊ธฐ๋ฅ์? cf. getClass() ๋ฉ์๋ abstract ๋ฉ์๋๋, abstract ํด๋์ค๋? ๋ถ๋ณ ๊ฐ์ฒด(immutable object)๋? Object ํด๋์ค๋? Wrapper ํด๋์ค๋? ์๋ฐ๋ ๋ค์ค ์์์ ์ ๊ณตํ๋? interface๋?, ๊ทธ๊ฒ์ ์ฉ๋๋? ๋ด๋ถ(inner) ํด๋์ค๋?
- 24 -
์ 3์ฅ ๋ฐฐ์ด ์ด ์ฅ์์๋ ์๋ฐ์์ ์ ๊ณตํ๋ ๋ณตํฉ ํ์ ์ค ํ๋์ธ ๋ฐฐ์ด์ ๋ํด ์ดํด๋ณธ๋ค.
3.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์๋ฐ ๋ฐฐ์ด ArrayList Vector
3.2. ๋ฐฐ์ด
๋ฐฐ์ด
z z z
์ฉ๋: 10 ํฌ๊ธฐ: 3
๋ฐฐ์ด์ ํน์ฑ ๋์ง ๊ตฌ์กฐ(homogeneous structure): ๊ตฌ์กฐ์ ์๋ ๋ชจ๋ ์์๋ ๊ตฌ์กฐ ๊ฐ์ ํ์ ์ด๋ค. ์2.1) ์ผ์ฐจ์ ๋ฐฐ์ด์์ ์ฒซ ์ฌ๋กฏ์ ๋ฐฐ์ด์ ์ ์ฅ๋์ด ์๋ ์์๋ค์ ๊ฐ์๋ฅผ, ๋๋จธ์ง ์ฌ๋กฏ์ ์ ์๊ฐ์ ์ ์ฅํ ๋ฐฐ์ด ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋์ง ๊ตฌ์กฐ์ด์ง๋ง ๋ ผ๋ฆฌ์ ์ผ๋ก๋ ๋์ง ๊ตฌ์กฐ๊ฐ ์๋ ์์๋ค๊ฐ์ ์์๊ฐ ์กด์ฌํ๋ค. ์กด์ฌ ๋ฐฐ์ด์ ์์๋ ์์น์ ์ํด ์ ๊ทผ๋๋ค. (index: 0๋ถํฐ ์์) ๋ฐฐ์ด์ ์ฉ๋์ ์ปดํ์ผ ์๊ฐ์ ์ ํด์ง๋ค. ์ ํด์ง๋ค ๋ฐฐ์ด์ ๋ชจ๋ ์ฌ๋กฏ์ ์ ํจํ ์์๊ฐ ๋ค์ด์์ ํ์๋ ์๋ค. ๋ฐฐ์ด์ ์ฉ๋์ ๋ณ๊ฒฝํ ์ ์๋ค. ์์ ์ ๊ทผ ์ ๊ณต: ์ ๊ณต ๋ชจ๋ ์์๋ฅผ ๋ฐ๋ก ์ ๊ทผํ ์ ์๋ค. ์ฉ๋์ด ๊ณ ์ ๋์ด ์๊ธฐ ๋๋ฌธ์ ์์ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ค.
๋ฐฐ์ด์ ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์ ์งํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ๋ฐฐ์ด์ ๋๋ถ๋ถ์ ํ๋ก ๊ทธ๋๋ฐ ์ธ์ด์์ ์์ฒด์ ์ผ๋ก ์ ๊ณต๋๋ค. ๋ฐฐ์ด์ ๊ฐ์ฅ ํฐ ํน์ง์ ๋ค์๊ณผ ๊ฐ๋ค. ์ฒซ์งธ, ๋์ง๊ตฌ์กฐ์ด๋ค. ์ฆ, ์ ์ฅ๋์ด ์๋ ๋ชจ๋ ์์๊ฐ ๊ฐ์ ํ์ ์ด๋ค. ํ์ง๋ง ๋ฐฐ์ด์ด๋ผ ํ์ฌ ๋ฐ๋์ ๊ฐ์ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ง ์ ์ฅ๋๋ ๊ฒ์ ์๋๋ค. ์๋ฅผ ๋ค์ด ์ ์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์
- 25 -
์ ๋ฐฐ์ด์ ์ ์ฅ๋ ์์์ ๊ฐ์๋ฅผ ์ ์งํ๋ฉด ๋ฌผ๋ฆฌ์ ์ผ๋ก๋ ๋ชจ๋ ์ ์ ๊ฐ์ด ์ ์ฅ๋์ด ์์ง๋ง ๋ ผ๋ฆฌ์ ์ผ๋ก๋ ์ฒซ ๋ฒ์งธ ์์์ ๋๋จธ์ง ์์๋ ๋ค๋ฅด๋ค. ๋ ๋ค๋ฅธ ์๋ก ์๋ฐ์์ Object ํ์ ์ ๋ฐฐ์ด์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ์ด ๋ฐฐ์ด์ ์ ์ฅํ ์ ์๋ ๋ฐ์ดํฐ ํ์ ์ ๊ฑฐ์ ์ ํ์ด ์๋ค. ํ์ง ๋ง ์ด๋ฐ ์์ธ์ ์ธ ๊ฒฝ์ฐ๋ ๋ฐ๋์งํ ๊ฒฝ์ฐ๊ฐ ์๋๋ค. ๋ฐ๋ผ์ ๋ฐฐ์ด์ ๋์ง ๊ตฌ์กฐ๊ฐ ๋๋๋ก ๋ณด์ฅ ํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ๋์งธ, ์์๋ค ๊ฐ์ ์์๊ฐ ์กด์ฌํ๋ค. ๋ฐฐ์ด์ ๊ฐ ์์๋ฅผ ์ ๊ทผํ๊ธฐ ์ํด ์ ์ ํ์ ์ ์์ธ์ด ๋ผ๋ ์ ๋ณด๋ฅผ ์ฌ์ฉํ๋ฉฐ, ์๋ฐ๋ ๋ค๋ฅธ ๋๋ถ๋ถ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฒซ ๋ฒ์งธ ์์ธ ์ ๊ฐ์ 0์ด๋ค. ์์ธ ๊ฐ์ ์ํด ์์๋ค ๊ฐ์ ์์๊ฐ ๊ฒฐ์ ๋๋ค. ์ ์งธ, ๋ฐฐ์ด์ ์ฉ๋์ ์ปดํ์ผ ์๊ฐ์ ์ ํด์ง๋ค. ์์ผ๋ก ํผ๋์ ์ค์ด๊ธฐ ์ํด ๋ฐฐ์ด์ ์ฉ๋
(capacity)์ ๋ฐฐ์ด์ ์์ฑํ ๋ ์ง์ ํ ๋ฐฐ์ด์ ์ ์ฅํ ์ ์๋ ์์์ ์ต๋ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ฉ์ด๋ก ์ฌ์ฉํ๋ฉฐ, ๋ฐฐ์ด์ ํฌ๊ธฐ(size)๋ ํ์ฌ ๋ฐฐ์ด์ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ฉ์ด๋ก ์ฌ์ฉํ๋ค. ๋ท์งธ, ๋ฐฐ์ด์ ์์ ์ ๊ทผ์ ์ ๊ณตํ๋ค. ์์ธ ์ ๋ณด๋ง ์์ผ๋ฉด ๋ฐฐ์ด ๋ด์์ ์์์ ์์น์ ์๊ด ์์ด ๋ฐ๋ก ์ ๊ทผํ ์ ์๋ค. ์ด๊ฒ์ด ๊ฐ๋ฅํ ์ด์ ๋ ์ฉ๋์ด ์ปดํ์ผ ์๊ฐ์ ๊ณ ์ ๋์ด ์์ผ๋ฉฐ, ๊ฐ ์์์ ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์๊ธฐ ๋๋ฌธ์ด๋ค.
์ผ์ฐจ์ ๋ฐฐ์ด ์๋ฐ์์ ๋ฐฐ์ด์ ์ฐธ์กฐ ํ์ ์ด๋ค. ์ผ์ฐจ์ ๋ฐฐ์ด์ ์ ์ธ ์2.2) int[] numbers; // reference type C/C++์ฒ๋ผ int numbers[];์ ๊ฐ์ด ์ ์ธ๋ ์๋ ์๋ค. ๋ค๋ฅธ ์ฐธ์กฐ ํ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก new๋ฅผ ์ด์ฉํ์ฌ ์์ฑ๋์ด์ผ ํ๋ค. ์2.3) numbers = new int[10]; C/C++์ฒ๋ผ int numbers[10];๊ณผ ๊ฐ์ด new๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , ์ ์ธ๊ณผ ๋์์ ์์ฑํ๋ ๊ฒ์ ๊ฐ๋ฅํ์ง ์๋ค. ์ ์ธ๊ณผ ์์ฑ์ ๋์์ ํ ์ ์๋ค. ์2.4) int[] numbers = new int[10]; new๋ฅผ ์ด์ฉํ์ฌ ์์ฑ๋ ๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ์? ๊ธฐ๋ณธ ๊ฐ์ผ๋ก ์๋์ผ๋ก ์ด๊ธฐํ๋๋ค.
์๋ฐ์์ ๋ฐฐ์ด์ ์ฐธ์กฐ ํ์ ์ผ๋ก์ new ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ์์ฑ๋๋ค. ๋ฐฐ์ด์ ์ ์ธํ ๋์๋ ๋ฐฐ์ด์์ ๋ํ๋ด๊ธฐ ์ํด โ[]โ์ ํ์ ๋ช ๋๋ ๋ฐฐ์ด๋ช ๋ค์ ์ฒจ๊ฐํ๋ค. ๋ณดํต ํ์ ๊ณผ ๊ด๋ จ๋ ์ ๋ณด ๋ฅผ ํ ๊ณณ์์ ํํํ๊ธฐ ์ํด ํ์ ๋ช ๋ค์ ์ฒจ๊ฐํ๋ ํํ๋ฅผ ๋ง์ด ์ฌ์ฉํ๋ค. ์๋ฐ์์๋ ์ด๊ธฐ ๊ฐ์ ์ฌ์ฉํ์ง ์๊ณ ๋ฐฐ์ด์ ์์ฑํ๋ฉด ๊ธฐ๋ณธ ๊ฐ์ผ๋ก ๋ชจ๋ ์์์ ๊ฐ์ด ์๋์ผ๋ก ์ด๊ธฐํ๋๋ค.
- 26 -
์ผ์ฐจ์ ๋ฐฐ์ด โ ๊ณ์ ๋ฐฐ์ด์ ์์ ์ ๊ทผ: [] ์ฐ์ฐ์ ์ด์ฉ ์2.5) numbers[2] = 5; value = numbers[i]; ์์ธ๊ฐ์ด 0์์ 9์ฌ์ด์ ๊ฐ์ด ์๋๋ฉด ์๋ฐ๋ ์์ธ๋ฅผ ๋ฐ์์ํจ๋ค. ์์ธ: ArrayIndexOutofBoundException ๋ฐฐ์ด์ ์ฉ๋์ public ๋ฉค๋ฒ๋ณ์์ธ length๋ฅผ ์ด์ฉํ๋ค. ์2.6) numbers.length ์ฌ์ฉ์๋ ์ด ๋ณ์์ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค. ์2.7) numbers.length = 10; ๋น๊ณ . ๋น๊ณ . String์์ ๋ฌธ์์ด์ ๊ธธ์ด๋ length() ๋ฉ์๋๋ฅผ ์ด์ฉ numbers length
5/22
์๋ฐ์์ ๊ฐ ๋ฐฐ์ด์ ์์๋ []
์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ์ ๊ทผํ๋ค. ์ ํจํ์ง ์์ ์์ธ ๊ฐ์ ์ฌ์ฉ
ํ๋ฉด ArrayIndexOutofBoundException์ด๋ผ๋ ์์ธ๊ฐ ๋ฐ์ํ๋ค. ์๋ฐ์์ ๋ฐฐ์ด์ ์ฉ๋์ ํญ์
length๋ผ๋ public ๋ฉค๋ฒ๋ณ์๋ฅผ ์ด์ฉํ์ฌ ์ป์ ์ ์๋ค. ๋ฐ๋ผ์ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋ฐฐ์ด์ ๋ํ๋ด๋ฉด ์ด ์ฌ๋ผ์ด๋์ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ๋ค. ์ด ๋๋ฌธ์ ๋ฐฐ์ด์ ์ธ์๋ก ์ ๋ฌํ๋ฉด ๊ทธ ๋ฉ์๋ ๋ด์์ ๋งค ๊ฐ๋ณ์๋ฅผ ์ด์ฉํ์ฌ ๋ฐฐ์ด์ ์ฉ๋์ ์์๋ผ ์ ์๋ค. ์ฐธ๊ณ ์ ์ผ๋ก String ํ์ ์์๋ ๋ฉค๋ฒ๋ณ์ ๊ฐ ์๋ length()๋ผ๋ ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ์ป์ ์ ์๋ค.
์ผ์ฐจ์ ๋ฐฐ์ด โ ๊ณ์ ์ด๊ธฐ๊ฐ์ ์ ๊ณตํ์ฌ ์์ฑํ ์ ์๋ค. ์2.8) int[] numbers = new int[] {5, 7, 4, 3, 10, 22, -6, -3}; ์ด ๋ numbers์ ์ฉ๋์ 8์ด๋ค. ๋ค์๊ณผ ๊ฐ์ด new int[] ๋ถ๋ถ์ ์๋ตํ ์ ์๋ค. ์2.9) int[] numbers = {5, 7, 4, 3, 10, 22, -6, -3}; ๋์ ๋ฌธ์ ์ด์ฉํ์ฌ ์ด๊ธฐํํ๋ ๊ฒ๋ณด๋ค ์ด๊ธฐ๊ฐ์ ์ด์ฉํ๋ ๊ฒ์ด ๋ ํจ์จ์ ์ด๋ค. int[] age = {2, 12, 10}; ์ด ํํ๊ฐ ๋ ํจ์จ์
int[] age = new int[3]; age[0] = 2; age[1] = 12; age[2] = 10;
์2.8) int[] numbers = new int[8] {5, 7, 4, 3, 10, 22, -6, -3};
6/22
๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ์ ์ ๊ณตํ์ฌ ์์ฑํ ์๋ ์๋ค. ์ด ๋ new ์ฐ์ฐ์์ ์ฌ์ฉ์ ์๋ตํ ์ ์๋ค. ํ์ง๋ง ์ด๊ธฐ๊ฐ ๋ชฉ๋ก์ ์ฌ์ฉํ ๋์๋ ๋ฐฐ์ด์ ์ฉ๋์ ์ง์ ํ ์ ์๋ค. ๋ํ ๋์ ๋ฌธ์ ์ด์ฉํ ์ฌ ์ด๊ธฐํํ๋ ๊ฒ๋ณด๋ค ์ด๊ธฐ๊ฐ ๋ชฉ๋ก์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ณด๋ค ํจ์จ์ ์ด๋ค. ๊ทธ๋ฌ๋ ๋๋ฌด ํฐ ๋ฐฐ์ด ์ ์ด๊ธฐ๊ฐ์ ๋ชจ๋ ๋์ดํ์ฌ ์ด๊ธฐํํ๋ ๊ฒ์ด ์ด๋ ต๋ค๋ ๋ฌธ์ ์ ์ด ์๋ค.
- 27 -
๋ฌธ์ ๋ฐฐ์ด๊ณผ ๋ฌธ์์ด ๋ฌธ์ ๋ฐฐ์ด์ String ํ์ ์ ๊ฐ์ฒด๊ฐ ์๋๋ค. ์2.10)
void f1(String s){ โฆ } void f2(){ char[] fruit = {โaโ, โpโ, โpโ, โlโ, โeโ}; String s = fruit; // error f1(fruit); // error }
๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ ๋ฐฐ์ด์ ๋ฌธ์์ด๋ก ๋ณํํ ์ ์๋ค. ์2.11) char[] fruit = {โaโ, โpโ, โpโ, โlโ, โeโ}; String s1 = new String(fruit); String s2 = new String(fruit, 2, 3);
์ด ์ฒ๋ผ String๋ new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฑํ ์ ์์ง๋ง ๋ณดํต new๋ฅผ ์๋ตํ๋ค. ๋ฌผ๋ก ์ด ๊ฒฝ์ฐ์๋ ์๋ตํ ์ ์๋ค.
// ok // ok โpleโ
๋ฌธ์ ๋ฐฐ์ด์ ๋ฌธ์์ด์ฒ๋ผ ์ถ๋ ฅํ ์ ์๋ค. ์2.12) char[] fruit = {โaโ, โpโ, โpโ, โlโ, โeโ};
๊ฒฐ๊ณผ: apple
System.out.println(fruit);
7/22
C/C++์ ๋ง์ฐฌ๊ฐ์ง๋ก ์๋ฐ์์๋ ๋ฌธ์ ๋ฐฐ์ด๊ณผ ๋ฌธ์์ด์ ๊ตฌ๋ถ๋๋ค. ์ฆ, ๋ฌธ์ ๋ฐฐ์ด์ String ํ์ ์ ์ธ์คํด์ค๊ฐ ์๋๋ค. ํ์ง๋ง ๋ฌธ์ ๋ฐฐ์ด์ ์ฝ๊ฒ ๋ฌธ์์ด๋ก ๋ณํํ ์ ์์ผ๋ฉฐ, ๋ฌธ์ ๋ฐฐ ์ด์ ๋ฌธ์์ด์ฒ๋ผ ์ถ๋ ฅํ ์๋ ์๋ค. ์2.11์์ ์ ์ ์๋ฏ์ด new ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ
String ๊ฐ์ฒด๋ฅผ ์์ฑํ ์๋ ์๋ค. ํ์ง๋ง ๋ณดํต String ๊ฐ์ฒด๋ new ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ์์ฑํ๋ค.
๋ฐฐ์ด์ ๋ณต์ฌ numbers ๋ ๋ฐฐ์ด ๋ณ์๊ฐ ๊ฐ์ ํ์ ์ด๋ฉด ์ํธ ๋์ ํ ์ ์๋ค. ์2.13) int[] numbers = {1, 2, 3, 4}; int[] values = numbers; values๋ numbers์ ๊ฐ์ ๋ฐฐ์ด์ ์ฐธ์กฐํ๊ฒ ๋๋ค. values ํ ๋ฐฐ์ด์ ์๋ ๋ชจ๋ ๊ฐ์ ๋ค๋ฅธ ๋ฐฐ์ด๋ก ๋ณต์ฌํ๊ณ ์ถ์ผ๋ฉด System.arraycopy ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค. ์2.14) int[] numbers = {1,2,3,4,5}; int[] values = {11,12,13,14,15}; System.arraycopy(numbers,0,values,2,3);
numbers
1 2 3 4 5
values
11 12 13 14 15
numbers
1 2 3 4 5
values
System.arraycopy(์์ค๋ฐฐ์ด, ์์ค๋ฐฐ์ด์ ์์์์น, ๋ชฉ์ ๋ฐฐ์ด, ๋ชฉ์ ๋ฐฐ์ด์ ์์์์น, ๋ณต์ฌํ ์์์ ๊ฐ์)
1 2 3 4
11 12 1 2 3
8/22
์๋ฐ์์ ๋ฐฐ์ด์ ์ด๋ฆ์ C/C++์ฒ๋ผ ์์ ํฌ์ธํฐ๊ฐ ์๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ํ์ ์ ๋ค๋ฅธ ๋ฐฐ์ด ๋ณ์๋ฅผ = ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ๋์ ํ ์ ์๋ค. ํ์ง๋ง ์ด๋ฐ ๋์ ์ ๊ฐ๋ค์ด ๋ณต์ฌ๋๋ ๊ฒ์ด ์ ๋๋ผ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฐฐ์ด์ด ๋ฌ๋ผ์ง ๋ฟ์ด๋ค. ๋ฐฐ์ด ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ์์น์ ๋ณํ ์์ด ์ด๋ค ๋ฐฐ์ด์ ๊ฐ๋ง์ ๋ณต์ฌํ๊ณ ์ถ์ผ๋ฉด ์๋ฐ์์๋ System ํด๋์ค์ arraycopy ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค.
- 28 -
ํ๋ผ๋ฏธํฐ๋ก ๋ฐฐ์ด์ ์ ๋ฌ ์๋ฐ์์ ๋ฐฐ์ด์ ์ฐธ์กฐ ํ์ ์ด๋ฏ๋ก ์ธ์๋ก ๋ฉ์๋์ ์ ๋ฌํ์ฌ ๋ฉ์๋ ๋ด์์ ๋ฐฐ์ด์ ์กฐ์ํ๋ฉด ๋ฉ์๋๊ฐ ๋๋ ํ์๋ ์กฐ์ ๊ฒฐ๊ณผ๊ฐ ๊ณ์ ์ ์ง๋๋ค. void f1(int[] a){ ์2.15) a[2] = 10; ๊ฒฐ๊ณผ: 1,2,10,4 } void f2(){ int[] A = {1,2,3,4}; f1(A); void f1(int[] a){ for(int i=0; i<4; i++) int[] B = {5,6,7,8}; System.out.println(A[i]); a = B; ๊ฒฐ๊ณผ: 1,2,3,4 } }
ํ์ง๋ง ์ด ์ญ์ call-by-value ํํ๋ก ์ ๋ฌ๋๋ ๊ฒ์ด๋ค. ์2.16)
void f2(){ int[] A = {1,2,3,4}; f1(A); for(int i=0; i<4; i++) System.out.println(A[i]); } 9/22
์๋ฐ์์ ๋ฐฐ์ด์ ์ด๋ฆ์ ์ฐธ์กฐ ํ์ ์ด๋ฏ๋ก ๋ฐฐ์ด์ ์ธ์๋ก ๋ค๋ฅธ ๋ฉ์๋์ ์ ๋ฌํ์ฌ ๋ฉ์๋ ๋ด ์์ ๋ฐฐ์ด์ ์กฐ์ํ๋ฉด ๊ทธ ๊ฒฐ๊ณผ๊ฐ ๋ฉ์๋๊ฐ ๋๋ ํ์๋ ๊ณ์ ์ ์ง๋๋ค. ํ์ง๋ง ์๋ฐ์์๋
call-by-value ๋ฐฉ์๋ง ์ ๊ณตํ๋ฏ๋ก ๋ฐฐ์ด์ ์ธ์๋ก ์ ๋ฌํ์ฌ ๋ฐฐ์ด ์ด๋ฆ์ด ๊ฐ๋ฆฌํค๋ ์์น๋ฅผ ๋ณ ๊ฒฝํ ์๋ ์๋ค.
Call-by-value์ ์ฐธ์กฐ ๋ณ์ public class A{ private int value; public void set(int n) { value = n; } public int get() { return value; } } // class A public class B{ public static void f(A b){ A c = new A(); b.set(10); b = c; } // f public static void main(String[] args){ A a = new A(); a.set(5); f(a); System.out.println(a.get()); } // main ๊ฒฐ๊ณผ: 10 } // class B
a
value v 10 5
b
c value
v
10/22 10/22
์ด ์ฌ๋ผ์ด๋์ ์์์๋ call-by-value์ ์ฐธ์กฐ ํ์ ์ ๊ด๊ณ๋ฅผ ์ค๋ช ํ๊ณ ์๋ค. ์๋ฐ์์๋
call-by-value ๋ฐฉ์์ ์ธ์ ์ ๋ฌ ๋ฐฉ๋ฒ๋ง ์ ๊ณตํ๋ค. ๋ฐ๋ผ์ swap ๋ฉ์๋๋ ์๋ฐ์์๋ ์ ๋ ๊ตฌํํ ์ ์๋ค. ํ์ง๋ง ์ฐธ์กฐ ํ์ ๊ฐ๋ ์ ๋๋ฌธ์ ๊ฒฐ๊ณผ๊ฐ ๋ง์น call-by-reference๋ก ์ ๋ฌํ ๊ฒ๊ณผ ๊ฐ์ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค. f2() ๋ฉ์๋์์ a๋ผ๋ ๊ฐ์ฒด๋ a.set(5) ๋๋ฌธ์ a์ value ๋ฉค๋ฒ๋ณ์์ ๊ฐ์ด 5๊ฐ ๋๋ค. ์ด ๊ฐ์ฒด๋ฅผ f1() ๋ฉ์๋์ ์ ๋ฌํ๋ฉด a๋ ์ฐธ์กฐ ํ์ ์ด๋ฏ๋ก f1์์
b๋ a์ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋ฉฐ, b.set(10) ๋๋ฌธ์ a์ ๋ฉค๋ฒ๋ณ์์ ๊ฐ์ 10์ผ๋ก ๋ณ๊ฒฝ๋ ๋ค. ํ์ง๋ง call-by-value ๋ฐฉ์์ด๋ฏ๋ก b = c์ ์ํด b๊ฐ c๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ๋๋๋ผ๋ a์๋ ์ํฅ ์ ์ฃผ์ง ์๋๋ค.
- 29 -
๋ฐฐ์ด์ ๋ฐํํ๋ ๋ฉ์๋ ๋ฐฐ์ด์ ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ก ๋ฐํํ ์ ์๋ค. ์2.17) int[] doubeTheSize(int[] a){ 2 int[] b = new int[a.length*2]; 3 System.arraycopy(a,0,b,0,a.length); 4 return b; void f(){ } int[] A = {1,2,3,4}; 1 2 5 A = doubleTheSize(A); A[4] = 5; 6 b for(int i=0; i<5; i++) System.out.println(A[i]); } 3
a
A 1 2
5
1 2
4
3 4
1
2
3
4
1
2
3
4
6
5 11/22 11/22
๋ฐฐ์ด์ ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌํ ์ ์์ ๋ฟ๋ง ์๋๋ผ ๋ฐฐ์ด์ ๋ฉ์๋์ ๊ฒฐ๊ณผ๋ก ๋ฐํํ ์ ์ ๋ค. ์2.7์์๋ doubleTheSize ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๊ธฐ์กด ๋ฐฐ์ด์ ์ฉ๋์ ๋ ๋ฐฐ๋ก ํ์ฅํ๊ณ ์๋ค. ๋ฐฐ์ด์ ์ฉ๋์ ์ปดํ์ผ ์๊ฐ์ ๊ฒฐ์ ๋์ด ๊ณ ์ ๋๋ฏ๋ก ๊ธฐ์กด ๊ณต๊ฐ์ ๋ ๋ฐฐ๋ก ํ์ฅํ ์๋ ์๋ค. ๋ฐฐ์ด์ ์ฉ๋์ ํ์ฅํ๊ธฐ ์ํด์๋ ํ์ํ ์ฉ๋์ ๊ณต๊ฐ์ ์๋กญ๊ฒ ํ๋ณดํ ๋ค์, ๊ธฐ์กด ๋ฐ์ดํฐ๋ฅผ ์ ๊ณต๊ฐ์ผ๋ก ์ฎ๊ธฐ๊ณ , ๋ฐฐ์ด ์ด๋ฆ์ ์๋กญ๊ฒ ํ๋ณดํ ๊ณต๊ฐ์ ๊ฐ๋ฆฌํค๋๋ก ํด์ผ ํ๋ค.
๊ฐ์ฒด ๋ฐฐ์ด ์2.18) Circle[] allCircles = new Circle[5]; Circle ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ฅผ 5๊ฐ๊น์ง ์ ์ฅํ ์ ์๋ ๋ฐฐ์ด์ด ์์ฑ๋๋ค. 5๊ฐ์ Circle ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๊ฒ์ ์๋๋ค. ์ด ๋ ๊ฐ ํญ์ null๋ก ์ด๊ธฐํ๋๋ค. ๊ฐ ๊ฐ๋ณ ๊ฐ์ฒด๋ฅผ ์์ฑํ๊ณ ์ ํ๋ฉด ์ถ๊ฐ๋ก ๋ค์๊ณผ ๊ฐ์ ์ฝ๋๋ฅผ ์คํํด์ผ ํ๋ค. for(int i=0; i<allCircles.length; i++){ allCircles[i] = new Circle(); }
12/22 12/22
์์ ํ์ ์ ๋ฐฐ์ด์ด ์๋ ํด๋์ค ํ์ ์ ๋ฐฐ์ด์ ๊ฒฝ์ฐ์๋ ๋ฐฐ์ด์ ์์ฑํ์๋ค๊ณ ํ์ฌ ๊ทธ ๋ง ํผ์ ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ๊ฒ์ ์๋๋ค. ์ด ์ฌ๋ผ์ด๋์ ์์ฒ๋ผ Circle[] allCircles = new
Circle[5]์ ํ๊ฒ ๋๋ฉด 5๊ฐ์ Circle ๊ฐ์ฒด๊ฐ ์์ฑ๋๋ ๊ฒ์ด ์๋๋ผ Circle ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ฅผ 5๊ฐ๊น์ง ์ ์ฅํ ์ ์๋ ๋ฐฐ์ด์ด ์์ฑ๋๋ค. ์ด ๋ ๋ฐฐ์ด์ ๊ฐ ํญ์ null ๊ฐ์ผ๋ก ์ด๊ธฐํ๋๋ค.
- 30 -
final๊ณผ ๋ฐฐ์ด ์2.19)
void f(){ final int[] numbers = new int[5]; numbers[3] = 4; // ok numbers = new int[3]; // error }
final int[] numbers = new int[5]์์ final์ numbers์ ์ฐ๊ด์ด ์๋ ๊ฒ์ด์ง ๋ฐฐ์ด ์์ฒด์ ์๋ ๊ฒ์ ์๋๋ค.
์ด ๋ถ๋ถ๋ง final
13/22 13/22
์๋ฐ์์ final์ด๋ผ๋ ํค์๋๋ ์ฃผ๋ก ์์๋ฅผ ์ ์ํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ์๋ฅผ ๋ค์ด, ๊ฐ์ด 10์ธ ์์ ์ ์ ๋ณ์๋ ์๋ฐ์์๋ ๋ค์๊ณผ ๊ฐ์ด ์ ์ธํ๋ค.
public static final int CAPACITY = 10; ๋ฐฐ์ด์ ์ ์ธํ ๋ final ํค์๋๋ฅผ ์ฌ์ฉํ๋ฉด ๋ฐฐ์ด ์ด๋ฆ ์์ฒด๊ฐ final์ด ๋์ด ๋ฐฐ์ด์ ์ด๋ฆ์ด ๊ฐ ๋ฆฌํค๋ ์์น๋ฅผ ๋ณ๊ฒฝํ ์ ์๊ฒ ๋์ง๋ง ๋ฐฐ์ด ์ด๋ฆ์ ์ด์ฉํ์ฌ ์ฌ์ ํ ๋ฐฐ์ด์ ๊ฐ ํญ์ ๋ด์ฉ์ ๋ณ๊ฒฝํ ์ ์๋ค.
๋ค์ฐจ์ ๋ฐฐ์ด 2์ฐจ์ ๋ฐฐ์ด์ ํ๊ณผ ์ด๋ก ๊ตฌ์ฑ๋ ํ ์ด๋ธ์ ๋ํ๋ด๊ธฐ ์ํด ์ฌ์ฉํ๋ค. 2์ฐจ์ ๋ฐฐ์ด์ ์ ์ธ ์2.20) double[][] alpha = new double[100][10]; ์ฒซ ๋ฒ์งธ [100]์ ํ์ ๋ ๋ฒ์งธ [10]์ ์ด์ ๋ํ๋ธ๋ค. 2์ฐจ์ ๋ฐฐ์ด์ ์ ๊ทผ alpha[0][5] = 36.4; ํ๊ณผ ์ด์ ๊ฐ์ ํ์ ๊ฐ์: alpha.length ์ด์ ๊ฐ์: alpha[i].length
14/22 14/22
์๋ฐ๋ ๋ค๋ฅธ ์ผ๋ฐ ๋ฒ์ฉ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ค์ฐจ์ ๋ฐฐ์ด์ ์ ์ํ์ฌ ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง ์ผ๋ฐ์ ์ผ๋ก 2์ฐจ์ ์ด์์ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ๋ ๋๋ฌผ๋ค. ๋ํ ์๋ฐ์์
2์ฐจ์ ๋ฐฐ์ด์ ๋ค๋ฅธ ์ธ์ด์์ 2์ฐจ์ ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ํ ๊ฐ์ง ๋ ํนํ ๋ค์๊ณผ ๊ฐ์ ํน์ฑ์ ๊ฐ์ง๊ณ ์๋ค. ์๋ฐ์์ 2์ฐจ์ ๋ฐฐ์ด์ ๊ฐ ํ์ ์ฉ๋์ ์๋ก ๋ค๋ฅผ ์ ์๋ค.
- 31 -
๋ค์ฐจ์ ๋ฐฐ์ด โ ๊ณ์ ์ผ๋ฐ์ ์ผ๋ก 2์ฐจ์ ๋ฐฐ์ด์ ๊ฐ ํ์ ์ฉ๋์ ๊ฐ๋๋ก ๋ง๋ ๋ค. ์2.21) int[][] a = new int[10][5]; ๊ทธ๋ฌ๋ ๊ฐ ํ์ ์ฉ๋์ด ๋ค๋ฅผ ์๋ ์๋ค. ์2.22) int[][] a = new int[2][]; a[0] = new int[5]; a[1] = new int[3];
15/22 15/22
3.3. ArrayList ArrayList๋ java.util ํจํค์ง์์ ์ ๊ณตํ๋ ํด๋์ค๋ก์, ๋ฐฐ์ด๊ณผ ์ ์ฌํ์ง๋ง ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ์ฉ๋ ์ด ๋ถ์กฑํ๋ฉด ์๋์ผ๋ก ์ฆ๊ฐ๋๋ค. ์ด ํด๋์ค๋ ์๋ฐ 1.2๋ถํฐ ์ ๊ณต๋ ํด๋์ค์ด๋ฉฐ, ๋ค์ค ์ฐ๋ ๋ ๋ฅผ ์ง์ํ์ง ์๋๋ค.
ArrayList ArrayList๋ java.util ํจํค์ง์ ์ ์๋์ด ์๋ ํด๋์ค๋ก ๋ฐฐ์ด๊ณผ ์ ์ฌํ์ง๋ง ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ์ฉ๋์ด ๊ณ ์ ๋์ด ์์ง ์๋ค. ์๋ค ์ฆ, ํ์์ ๋ฐ๋ผ ์ฉ๋์ด ๋ณํ๋ค. ArrayList๋ size() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ํ์ฌ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ ์ป์ ์ ์๋ค. ๋ฐฐ์ด์ ํน์ ํ์ ์ ์ ์ฅํ๋๋ก ์ ์ธํ ์ ์์ง๋ง, ArrayList๋ Object ํ์ ๋ง ์ ์ฅํ ์ ์๋ค. (์ฐธ์กฐ๋ฅผ ์ ์ฅํ๋ค.) ๋ฐ๋ผ์ ์์ ํ์ ์ wrapper ํด๋์ค๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ์ด๋ก ์ ์ผ๋ก ์๋ก ๋ค๋ฅธ ์ข ๋ฅ์ ๊ฐ์ ArrayList์ ์์๋ก ์ฌ์ฉ ๊ฐ๋ฅ int[] a = new int[10]; a[0] = 3; a[1] = 2.5; // error
ArrayList a = new ArrayList(); a.add(new Integer(10)); a.add(new Double(2.5)); ๋ฐ๋์งํ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ์๋๋ค.
ArrayList๋ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ก์ ํน์ ํ์ ๋ง ์ ์ฅํ ์ ์๋ ๊ฒ์ด ์๋๊ณ , ํ์ํ ์ด๋ค ์ข ๋ฅ ์ ๋ฐ์ดํฐ๋ ์ ์ฅํ ์ ์๋ค. ์ด๋ฅผ ์ํด ๋ด๋ถ์ ์ผ๋ก Object ๋ฐฐ์ด์ ์ด์ฉํ๋ค. ์์ ๊ด๊ณ์์ ์์ ํด๋์ค์ ๊ฐ์ฒด๋ ์กฐ์ ํด๋์ค ๊ฐ์ฒด ํ์ ์ ์ ์ฅํ ์ ์๋ค. ๊ทธ๋ฐ๋ฐ ์๋ฐ์์ Object ํด๋์ค๋ ๊ฐ์ฅ ์ต์์ ์กฐ์ ํด๋์ค์ด๋ฏ๋ก ์ด๋ค ์ข ๋ฅ์ ๊ฐ์ฒด๋ ์ ์ฅํ ์ ์๋ค. ํ์ง๋ง int,
double๊ณผ ๊ฐ์ ์์ ํ์ ์ Object ํ์ ์ ์ ์ฅํ ์ ์๋ค. ๋ฐ๋ผ์ ์ด๋ฅผ ์ํด ์๋ฐ๋ Wrapper ํด๋์ค๋ฅผ ์ ๊ณตํ๋ค. Wrapper ํด๋์ค๋ ์์ ํ์ ์ ๊ฐ์ฒด์ฒ๋ผ ๋ค๋ฃฐ ์ ์๋๋ก ํด์ฃผ ๋ ํด๋์ค์ด๋ค. Object ๋ฐฐ์ด์ ๋ ๋ค๋ฅธ ๋ฌธ์ ์ ์ ๋ฐฐ์ด์ ๋์ง ๊ตฌ์กฐ ํน์ฑ์ ๋ณด์ฅํ์ง ๋ชปํ๋
- 32 -
๋ฌธ์ ์ ์ด ์๋ค. ์ฆ, ์ ์ฌ๋ผ์ด๋์์ ๋ณด์ฌ์ฃผ๋ ๋ฐ์ ๊ฐ์ด ๊ฐ ํญ์ ๋ค๋ฅธ ์ข ๋ฅ์ ๊ฐ์ฒด๋ฅผ ์ ์ฅ ํ ์ ์๋ค. ์ด๋ ๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ ๋งค์ฐ ๋ฐ๋์งํ์ง ์๋ค.
ArrayList โ ๊ณ์ ArrayList๋ ํด๋์ค์ด๋ฉฐ, ์๋ฐ๋ ์ฐ์ฐ์๋ฅผ ์ฌ์ ์ํ ์ ์์ผ๋ฏ๋ก ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ [ ] ์ฐ์ฐ์๋ฅผ ์ด์ฉํ์ฌ ์์๋ฅผ ์ ๊ทผํ ์ ์๋ค. ArrayList๋ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์์ธ์ ์ด์ฉํ์ฌ ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด๋ค์ ์ ๊ทผํ ์ ์๋ค. ์์ธ์ ์์์ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก 0์ด๋ค. add()์ get() ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค. void add(Object element): ๋งจ ๋์ ์์๋ฅผ ์ถ๊ฐํ๋ค. void add(int index, Object element): ์ฃผ์ด์ง ์์ธ ์์น์ ์์๋ฅผ ์ถ๊ฐํ๋ค. ์ด ๋ ์์ธ ์์น์ ์์๊ฐ ์ด๋ฏธ ์์ผ๋ฉด ๊ทธ ์์๋ถํฐ ๋ชจ๋ ์์๋ ์ค๋ฅธ์ชฝ์ผ๋ก ํ๋์ฉ ์ด๋๋๋ค. Object get(int index): ์์ธ ์์น์ ์๋ ์์๋ฅผ ๋ฐํํ๋ค. ๋ง์ฝ index๊ฐ ์ ํจํ ์์ธ(0โคindex<size())์ด ์๋๋ฉด IndexOutOfBoundsException์ ๋ฐ์ํ๋ค.
ArrayList๋ ์๋ฐ ์์ฒด์์ ์ ๊ณต๋๋ ๋ฐ์ดํฐ ํ์ ์ด ์๋๋ผ ์๋ฐ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณต ํ๋ ํด๋์ค์ด๋ค. ๋ํ ์๋ฐ๋ C++ ์ธ์ด์ ๋ฌ๋ฆฌ ์ฐ์ฐ์๋ฅผ ์ฌ์ ์ํ ์ ์์ผ๋ฏ๋ก [] ์ฐ์ฐ์ ๋ฅผ ์ด์ฉํ์ฌ ๊ฐ๋ณ ์์๋ฅผ ์ ๊ทผํ ์ ์๋ค. ๋์ ์ add, get์ ๊ฐ์ ๋ฉ์๋๋ฅผ ํตํด ๊ฐ๋ณ ์ ์์ ์ ๊ทผํ๋ค. ๊ทธ๋ฌ๋ ๋ฐฐ์ด๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์์ธ ์ ๋ณด๋ฅผ ์ด์ฉํ๋ฉฐ, ์์ธ์ ์ผ๋ฐ ๋ฐฐ์ด๊ณผ ๊ฐ์ด
0๋ถํฐ ์์ํ๋ค. ArrayList๋ ์ฝ์ ๋ ์์๋ค์ ์ผ์ชฝ๋ถํฐ ์ฐจ๋ก๋ก ์ ์ฅํ๋ค. ์ฆ, ์ค๊ฐ์ ๋น ํญ ์ด ์กด์ฌํ ์ ์๋ค. ๋ฐ๋ผ์ add ๋ฉ์๋๋ ๊ธฐ๋ณธ์ ์ผ๋ก ์ฃผ์ด์ง ์์๋ฅผ ๋งจ ๋์ ์ฝ์ ํ๋ค. ์ด ๊ฒ์ ๊ธฐ์กด์ ์ ์ฅ๋์ด ์๋ ์์๋ฅผ ๋์ฒดํ๋ ๋ฐฉ์์ด ์๋ ๊ฒฝ์ฐ์๋ ๋งจ ๋์ ์ฝ์ ํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ ๋ ดํ๊ธฐ ๋๋ฌธ์ด๋ค.
ArrayList โ ๊ณ์ ํญ์ ArrayList์ ์ค๋ฅธ์ชฝ์ ๋น์ด์๋ค. (์ผ์ชฝ์ ๋ ฌ ๋ฐฉ์) ์ค๊ฐ์ ๋น ์ฌ๋กฏ์ด ์์ ์ ์๋ค. ์๋ค Object set(int index, Object element): ์์ธ ์์น์ ์๋ ์์๋ฅผ ์ฃผ์ด์ง ๊ฐ์ฒด๋ก ๋์ฒดํ๋ค. ๋ํ ๊ฒฐ๊ณผ๋ก ์ด์ ์ ๊ทธ ์์น์ ์๋ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ค. ๋ง์ฝ index๊ฐ ์ ํจํ ์์ธ์ด ์๋๋ฉด IndexOutOfBoundsException์ ๋ฐ์ํ๋ค. Object remove(int index): ์์ธ ์์น์ ์๋ ์์๋ฅผ ์ญ์ ํ๊ณ , ๊ทธ ๋ค ์ ์๋ ๊ฐ์ฒด๋ค์ ํ๋์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋ํ๋ค. ๋ํ ๊ฒฐ๊ณผ๋ก ์ญ์ ํ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๋ค. ๋ง์ฝ index๊ฐ ์ ํจํ ์์ธ์ด ์๋๋ฉด IndexOutOfBoundsException์ ๋ฐ์ํ๋ค. void trimToSize(): ArrayList์ ์ฉ๋์ ํ์ฌ์ ํฌ๊ธฐ๋ก ์ถ์ํ๋ค.
add์ get ๋ฉ์๋ ์ธ์ ArrayList๋ set, remove์ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค. set์ ์ฃผ์ด์ง ์์ธ ์์น์ ์๋ ์์๋ฅผ ์ฃผ์ด์ง ์์๋ก ๋์ฒดํ๋ ๊ฒ์ด๊ณ , remove๋ ์ฃผ์ด์ง ์์น์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ค.
- 33 -
ArrayList โ ๊ณ์ add/remove ๋ฉ์๋ ์ฌ์ฉ์ ์ฃผ์์ add๋ ์ต์ ์ ๊ฒฝ์ฐ ํ์ฌ ์ ์ฅ๋์ด ์๋ ๋ชจ๋ ์์๋ฅผ ํ๋์ฉ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ค. ๋ฐ๋๋ก remove๋ ์ต์ ์ ๊ฒฝ์ฐ ํ์ฌ ์ ์ฅ๋์ด ์๋ ๋ชจ๋ ์์๋ฅผ ํ๋์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ค. ํ์ฌ ํฌ๊ธฐ๊ฐ ์ฉ๋๊ณผ ๊ฐ์ ๊ฒฝ์ฐ์๋ ํ์ฌ๋ณด๋ค ํฐ ์ฉ๋์ ๋ฐฐ์ด์ ์์ฑํ ๋ค์์ ๊ธฐ์กด ๋ฐฐ์ด์์ ์์๋ค์ ๋ณต์ฌํ๋ค. get ๋ฉ์๋ ์ฌ์ฉ์ ์ฃผ์์ ๋ฐํํ์ ์ด Object์ด๋ฏ๋ก ๋ฐํ๊ฐ์ ์ํ๋ ํ์ ์ผ๋ก ๊ฐ์ ๋ณํ ํด์ฃผ์ด์ผ ํ๋ค. ArrayList์ ์์ฑ์ ArrayList() : ์ฉ๋์ด 10์ธ ๋น ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ค. ArrayList(int capacity): ์ฃผ์ด์ง ์ธ์์ ํด๋นํ๋ ์ฉ๋์ ๋น ๋ฆฌ์คํธ๋ฅผ ์์ฑํ๋ค.
์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ArrayList๋ ์ค๊ฐ์ ๋น ํญ์ด ์กด์ฌํ ์ ์์ผ๋ฏ๋ก add ๋๋ remove ๋ฉ์๋๋ ์ต์ ์ ๊ฒฝ์ฐ ๊ธฐ์กด ์์๋ฅผ ๋ชจ๋ ํ๋์ฉ ์ผ์ชฝ ๋๋ ์ค๋ฅธ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ค. add ์ ๊ฒฝ์ฐ ๋งจ ์ฒซ ํญ์ ์ ์์๋ฅผ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ๊ฐ ์ต์ ์ ๊ฒฝ์ฐ์ด๊ณ , remove๋ ๋งจ ์ฒซ ํญ์ ์ ๋ ์์๋ฅผ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ๊ฐ ์ต์ ์ ๊ฒฝ์ฐ์ด๋ค. ๋ํ get, set, remove ๋ฉ์๋์ ๋ฐํ ํ์ ์ด
Object์ด๋ฏ๋ก ์ด ๋ฉ์๋๋ฅผ ํตํด ๋ฐ์ ๊ฐ์ฒด๋ ์๋์ ํ์ ์ผ๋ก ๊ฐ์ ๋ณํํ ํ์ ์ฌ์ฉํด์ผ ํ๋ค.
๋ฐ๋ณต์ ArrayList๋ ๋ฐ๋ณต์(iterator)๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ๋ฐ๋ณต์๋ ๊ตฌ์ฑ์์๋ฅผ ์ฐจ๋ก๋ก ๋ฐฉ๋ฌธํ ๋ ์ฌ์ฉํ๋ ๋๊ตฌ๋ฅผ ๋งํ๋ค. ๋ฐ๋ณต์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ค์ ๋ ์ฐ์ฐ์ ์ ๊ณตํ๋ค. boolean hasNext(): ๋ ์ด์์ ์์๊ฐ ์๋์ง ํ์ธํ ๋ ์ฌ์ฉ Object next(): ๋ค์ ์์๋ฅผ ์ป๊ธฐ ์ํด ์ฌ์ฉ ์2.23) void printVector(ArrayList list){ Iterator i = list.iterator(); while(i.hasNext()){ System.out.println(i.next()); } }
20/22 20/22
์ผ๋ฐ์ ์ผ๋ก ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ๋ณต์(iterator)๋ผ๋ ๋ฉ์๋ ๋๋ ๊ฐ์ฒด๋ฅผ ์ ๊ณตํ์ฌ ์ค๋ค. ๋ฐ๋ณต์๋ ์๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋์ด ์๋ ๋ชจ๋ ์์๋ฅผ ์ฐจ๋ก๋ก ๋ฐฉ๋ฌธํ ์ ์๋๋ก ํด์ค๋ค. ์ผ๋ฐ์ ์ผ๋ก ๋ฐ๋ณต ์ ๊ฐ์ฒด๋ hasNext(), next() ๋ ๊ฐ์ง ์ข ๋ฅ์ ๋ฉ์๋๋ฅผ ์ ๊ณตํ์ฌ ์ค๋ค. hasNext() ๋ฉ์๋๋ ๋ ์ด์ ๋ฐฉ๋ฌธํ ์์๊ฐ ์๋์ง ์๋์ง ๊ฒ์ฌํ๋ ๋ฉ์๋์ด๋ฉฐ, ์ด ๋ฉ์๋๊ฐ ์ฐธ์ ๋ฐํํ ๊ฒฝ์ฐ ์๋ next() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๋ค์ ์์๋ฅผ ์ป์ ์ ์๋ค. Iterator๋ java.util ํจํค์ง์ ์ ์ ๋์ด ์๋ ์ธํฐํ์ด์ค์ด๋ค.
- 34 -
๋จ์ ๋ฐฐ์ด vs. ArrayList ๋จ์ ๋ฐฐ์ด ๊ณต๊ฐ ๋ฌธ์ ๊ฐ ์ค์ํ์ง ์๋ ๊ฒฝ์ฐ ์คํ์๊ฐ์ด ์ค์ํ ๊ฒฝ์ฐ ์๊ตฌ๋๋ ๋ฐฐ์ด์ ์ฉ๋์ด ํ๋ก๊ทธ๋จ ์คํ๋ง๋ค ํฌ๊ฒ ๋ณํ์ง ์๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๋์ ๋ณํ์ง ์๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์๋ ์์์ ์์น๊ฐ ์ค์ํ ๊ฒฝ์ฐ
ArrayList ๊ณต๊ฐ ๋ฌธ์ ๊ฐ ์ค์ํ ๊ฒฝ์ฐ ์คํ์๊ฐ์ด ์ค์ํ์ง ์๋ ๊ฒฝ์ฐ ์๊ตฌ๋๋ ๋ฐฐ์ด์ ์ฉ๋์ด ํ๋ก๊ทธ๋จ ์คํ๋ง๋ค ํฌ๊ฒ ๋ณํ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ ๋์ ๊ทน๋จ์ ์ผ๋ก ๋ณํ๋ ๊ฒฝ์ฐ ๋ฐฐ์ด์ ์๋ ์์์ ์์น๊ฐ ์ค์ํ์ง ์๋ ๊ฒฝ์ฐ ์ญ์ /์ฝ์ ์ด ๋๋ถ๋ถ ๋์ ์ด๋ฃจ์ด์ง๋ ๊ฒฝ์ฐ
ArrayList๋ ์ผ๋ฐ ๋จ์ ๋ฐฐ์ด์ ๋นํด ์ฉ๋์ ์ ํ์ด ์๋ค๋ ์ฅ์ ์ด ์์ง๋ง ํ์ฌ ์ฉ๋์ด ๊ฝ ์ฐจ ์ฉ๋์ ๋๋ ค์ผ ํ ๊ฒฝ์ฐ์๋ ๋ง์ ๋น์ฉ์ด ๋ ๋ค. ๋ฐ๋ผ์ ํญ์ ๋ฐฐ์ด ๋์ ์ ArrayList๋ฅผ ์ฌ์ฉํ ๋ ๊ฒ์ ๋ฐ๋์งํ์ง ์๋ค. ์ฆ, ๊ณต๊ฐ ๋ฌธ์ ๊ฐ ์ค์ํ์ง ์์ผ๋ฉด ์ถฉ๋ถํ ๊ณต๊ฐ์ ๋จ์ ๋ฐฐ์ด๋ก ํ ๋ณดํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ํจ์จ๋ฉด์์ ArrayList๋ณด๋ค ์ข๋ค. ๋ํ ํ๋ก๊ทธ๋จ์ด ์คํ๋ ๋๋ง๋ค ์๊ตฌ ๋๋ ๋ฐฐ์ด์ ์ฉ๋์ด ๋ณํ์ง ์์ผ๋ฉด ArrayList๋ฅผ ์ฌ์ฉํ ํ์๊ฐ ์์ผ๋ฉฐ, ๋ง์ฐฌ๊ฐ์ง๋ก ํ๋ก๊ทธ๋จ ์ด ์คํ๋๋ ๋์์ ๋ฐฐ์ด์ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๊ฐ ๊ทน๋จ์ ์ผ๋ก ๋ณํ์ง ์์ผ๋ฉด ๋จ์ ๋ฐฐ์ด์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค.
Vector java.util ํจํค์ง์ ํฌํจ๋์ด ์์ผ๋ฉฐ, ArrayList์ ๊ทธ ๊ธฐ๋ฅ์ด ๋งค์ฐ ์ ์ฌํ๋ค. ๊ฐ์ฅ ์ค์ํ ์ฐจ์ด์ ์ Vector๋ ๋ค์ค์ฐ๋ ๋๋ฅผ ์ง์ํ๊ณ ArrayList๋ ์ง์ํ์ง ์๋๋ค. ๋ฐ๋ผ์ ๋ค์ค์ฐ๋ ๋ ํ๊ฒฝ์ด ์๋๋ฉด Vector ๋์ ์ ArrayList๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ArrayList์ ๋ฌ๋ฆฌ capacity() ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ํ์ฌ ์ฉ๋์ ์ป์ ์ ์๋ค. Vector์ ๋ ์ด์ ์์๋ฅผ ์ฝ์ ํ ๊ณต๊ฐ์ด ์์ผ๋ฉด ์ง์ ํด ๋์ ์ฉ๋๋งํผ ๋๋ ๊ธฐ๋ณธ ์ฆ๊ฐ ์ฉ๋๋งํผ ์๋์ผ๋ก ์ฆ๊ฐํ๋ค. ๊ธฐ๋ณธ ์ฆ๊ฐ ์ฉ๋์ ํ์ฌ ์ฉ๋์ ๋ ๋ฐฐ์ด๋ค. Vector() Vector(int capacity) ์ฆ๊ฐํ๋ ์ฉ๋์ ์ง์ ํ๊ณ ์ถ์ผ๋ฉด ๋ฒกํฐ๋ฅผ ์์ฑํ ๋ ํด์ผ ํ๋ค. Vector(int capacity, int increment)
Vector ํด๋์ค๋ java.util ํจํค์ง์์ ์ ๊ณตํ๋ ArrayList์ ์ ์ฌํ ํด๋์ค๋ก์, ์ด ํด๋์ค๋ ์๋ฐ์ ์ด๊ธฐ ๋ฒ์ ๋ถํฐ ์ ๊ณต๋ ํด๋์ค์ด๋ค. ์ด ํด๋์ค๋ ๋ํ ArrayList์ ๋ฌ๋ฆฌ ๋ค์ค์ฐ๋ ๋๋ฅผ ์ง์ํ๋ค. ๋ฟ๋ง ์๋๋ผ Vector๋ ํ์ฌ ์ฉ๋์ด ๊ฝ ์ฐผ์ ๋ ์ฆ๊ฐํ๋ ์ ์ฑ ์ ์ฌ์ฉ์๊ฐ ์ง์ ํ ์ ์๋ค.
- 35 -
์ 4์ฅ ์๋ฐ๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ ์ด ์ฅ์์๋ ์๋ฐ๋ฅผ ์ด์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋ ๊ณ ๋ คํด์ผ ํ๋ ์ฌ๋ฌ ๊ฐ์ง ๋ฌธ์ ์ ๊ณผ ๊ทธ๊ฒ์ ํด๊ฒฐ์ฑ ์ ์ดํด๋ณธ๋ค.
4.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์๋ฐ๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ Object ํด๋์ค equals ๋ฉ์๋ clone ๋ฉ์๋ Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ compareTo ๋ฉ์๋ ๋ณต์ฌ ๋ฐฉ์ vs. ์ฐธ์กฐ ๋ฐฉ์ clone ๋ฉ์๋ Listable ์ธํฐํ์ด์ค
4.2. ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ
๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ โ ๊ฐ์ (1) ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ ํน์ ํ ๋ฐ์ดํฐ ํ์ ๋ง ์ ์ฅํ ์ ์๋ ๊ตฌ์กฐ๊ฐ ์๋ ๋ชจ๋ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ ์๋ ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค. ์3.1) Point ๋ฐ์ดํฐ๋ง ์ ์ฅํ ์ ์๋ PointList ADT๋ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋๋ค. ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์๋ฐ์์ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋ค์ํ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ์ ์ฅํ ์ ์๋ ๋ฐ์ดํฐ ํ์ ์ด ํ์ํ๋ค. ์ด ๋ ๊ฐ์ฅ ์ฝ๊ฒ ์๊ฐํ ์ ์๋ ๊ฒ์ Object ํด๋์ค์ด๋ค. ํด๋์ค Object ํด๋์ค๋ ์๋ฐ์์ ๊ฐ์ฅ ์ต์์ ์กฐ์ ํด๋์ค์ด๋ฉฐ, ๋ช ๋ฐฑํ๊ฒ ๋ถ๋ชจ๋ฅผ ์ง์ ํ์ง ์์ ํด๋์ค์ ๋ถ๋ชจ๋ ํญ์ ์๋์ผ๋ก Object ํด๋์ค๊ฐ ๋๋ค. ๊ฐ์ฒด๋ ๊ทธ๊ฒ์ ์กฐ์ ํด๋์ค ํ์ ๋ณ์์ ๋์ ํ ์ ์๋ค. ๋ฐ๋ผ์ ๋ชจ๋ ๊ฐ์ฒด๋ Object ํ์ ์ ๋ณ์์ ์ ์ฅํ ์ ์๋ค.
๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ ํน์ ํ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ง์ ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉ๋๋ ๊ตฌ์กฐ๊ฐ ์๋๋ผ ๋ค์ํ ์ข ๋ฅ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉํ ์ ์๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค. 2์ฅ์์ ์ดํด๋ณธ
ArrayList ํด๋์ค๋ ์๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณตํ๋ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ด์ง๋ง ์ค์ต 3์์ ๊ตฌํํ
- 37 -
Point ๋ฐ์ดํฐ๋ง ์ ์ฅํ ์ ์๋ PointList ADT๋ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๊ฐ ์๋๋ค. ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋ค์ํ ๋ฐ์ดํฐ ํ์ ์ ์ ์ฅํ ์ ์๋ ๋ฐฉ๋ฒ์ด ํ์ํ๋ค. ์๋ฐ์์ ๊ฐ์ฅ ์ฝ๊ฒ ์๊ฐํ ์ ์๋ ๊ฒ์ Object ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์๋ฐ์์๋ ๋ช ๋ฐฑํ๊ฒ ๋ถ๋ชจ ํด ๋์ค๋ฅผ ์ง์ ํ์ง ์์ผ๋ฉด Object ํด๋์ค๊ฐ ๋ถ๋ชจ ํด๋์ค๊ฐ ๋๋ค. ๋ฐ๋ผ์ Object ํด๋์ค๋ ์ ๋ฐ์์ ๊ฐ์ฅ ์ต์์ ์กฐ์ ํด๋์ค์ด๋ค. ์ด ๋๋ฌธ์ ์ด ํ์ ์ ๋ณ์์๋ ์ด๋ค ํ์ ์ ๊ฐ์ฒด๋ ์ ์ฅํ ์ ์๋ค.
๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ โ ๊ฐ์ (2) Object ํ์ ์ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ๊ตฌํ์ ๋ฌธ์ ์ ๋ฌธ์ ์ 1. ์์ํ์ ์ Object ํ์ ์ ์ ์ฅํ ์ ์๋ค. ํด๊ฒฐ์ฑ . ํด๊ฒฐ์ฑ . Wrapper ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค. ๋ฌธ์ ์ 2. ์๋ฃ๊ตฌ์กฐ๋ง๋ค ๊ทธ ์๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋๋ ์์๊ฐ ๋ฐ๋์ ์ ๊ณตํด์ผ ํ๋ ๋ฉ์๋๊ฐ ์์ ์ ์๋ค. ์3.2) ์ ๋ ฌ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ ์ ์ฅ๋๋ ๋ ์์์ ์์๋ฅผ ๋น๊ตํ๋ ๋ฉ์๋๊ฐ ํ์ํจ. ์3.3) ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค ๋ ๋ณต์ฌ ๋ฐฉ์ ๋๋ ์ฐธ์กฐ ๋ฐฉ์ ๋ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์ฌ์ฉํ์ฌ ๊ตฌํํ ์ ์๋ค. ์ด ๋ ๋ณต์ฌ ๋ฐฉ์์ ์ฌ์ฉํ๋ฉด ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ ๋ฉ์๋๊ฐ ํ์ํจ Object ํ์ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๊ฐ์ ํ์ ๋ณํ์ ํ์ง ์์ผ๋ฉด ์ด ํด๋์ค์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ง ํธ์ถํ ์ ์๋ค. Object ํ์ ์ ํ์ํ ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ง ์์ ์ ์๋ค.
์๋ฐ์์ Object ํ์ ์ ์ด์ฉํ์ฌ ๊ตฌํํ ๊ฒฝ์ฐ์๋ ๋ช ๊ฐ์ง ๋ฌธ์ ์ ์ด ์๋ค. ์ฒซ์งธ, ์์ํ์ ์ Object ํ์ ์ ๋ณ์์ ์ ์ฅํ ์ ์๋ค. ์ฆ, Object ํ์ ๋ณ์์ Rectangle, Student๊ณผ ๊ฐ ์ ํด๋์ค ํ์ ์ ๊ฐ์ฒด๋ค์ ์ ์ฅํ ์ ์์ง๋ง int, double๊ณผ ๊ฐ์ ์์ํ์ ์ ์ ์ฅํ ์ ์ ๋ค. ๋ฒ๊ฑฐ๋กญ์ง๋ง ์ด ๋ฌธ์ ์ ์ Wrapper ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ํด๊ฒฐํ ์ ์๋ค. ๋์งธ, ์๋ฃ๊ตฌ์กฐ๋ง ๋ค ๊ทธ ์๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋๋ ์์๊ฐ ๋ฐ๋์ ์ ๊ณตํด์ผ ํ๋ ๋ฉ์๋๊ฐ ์์ ์ ์๋ค. ์๋ฅผ ๋ค ์ด ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ์ ์ฅ๋๋ ์์๋ค์ด ์ ๋ ฌ๋ ์ํ๋ก ์ ์ฅ๋์ด์ผ ํ๋ค. ์ด๋ฅผ ์ํด ์๋ ๋ ์์์ ์์๋ฅผ ๋น๊ตํ๋ ๋ฉ์๋๊ฐ ํ์ํ๋ค. ๊ทธ๋ฐ๋ฐ ์๋ฐ์์๋ ํ ํ์ ์ ๋ณ์๋ฅผ ํตํด์๋ ๊ทธ ํ์ ์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ง ํธ์ถํ ์ ์๋ค. ์ฆ, Object ํ์ ์ ๋ณ์์ด๋ฉด
Object ํด๋์ค์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ง ํธ์ถํ ์ ์๋ค. ๋ฐ๋ผ์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ธฐ ์ ํด Object ํด๋์ค์ ์ ์๋์ด ์์ง ์์ ๋ฉ์๋๊ฐ ํ์ํ๋ฉด ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ธฐ๊ฐ ์ด๋ ต ๋ค. ์ด ์ฅ์์๋ ์ด๋ฐ ์ํฉ์ ์ด๋ป๊ฒ ํด๊ฒฐํ ์ ์๋์ง ๊ทธ ๋ฐฉ๋ฒ์ ์ค๋ช ํ๋ค.
- 38 -
4.3. Object ํด๋์ค
Object ํด๋์ค ์๋ฐ์์ ๋ค๋ฅธ ํด๋์ค๋ฅผ ๋ช ๋ฐฑํ๊ฒ ์์๋ฐ์ง ์๋ ๊ฒฝ์ฐ์๋ ์๋์ผ๋ก Object ํด๋์ค๋ฅผ ์์๋ฐ๋๋ค. ์ด ํด๋์ค๋ ์์ ๊ณ์ธต๊ตฌ์กฐ ์์์ ๊ฐ์ฅ ์ต์์ ์กฐ์ ํด๋์ค์ด๋ค. Object ํด๋์ค๋ toString, equals, clone๊ณผ ๊ฐ์ ์ ์ฉํ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค. ์ด ์ค ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค ๋ ๋ง์ด ์ฌ์ฉ๋๋ ๋ฉ์๋๋ equals์ clone์ด๋ค. equals ๋ฉ์๋๋ ๋ ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๊ฐ ๊ฐ์์ง ๋น๊ตํ ๋ ์ฌ์ฉ๋๋ค. clone ๋ฉ์๋๋ ์ํ๊ฐ ๊ฐ์ ๋ค๋ฅธ ๊ฐ์ฒด๋ฅผ ์์ฑํ ๋ ์ฌ์ฉ๋๋ค. ๋ ๋ฉ์๋๋ฅผ ์ฌ์ ์(override)ํ์ง ์์ผ๋ฉด Object ํด๋์ค์ ์ ์๋์ด ์๋ ๋ฉ์๋๊ฐ ํธ์ถ๋๋ค.
์๋ฐ์์ Object ํด๋์ค๋ ์์ ๊ณ์ธต๊ตฌ์กฐ ์์์ ๊ฐ์ฅ ์ต์์ ์กฐ์ ํด๋์ค์ด๋ค. ์ด๋ค ํด๋ ์ค๋ฅผ ์ ์ํ ๋ ๋ช ๋ฐฑํ๊ฒ ๊ทธ๊ฒ์ ๋ถ๋ชจ ํด๋์ค๋ฅผ ์ง์ ํ์ง ์์ผ๋ฉด ์๋์ผ๋ก Object ํด๋์ค๊ฐ ๊ทธ๊ฒ์ ๋ถ๋ชจ ํด๋์ค๊ฐ ๋๋ค. Object ํด๋์ค๋ toString, equals, clone์ ๊ฐ์ ์ ์ฉํ ๋ฉ์๋ ๋ฅผ ์ ๊ณตํ๋ค. ์ด ์ค์ equals์ clone์ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋ ๋๋ฆฌ ์ฌ์ฉ๋๋ค. equals ๋ฉ์๋๋ ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๊ฐ ๊ฐ์์ง ๋น๊ตํ๋ ๋ฉ์๋์ด๊ณ , clone์ ๋ด๋ถ ์ํ๊ฐ ๊ฐ์ ๊ฐ์ฒด ๋ฅผ ๋ณต์ ํ ๋ ์ฌ์ฉ๋๋ ๋ฉ์๋์ด๋ค. ๋ ๋ฉ์๋๋ฅผ ์ฌ์ ์(override)ํ์ง ์์ผ๋ฉด Object ํด๋์ค ์ ์ ์๋์ด ์๋ ๋ฉ์๋๊ฐ ํธ์ถ๋๋๋ฐ, Object ํด๋์ค์ ์ ์๋์ด ์๋ ์ด๋ค ๋ฉ์๋๋ ๋ณด ํต ์ฐ๋ฆฌ๊ฐ ์ํ๋ ํจ๊ณผ๋ฅผ ์ ๊ณตํ์ง ๋ชปํ๋ค.
equals ๋ฉ์๋ Object์ equals ๋ฉ์๋์ ๋ฌธ์ ์ Object ํด๋์ค์ ์ ์๋์ด ์๋ equals ๋ฉ์๋: ๋ ๊ฐ์ฒด ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋์ง ๊ฒ์ฌํ๋ค. ์ฐ๋ฆฌ๊ฐ ์ํ๋ equals์ ํจ๊ณผ๋ ๋ ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๋ฅผ ๋น๊ตํ๋ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ Object์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๋ ์ฐ๋ฆฌ๊ฐ ๋ณดํต ์ํ๋ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค. ๋ฐ๋ผ์ ํด๋์ค๋ฅผ ๋ง๋ค ๋ ๋ณดํต ๊ธฐ๋ณธ์ ์ผ๋ก ์ด ๋ฉ์๋๋ ์ฌ์ ์ํด์ผ ํ๋ค.
equals ๋ฉ์๋๋ ๋ ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๊ฐ ๊ฐ์์ง ๋น๊ตํ๋ ๋ฉ์๋์ด์ง๋ง Object์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๋ ๋ ๊ฐ์ฒด ๋ณ์๊ฐ ๊ฐ์ ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋์ง ๊ฒ์ฌํ๋ฏ๋ก ์ฐ๋ฆฌ๊ฐ ์ ํ๋ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค. ๋ฐ๋ผ์ ์ ํด๋์ค๋ฅผ ์ ์ํ ๋์๋ ๊ธฐ๋ณธ์ ์ผ๋ก equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํด์ผ ํ๋ค.
- 39 -
clone ๋ฉ์๋ Object์ clone ๋ฉ์๋์ ๋ฌธ์ ์ Object ํด๋์ค์ ์ ์๋์ด ์๋ clone ๋ฉ์๋: ์ด ๋ฉ์๋๋ ๊ฐ์ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์๋์ผ๋ก ์์ฑํ๊ณ ์ธ์คํด์ค ํ๋์ ๊ฐ์ ์๋์ผ๋ก ๋ณต์ฌํ๋ค. (shallow copy) ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์ ์ค ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์3.4) public class logbook{ private int logMonth; private int logYear; private int entry = new int[31]; โฆ }
logMonth
logMonth
logYear
logYear
entry
entry
equals ๋ฉ์๋์ ๋ง์ฐฌ๊ฐ์ง๋ก Object์ clone ๋ฉ์๋๋ ์ฌ์ ์ํ์ฌ ์ฌ์ฉํ์ง ์์ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. Object์ clone ๋ฉ์๋๋ ๊ฐ์ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์๋์ผ๋ก ์์ฑํ๊ณ ์ธ์คํด์ค ํ๋์ ๊ฐ์ ๊ธฐ๊ณ์ ์ผ๋ก ๋ณต์ฌํ์ฌ ๊ฐ์ฒด๋ฅผ ๋ณต์ ํ๋ค. ์ด๋ฐ ๋ณต์ ๋ฅผ shallow copy๋ผ ํ๋ค. ๋ฐ๋ผ ์ ํด๋์ค์ ๋ฉค๋ฒ๋ณ์ ์ค ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ๋ณต์ ํ ํ์ ๋ ๊ฐ์ฒด์ ๋ฉค๋ฒ๋ณ์๊ฐ ๋์ผํ ๊ฒ ์ ์ฐธ์กฐํ๊ฒ ๋๋ ๋ฌธ์ ์ ์ด ๋ฐ์ํ ์ ์๋ค.
boolean equals(Object other) equals ๋ฉ์๋์ ๊ตฌํ ์ฌ์ ์กฐ๊ฑด: ์ฌ์ ์กฐ๊ฑด ๋น๊ตํ๊ณ ์ ํ๋ ๊ฐ์ฒด๊ฐ null์ด ์๋์ด์ผ ํ๋ฉฐ, ๊ฐ์ ํด๋์ค์ ์ธ์คํด์ค์ด์ด์ผ ํ๋ค. ์ฌํ์กฐ๊ฑด: ์ฌํ์กฐ๊ฑด ๊ฐ์ฒด์ ๋ด๋ถ ์ํ๋ฅผ ๋น๊ตํ์ฌ ๋ด๋ถ ์ํ๊ฐ ๊ฐ์ ๊ฒฝ์ฐ์๋ true๋ฅผ ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค. ๊ฐ์ ํด๋์ค์ ์ธ์คํด์ค์ธ๊ฐ๋ฅผ ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ instanceof ์ฐ์ฐ์: ๊ฐ๋ฅํ์ง๋ง ํ์ ํด๋์ค๋ ์ด ์ฐ์ฐ์๋ฅผ ์ด์ฉํ ๊ฒ์ฌ์์ ํต๊ณผํ๋ฏ๋ก ์ด ๊ฒฝ์ฐ์๋ ์ฌ์ฉํ ์ ์๋ค. Object ํด๋์ค์ Class getClass() ๋ฉ์๋ ์ฌ์ฉ ์ถ๊ฐ์ ๊ณ ๋ ค์ฌํญ ๋์ผ ๊ฐ์ฒด์ธ์ง ๊ฒ์ฌํ๋ค. ร if(this==other) return true; ์ธ์์ ํ์ ์ด Object์ด๋ฏ๋ก ๊ฐ์ ํ์ ๋ณํ์ ํ ๋ค์์ ๊ฐ ๋ฉค๋ฒ๋ณ์๋ฅผ ๋น๊ตํด์ผ ํ๋ค.
Object์ equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ ๋ ๊ณ ๋ คํด์ผ ํ๋ ์ฌํญ์ ๋ค์๊ณผ ๊ฐ๋ค. ์ฒซ์งธ, ๋น๊ตํ๊ณ ์ ํ๋ ๊ฐ์ฒด๊ฐ ๊ฐ์ ํด๋์ค์ ์ธ์คํด์ค์ด์ด์ผ ํ๋ค. ๋ณดํต ์๋ฐ์์ ๊ฐ์ฒด๊ฐ ์ด๋ค ํน์ ํ์ ์ธ์ง ๊ฒ์ฌํ ๋์๋ instanceof ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ค. ํ์ง๋ง instanceof ์ฐ์ฐ์๋ ํ์ ํด๋์ค ๋ ์ด ๊ฒ์ฌ์ ํต๊ณผํ๊ฒ ๋๋ฏ๋ก equals ๋ฉ์๋๋ฅผ ๊ตฌํํ ๋์๋ ์ฌ์ฉํ ์ ์๋ค. ์ด๋ฅผ ์ํด ์ด ์ฐ์ฐ์ ๋์ ์ Class ํด๋์ค์ ์ ์๋์ด ์๋ getClass ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. ๋์งธ, ๋์ผ ๊ฐ์ฒด๊ฐ ๋ฉ์๋์ ์ธ์๋ก ์ ๋ฌ๋ ์ ์๋ค. ์ ์งธ, ์ธ์์ ํ์ ์ด Object์ด๋ฏ๋ก ๋ฐ์ ์ธ์๋ฅผ ๊ฐ ์ ํ์ ๋ณํํ ํ์ ๋ด๋ถ ๋ฉค๋ฒ๋ณ์๋ค์ ์ํ๋ฅผ ๋น๊ตํด์ผ ํ๋ค.
- 40 -
boolean equals(Object other) โ ๊ณ์ ์3.5) public class Date{ private int year; private int month; private int day; โฆ public boolean equals(Object other){ if(other==null||getClass() != other.getClass()) return false; if(this == other) return true; Date o = (Date)other; public class MyDate extends Date{ return year==o.year&& private int val; month==o.month&& โฆ day==o.day; public boolean equals(Object other){ } if(!super.equals(other)) return false; โฆ MyDate o = (MyDate)other; } return val == o.val; } ์๋ธ ํด๋์ค์ ๊ฒฝ์ฐ
Date๋ผ๋ ํด๋์ค์ ๋ํด equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ์ฌ ๋ณด์. ์ฐ์ ๋น๊ตํ๊ณ ์ ํ๋ ๊ฐ์ฒด๊ฐ null์ด ์๋์ด์ผ ํ๋ฉฐ, ๊ฐ์ฒด๊ฐ ์ ํํ๊ฒ Date ํด๋์ค์ ์ธ์คํด์ค์ด์ด์ผ ํ๋ค. ์ฆ, Date์ ํ ์ ํด๋์ค์ ํด๋น๋๋ ๊ฐ์ฒด์๋ ๋น๊ตํ ์ ์๋ค. ๋น๊ตํ๊ณ ์ ํ๋ ๊ฐ์ฒด๊ฐ null์ด ์๋๊ณ
Date ํด๋์ค์ ์ธ์คํด์ค์ด๋ฉด ์ฃผ์ด์ง ๊ฐ์ฒด๊ฐ ํ์ฌ ๊ฐ์ฒด์ ๊ฐ์ ๊ฐ์ฒด์ธ์ง ๋จผ์ ๊ฒ์ฌํ๋ค. ์ด ๋ฐ ๊ฒ์ฌ๊ฐ ๋๋๋ฉด ์ฃผ์ด์ง ๊ฐ์ฒด๋ฅผ Date ๊ฐ์ฒด๋ก ๋ณํํ ๋ค์์ Date์ ๊ฐ ๋ฉค๋ฒ๋ณ์๋ค์ ๊ฐ์ด ๊ฐ์์ง ๋น๊ตํ๋ค. ๋ถ๋ชจ ํด๋์ค์ ์ด๋ฏธ equals ๋ฉ์๋๊ฐ ์ ์๋์ด ์๋ ๊ฒฝ์ฐ์๋ ์ฐ์ ๋ถ๋ชจ ํด๋์ค์ equals ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ๋น๊ตํ๊ณ , ์ด ๋น๊ต์ ์ฑ๊ณตํ๋ฉด ํ์ฌ ํด๋์ค์ ์ถ๊ฐ๋ก ์ ์๋์ด ์๋ ๋ฉค๋ฒ๋ณ์๋ค์ ์ํ๋ฅผ ๋น๊ตํ๋ค.
Object clone() Object ํด๋์ค์ clone ๋ฉ์๋๋ ๊ฐ์ฒด์ ๋ฉค๋ฒ ๋ณ์ ์ค์ ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ๋ฐ๋ผ์ ์ด ๋ฉ์๋๋ protected๋ก ์ ์ธ๋์ด ์๋ค. ์ฆ, ์ฌ์ ์ํ์ง ์์ผ๋ฉด ํธ์ถํ ์ ์๋ค. clone์ ์ฌ์ ์ํ๋ ๊ฒฝ์ฐ์๋ Cloneable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค.
๋ฉค๋ฒ๋ณ์ ์ค ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ๊ทธ ๋ณ์๋ง๋ค ๊ทธ ๋ณ์์ clone์ ํธ์ถํ๋ค.
public class Customer implements Cloneable{ private String name; private BankAccount account; โฆ public Object clone(){ try{ Customer cloned = (Customer)super.clone(); cloned.account = (BankAccount)account.clone(); return cloned; } catch(CloneNotSupportedException e){ return null; } } }
์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด Object์ clone ๋ฉ์๋๋ shallow copy ๋ฐฉ์์ ๋ณต์ ๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด์ ๋ฉค๋ฒ ๋ณ์ ์ค์ ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ์ฌ๊ฐํ ๋ฌธ์ ๋ฅผ ์ด๋ํ ์ ์๋ค. ์ด๋ฐ ์ด์ ๋๋ฌธ ์ Object์ clone ๋ฉ์๋๋ protected ๋ฉค๋ฒ๋ก ์ ์ธ๋์ด ์๋ค. ๋ฐ๋ผ์ ํ์ ํด๋์ค์์
clone ๋ฉ์๋๋ฅผ public ๋ฉค๋ฒ๋ก ์ฌ์ ์ํ์ง ์์ผ๋ฉด ๊ฐ์ฒด ํธ๋ค์ ์ด์ฉํ์ฌ ์ง์ ํธ์ถํ ์ ์ ๋ค. clone์ ์ฌ์ ์ํ๋ ๊ฒฝ์ฐ์๋ Cloneable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ค๊ณ ํ๊ธฐํ์ฌ, ์ด ์ฌ์ค์
- 41 -
์ธ๋ถ ์ฌ์ฉ์์๊ฒ ์๋ ค์ฃผ์ด์ผ ํ๋ค. clone ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๋ ๋ฐฉ๋ฒ์ ๋ค์๊ณผ ๊ฐ๋ค. ์ฐ์ ๋ถ ๋ชจ ํด๋์ค์ clone์ ํธ์ถํ์ฌ ์ด๊ธฐ ๋ณต์ ๋ฅผ ํ๋ค. ๊ทธ ๋ค์์ ์ฐธ์กฐ ํ์ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋๋ ๋ถ๋ถ์ shallow copy๊ฐ ๋์ง ์๋๋ก ์ถ๊ฐ๋ก ๋ณต์ ํ๋ค.
protected package pack1; class A{ private int a; public A(int val){ a = val; } protected void f(){ System.out.println(โHa Ha!!!โ); } } class B extends A{ private int b; public B(int val){ super(val); b = val; } public void g(){ f(); } public void test(){ a = 10; // error } }
package pack2; class C{ private int c; public void test(){ A o1 = new A(10); o1.a = 20; // error o1.f(); // error B o2 = new B(20); o2.g(); // ok } } ์์ํ ํด๋์ค๊ฐ ์๋ ๊ด๋ จ์ด ์๋ ๋ค๋ฅธ ํจํค์ง์ ์๋ ํด๋์ค์ ๊ฒฝ์ฐ์๋ protected๋ private๊ณผ ๊ทธ ํจ๊ณผ๊ฐ ๊ฐ๋ค.
clone์ด Object์ protected ๋ฉค๋ฒ์ด๋ฏ๋ก ์๋ฐ์์ธ ์ ๊ณตํ๋ ์ ๊ทผ ์ง์์์ ๋ํด ๋ณต์ตํ์ฌ ๋ณด ์. ์๋ฐ๋ public, private, protected, default ๋ค ๊ฐ์ง ์ข ๋ฅ์ ์ ๊ทผ ์ง์์๋ฅผ ์ ๊ณตํ๋ฉฐ, ํจํค ์ง ๊ฐ๋ ์ ๋๋ฌธ์ ์ด๋ค์ ๋ํ ๊ฐ๋ ์ด ๋ค๋ฅธ ์ธ์ด์ ๋นํด ๋ณต์กํ๋ค. ์ด ์ค์ protected๋ ์ ์๊ณผ ๋ฐ์ ํ ๊ด๋ จ์ด ์๋ค. ์ ์์์ B๋ A๋ฅผ ์์ํ๊ณ ์์ผ๋ฏ๋ก B๋ ๊ทธ๊ฒ์ ๋ฉ์๋์์ A ์ protected ๋ฉค๋ฒ์ธ f()๋ฅผ ์ ๊ทผํ ์ ์๋ค. ์ฆ, ์์ ํด๋์ค ๋ด์์๋ ๋ถ๋ชจ ํด๋์ค์
protected ๋ฉค๋ฒ๋ฅผ public ๋ฉค๋ฒ์ฒ๋ผ ์ ๊ทผํ ์ ์๋ค. ๊ทธ๋ฌ๋ C๋ A๋ฅผ ์์ํ๊ณ ์์ง๋ ์์ผ ๋ฉฐ, A ๋๋ B์ ๊ฐ์ ํจํค์ง ๋ด์ ํฌํจ๋์ด ์์ง ์์ผ๋ฏ๋ก C ๋ฉ์๋ ๋ด์์๋ A์
protected ๋ฉค๋ฒ์ธ f()๋ private ๋ฉค๋ฒ์ฒ๋ผ ๊ฐ์ฃผ๋๋ฏ๋ก A๋ B์ ๊ฐ์ฒด ํธ๋ค์ ์ด์ฉํ์ฌ f() ๋ฉ์ ๋๋ฅผ ์ ๊ทผํ ์ ์๋ค.
- 42 -
4.4. Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ
Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ์์๋ค์ ์ด๋ค ๊ธฐ์ค์ ์ํด ์ ๋ ฌํ์ง ์์ ์ํ๋ก ์ ์งํ๋ ์๋ฃ๊ตฌ์กฐ์ ๊ฒฝ์ฐ์๋ ์ฝ์ ์ ๋น๊ต์ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ผ๋, ์ญ์ ๋ ๋ด๋ถ์ ์ผ๋ก ์์๋ค์ด ์ด๋ป๊ฒ ์ ์ฅ๋์ด ์๋์ง์ ๋ฌด๊ดํ๊ฒ ํญ์ ์ญ์ ํ๊ณ ์ ํ๋ ์์๊ฐ ํ์ฌ ๊ตฌ์กฐ ๋ด์ ์๋์ง ๊ฒ์ฌํด์ผ ํ๋ค. Object ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋์ ๋ด๋ถ ์๋ฃ๊ตฌ์กฐ ๋ฟ๋ง ์๋๋ผ ์ธ์๋ก ์ ๋ฌ๋๋ ๊ฐ์ฒด๋ฅผ ๋ฐ๊ธฐ ์ํด Object ํ์ ์ ํ๋ผ๋ฏธํฐ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค. Object ํด๋์ค์ equals ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ผ๋ฏ๋ก ์ด ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ญ์ ํ๊ณ ์ ํ๋ ์์๊ฐ ์๋์ง ๊ฒ์ฌํ ์ ์๋ค. ์ฃผ์. ์ฃผ์. Object ํ์ ์ ๋ณ์์ ์ค์ ๋ก ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด์ equals ๋ฉ์๋๊ฐ ์ฌ์ ์๋์ด ์์ง ์์ผ๋ฉด ์ฐ๋ฆฌ๊ฐ ์ํ๋ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
์๋ฃ๊ตฌ์กฐ์ ์ ์ฅํ๋ ์์๋ค์ด ์ด๋ค ๊ธฐ์ค์ ์ํด ์ ๋ ฌ๋ ์ํ๋ก ์ ์ง๋ ํ์๊ฐ ์์ผ๋ฉด ์ฝ์ ์ฐ์ฐ์ ๋น๊ต์ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค. ํ์ง๋ง ์ญ์ ๋ ์ฝ์ ๊ณผ ๋ฌ๋ฆฌ ์์๋ค์ด ์ด๋ป๊ฒ ์ ์ง๋๊ณ ์๋์ง์ ์๊ด์์ด ์ญ์ ํ๊ณ ์ ํ๋ ์์๊ฐ ์๋ฃ๊ตฌ์กฐ ๋ด์ ์๋์ง ํญ์ ๊ฒ์ฌํด์ผ ํ๋ฏ๋ก ์ ๋์ ์ผ๋ก ๊ตฌํํ๊ธฐ๊ฐ ์ด๋ ต๋ค. Object ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๋ ๊ฒฝ์ฐ์ ๋ ๋ณดํต ๋ด๋ถ ์๋ฃ๊ตฌ์กฐ ๋ฟ๋ง ์๋๋ผ ๊ฐ ๋ฉ์๋์์ ๊ฐ์ฒด๋ฅผ ์ ๋ฌ๋ฐ์์ผ ํ๋ ๊ฒฝ์ฐ์๋
Object ํ์ ์ ํ๋ผ๋ฏธํฐ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ค. Object ํด๋์ค์๋ equals ๋ฉ์๋๊ฐ ์ ์๋์ด ์ ์ผ๋ฏ๋ก ์ด ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ์ฐพ๊ณ ์ํ๋ ์์๊ฐ ์๋์ง ๊ฒ์ฌํ ์ ์๋ค. ๋ฌผ๋ก ์ด ๋
Object ํ์ ์ ๋ณ์์ ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด๊ฐ equals ๋ฉ์๋๋ฅผ ์ฌ์ ์ํ๊ณ ์์ง ์์ผ๋ฉด ์ฐ๋ฆฌ ๊ฐ ์ํ๋ ํจ๊ณผ๋ฅผ ์ป์ ์ ์๋ค.
Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ์3.6) public class UnsortedList{ Object[] list; int size = 0; public UnsortedList(int capacity){ list = new Object[capacity]; } public boolean delete(Object item){ for(int i=0; i<size; i++){ if(item.equals(list[i])){ โฆ } } } โฆ }
์๋ฐ์ late binding ๊ธฐ๋ฅ ๋๋ฌธ์ ์ด ๊ฒฝ์ฐ Object์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๊ฐ ์๋๋ผ item์ด ์ฐธ์กฐํ๊ณ ์๋ ๊ฐ์ฒด์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๊ฐ ์คํ๋๋ค.
์ด ์ฌ๋ผ์ด๋์ ์์์ delete ์ฐ์ฐ์ ์ธ์ ํ์ ์ Object์ด๋ฉฐ, ๋ด๋ถ์ ์ผ๋ก ์ด ์ธ์์ equals ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ์ญ์ ํ๊ณ ์ ํ๋ ๊ฐ์ฒด๊ฐ ๊ตฌ์กฐ ๋ด์ ์กด์ฌํ๋์ง ๊ฒ์ฌํ๊ณ ์๋ค. ๊ทธ๋ฌ๋ ์ค์ ์ธ์๋ก ๋ฐ๊ฒ ๋๋ ๊ฐ์ฒด๋ Object๊ฐ ์๋ ๋ค๋ฅธ ํ์ ์ผ ๊ฒ์ด๋ค. ๋ฐ๋ผ์ ์๋ฐ์ late
- 43 -
binding ํน์ฑ ๋๋ฌธ์ Object ํด๋์ค์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๊ฐ ์๋๋ผ ์ค์ item์ด ์ฐธ์กฐํ๋ ๊ฐ์ฒด์ ์ ์๋์ด ์๋ equals ๋ฉ์๋๊ฐ ํธ์ถ๋๋ค.
Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ์์๋ค์ ์ด๋ค ๊ธฐ์ค์ ์ํด ์ ๋ ฌ๋ ์ํ๋ก ์ ์งํ๋ ์๋ฃ ๊ตฌ์กฐ์ ๊ฒฝ์ฐ์๋ ์ฝ์ ํ ๋ ๊ธฐ์กด ์์๋ค๊ณผ ๋น๊ตํ์ฌ ์ฝ์ ์์น๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค. ์ด๋ฐ ๋น๊ต๋ ์๋ฐ์์๋ ๋ณดํต compareTo ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค. Object ํ์ ์ ์ด์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ณ ์ ํ ๊ฒฝ์ฐ์๋ Object ํด๋์ค์๋ compareTo ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ง ์์ผ๋ฏ๋ก ์3.6์ฒ๋ผ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค. Object ํ์ ๋ณ์์ ์ ์ฅ๋์ด ์๋ ๊ฐ์ฒด์ compareTo ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ด๋ Object ํ์ ๋ณ์๋ฅผ ํตํด์๋ compareTo ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋ค. ๊ฐ์ ํ์ ๋ณํ์ ํ์ฌ ํธ์ถํ ์ ์์ง๋ง ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ๊ตฌํ์์๋ ์ด๋ค ํ์ ์ ๊ฐ์ฒด๊ฐ ๋ณ์์ ์ ์ฅ๋ ์ง ๋ชจ๋ฅด๊ธฐ ๋๋ฌธ์ ๊ฐ๋ฅํ์ง ์๋ค.
์๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋๋ ์์๋ค์ด ์ด๋ค ๊ธฐ์ค์ ์ํด ์ ๋ ฌ๋ ์ํ๋ก ์ ์ง๋๋ ๊ฒฝ์ฐ์๋ ์ฝ์ ํ ๋ ๊ธฐ์กด ์์๋ค๊ณผ ๋น๊ตํ์ฌ ์ฝ์ ์์น๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค. ์๋ฐ์์๋ ๋ณดํต compareTo ๋ฉ์ ๋๋ฅผ ์ด์ฉํ์ฌ ์ด๋ฐ ๋น๊ต๋ฅผ ํ๋ค. ๋ง์ฝ Object ํ์ ์ ์ด์ฉํ์ฌ ์ด๋ฐ ํํ์ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ๋ฅผ ๊ตฌํํ๋ค๋ฉด Object ํด๋์ค์๋ compareTo ๋ฉ์๋๊ฐ ์ ์๋์ด ์์ง ์์ผ๋ฏ๋ก ์์ ์ดํด ๋ณธ ์ 3.6๊ณผ ๋ฌ๋ฆฌ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค. ๊ฐ์ ํ์ ๋ณํํ์ฌ compareTo ๋ฉ์๋๋ฅผ ํธ์ถํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํด ๋ณผ ์ ์์ง๋ง ์ด๋ค ํ์ ์ ๊ฐ์ฒด๊ฐ ์ ์ฅ๋ ์ง ์ ์ ์์ผ๋ฏ๋ก ์ด๊ฒ์ ๊ฐ๋ฅํ์ง ์๋ค.
Object ํด๋์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ์3.7)
public class Test{ public static void main(String[] args){ public class SortedList{ SortedList list = new SortedList(10); Object[] list; list.insert(new Integer(10)); int size = 0; } public SortedList(int capacity){ } list = new Object[capacity]; } public void insert(Object item){ for(int i=0; i<size; i++){ int comp = item.compareTo(list[i]); // error โฆ } ์ด ์์ ์์ Integer ํด๋์ค๋ } compareTo ๋ฉ์๋๊ฐ ์ ์๋์ด โฆ ์์ง๋ง SortedList์ add ๋ฉ์๋๋ } ์ ๋ฌ๋ ๊ฐ์ฒด์ ํ์ ๊ณผ ์๊ด์์ด item์ Object ํ์ ์ด๋ฏ๋ก item์ ์ด์ฉํ์ฌ compareTo๋ฅผ ํธ์ถํ ์ ์๋ค.
์ด ์ฌ๋ผ์ด๋ ์์ ์ฒ๋ผ ์ค์ ์ธ์๋ก ์ ๋ฌ๋ Integer ํ์ ์ ๊ฐ์ฒด๋ compareTo ๋ฉ์๋๋ฅผ ๊ฐ ์ง๊ณ ์์ง๋ง insert ๋ฉ์๋ ๋ด์์ item์ Object ํ์ ์ด๋ฏ๋ก late binding๊ณผ ์๊ด์์ด ๋ฌธ๋ฒ ์ ์ผ๋ก compareTo ๋ฉ์๋๋ฅผ ํธ์ถํ ์ ์๋ค.
- 44 -
ํด๊ฒฐ์ฑ 1. public class SortedList{ Object[] list; int size = 0; public SortedList(int capacity){ list = new Object[capacity]; } public void insert(Object item){ Comparable x = (Comparable)item; for(int i=0; i<size; i++){ int comp = x.compareTo(list[i]); // ok โฆ } ์ด ๋ item์ด Comparable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ } ์์ง ์์ผ๋ฉด ClassCastException์ด ๋ฐ์ํ๋ค. โฆ }
compareTo ๋ฌธ์ ๋ ์ ์ฌ๋ผ์ด๋์ ์๋ ์์ฒ๋ผ ์ ๋ฌ๋ ์ธ์๋ฅผ compareTo ๋ฉ์๋๋ฅผ ์ ๊ณตํ ๋ Comparable ์ธํฐํ์ด์ค ํ์ ์ผ๋ก ๊ฐ์ ํ์ ๋ณํํ์ฌ ์ฌ์ฉํ ์ ์๋ค. ์ด ๋ ์ ๋ฌ๋ ์ธ ์๊ฐ Comparable ํ์ ์ผ๋ก ๋ณํ๋ ์ ์์ผ๋ฉด ClassCastException ์์ธ๊ฐ ๋ฐ์ํ๋ค. ์ด ๋ฉ ์๋์ ์๋ช ๋ง ๋ณด๋ฉด Comparable ํ์ ์ ์ธ์๋ฅผ ์ ๋ฌํด์ผ ํ๋์ง ์ ์ ์๊ธฐ ๋๋ฌธ์ ์ด ๋ฐฉ ๋ฒ๋ณด๋ค๋ ๋ค์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ ๋ฐ๋์งํ๋ค.
ํด๊ฒฐ์ฑ 2. public class SortedList{ Comparable[] list; // Object[] list; int size = 0; public SortedList(int capacity){ list = new Comparable[capacity]; } public void insert(Comparable item){ for(int i=0; i<size; i++){ int comp = item.compareTo(list[i]); // ok โฆ } } โฆ }
compareTo ๋ฉ์๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ insert์ ์ธ์ ํ์ ์ Object๊ฐ ์๋ Comparable ํ์ ์ผ๋ก ์ ์ธํ์ฌ, Comparable ํ์ ์ธ์๋ ์ ๋ฌํ ์ ์๋๋ก ํ๋ ๊ฒ์ด๋ค. ์ด ๋ ๋ด๋ถ ๋ฐฐ์ด์ Comparable ๋ฐฐ์ด๋ก ์ ์ธํ ์ ์๊ณ , Object ๋ฐฐ์ด๋ก ์ ์ธํ์ฌ ์ฌ์ฉํ ์ ๋ ์๋ค.
4.5. ๋ณต์ฌ๋ฐฉ์ VS. ์ฐธ์กฐ๋ฐฉ์ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋ ์๋ฐ์์๋ ๋ณต์ฌ ๋ฐฉ์(by clone)๊ณผ ์ฐธ์กฐ ๋ฐฉ์(by reference) ์ค
- 45 -
์ด๋ค ๋ฐฉ์์ผ๋ก ๊ตฌํํ ์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ๋ณต์ฌ ๋ฐฉ์์ ์ฃผ์ด์ง ์์๋ฅผ ๋ณต์ ํ์ฌ ๋ณต์ ๋ ์์ ์ ๋ํ ์ฐธ์กฐ๋ฅผ ๊ตฌ์กฐ์ ์ ์งํ๋ ๋ฐฉ์์ด๊ณ , ์ฐธ์กฐ ๋ฐฉ์์ ์ฃผ์ด์ง ์์์ ๋ํ ์ฐธ์กฐ๋ฅผ ๊ทธ๋๋ก ๊ตฌ์กฐ์ ์ ์งํ๋ ๋ฐฉ์์ด๋ค. ์๋ฐ์์ ๊ฐ์ฒด์ ๋ณต์ ๋ ๋ณดํต clone ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค.
๋ณต์ฌ๋ฐฉ์ vs. ์ฐธ์กฐ๋ฐฉ์ ๋ณต์ฌ๋ฐฉ์(by clone)
์ฐธ์กฐ๋ฐฉ์(by reference)
public void insert(Listable item){ public void insert(Object item){ list[size] = (Listable)item.clone(); list[size] = item; ๊ตฌํ ์ size++; size++; } } ์ํ์ฑ
์ธ๋ถ์์ ๋ด๋ถ ๋ด์ฉ์ ๋ถ๋ฒ์ ์ผ๋ก ์กฐ์ํ ์ ์๋ค.
์ธ๋ถ์์ ๋ด๋ถ ๋ด์ฉ์ ๋ถ๋ฒ์ ์ผ๋ก ์กฐ์ํ ์ ์๋ค.
์๋
๊ฐ์ฒด๊ฐ ํฌ๊ณ ๋ณต์กํ ์๋ก ๋๋ฆฌ๋ค.
์ผ์ ํ๋ฉฐ, ๋น ๋ฅด๋ค.
๊ณต๊ฐ
๋ ๋ฐฐ๋ก ์์๋๋ค.
๊ณต๊ฐ์ด ์ถ๊ฐ๋ก ํ์ ์๋ค.
์ฌ๊ธฐ์ Listable์ clone ๋ฉ์๋๋ฅผ public์ผ๋ก ์ ์ธํ๊ณ ์๋ ์ธํฐํ์ด์ค ํ์ ์ด๋ค.
์ฐธ์กฐ ๋ฐฉ์์ ์๋ ์ธก๋ฉด์ด๋ ๊ณต๊ฐ ์ธก๋ฉด์์ ๋ณต์ฌ ๋ฐฉ์์ ๋นํด ์ฑ๋ฅ์ด ์ฐ์ํ๋ค. ํ์ง๋ง ์ธ๋ถ ์์ ๊ธฐ์กด ์ฐธ์กฐ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌ์กฐ ๋ด์ ์๋ ์์์ ๊ฐ์ ๋ณ๊ฒฝํ ์ ์๋ค๋ ๋ฌธ์ ์ ์ ๊ฐ์ง๊ณ ์๋ค.
์ฐธ์กฐ ๋ฐฉ์์ ๋ฌธ์ ์ class MyClass{ int value; Myclass(int n){ value=n; } public void set(int n){ value=n; } public int get(){ return value; } โฆ }
list
UnsortedList list = new UnsortedList(5); MyClass a1 = new MyClass(10); MyClass a2 = new MyClass(20); list.insert(a1); list.insert(a2); a1.set(5);
10 5
a1
20
a2
์ด ์ฌ๋ผ์ด๋์ ์๋ ์์ ์์ ๋ณผ ์ ์๋ฏ์ด ๋ด๋ถ ์ํ๊ฐ 10๊ณผ 20์ธ ๊ฐ์ฒด๋ฅผ list์์ ์ฝ์ ํ ์์ง๋ง ์ฝ์ ํ ๋ ์ฌ์ฉ๋ a1๋ฅผ ์ด์ฉํ์ฌ ์ธ๋ถ์์ a1์ ๊ฐ์ ์กฐ์ํ๋ฉด list์ ์ ์ฅ๋์ด ์๋ ๊ฐ๋ ๋ณ๊ฒฝ๋๋ค. ํ์ง๋ง ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํ๋์ด ์๋ ๊ฒฝ์ฐ์๋ ์ด๋ฐ ์ํ์ ์๋ค.
- 46 -
clone clone์ compareTo์ ๋ฌ๋ฆฌ Object ํด๋์ค์ ์กด์ฌํ๋ค. ํ์ง๋ง Object์ clone ๋ฉ์๋๋ protected ๋ฉค๋ฒ์ด๋ฏ๋ก ์ธ๋ถ์์๋ ํธ์ถํ ์ ์๋ค. Object์ clone์ shallow copy(cf. deep copy)๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ฒด์ ๋ฉค๋ฒ ์ค ์ฐธ์กฐ ํ์ ์ด ์์ผ๋ฉด ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์ด ๋๋ฌธ์ Object์ clone ๋ฉ์๋๋ protected ๋ฉค๋ฒ๋ก ์ ์๋์ด ์๋ค. ๊ทธ๋ฌ๋ฉด Cloneable ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉํ์ฌ compareTo ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๊ฒ์ฒ๋ผ ํด๊ฒฐํ ์ ์์๊น? ๊ฐ๋ฅํ์ง ์๋ค. Cloneable ์ธํฐํ์ด์ค๋ ๋ด์ฉ์ด ๋น์ด์๋ marker interface์ด๋ค. ์ฐธ๊ณ . ์ฐธ๊ณ . marker interface๋ ๊ทธ๊ฒ์ ๊ตฌํํ๋ ํด๋์ค์ ํน์ฑ์ ๋ํ๋ธ๋ค. ์ด๋ค ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค๋ ๊ฒ์ ๋ํ๋ด์ง ์๋๋ค. ์3.8) Serializable: ๊ฐ์ฒด๋ฅผ ํ์ผ์ ์ ์ฅํ ์ ์์์ ๋ํ๋ธ๋ค.
clone์ ๋ฌธ์ ์ ์3.9)
Cloneable ์ธํฐํ์ด์ค๊ฐ clone ๋ฉ์๋๋ฅผ ์ ์ธํ๊ณ ์์ผ๋ฉด ์ด ๋ฉ์๋๊ฐ public class SortedList{ public ๋ฉ์๋๊ฐ ๋์ด ํธ์ถ์ด ๊ฐ๋ฅํ์ง๋ง Object[] list; marker interface์ด๋ฏ๋ก ๊ฐ๋ฅํ์ง ์๋ค. int size = 0; public SortedList(int capacity){ list = new Object[capacity]; } public Object get(int index) { // return list[index].clone(); Cloneable x = (Cloneable)list[index]; return x.clone(); // error; } โฆ }
ํด๊ฒฐ์ฑ . ํด๊ฒฐ์ฑ . ์๋ก์ด ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ๋ค. interface Copyable{ Object clone(); }
public void get(int index) { Copyable x = (Copyable)list[index]; return x.clone(); // ok; }
๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ ๋์๋ Object ํ์ ์ ์ด์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ธฐ๊ฐ ์ด๋ ต๋ค.
Object ํด๋์ค๋ clone ๋ฉ์๋๋ฅผ ์ ๊ณตํ๊ณ ์์ผ๋ฏ๋ก, equals ๋ฉ์๋์ ์์ฒ๋ผ Object ํ์ ์ ์ฌ์ฉํ์ฌ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ ๊ฒ์ผ๋ก ์๊ฐํ ์ ์๋ค. ํ์ง๋ง ์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด
clone ๋ฉ์๋๋ protected ๋ฉค๋ฒ์ด๋ฏ๋ก Object์ ๋ํ ํธ๋ค์ ์ด์ฉํ์ฌ clone ๋ฉ์๋๋ฅผ ํธ์ถ ํ ์ ์๋ค. ๊ทธ๋ฌ๋ฉด compareTo ๋ฉ์๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ๊ฒ์ฒ๋ผ Cloneable ์ธํฐํ์ด์ค๋ฅผ ์ด์ฉ ํ์ฌ ํด๊ฒฐํ ์ ์๋๊ฐ? ๊ฐ๋ฅํ์ง ์๋ค. ๊ทธ ์ด์ ๋ Cloneable ์ธํฐํ์ด์ค๋ ๋ถํํ๋
marker ์ธํฐํ์ด์ค์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ธํฐํ์ด์ค๋ ์ด๋ค ํน์ ๋ฉ์๋๋ค์ ์ ๊ณตํ๋ค๋ ๊ฒ์ ์๋ ค์ฃผ๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ํ์ง๋ง marker ์ธํฐํ์ด์ค๋ ๋ด์ฉ์ด ๋น ์ธํฐํ์ด์ค๋ก์ ๊ทธ๊ฒ์ ๊ตฌ ํํ๋ ํด๋์ค๊ฐ ์ด๋ค ๋ฉ์๋๋ค์ ์ ๊ณตํ๋ค๋ ๊ฒ์ ๋ํ๋ด์ง ์๊ณ , ์ด๋ค ํน์ฑ์ ๊ฐ์ง๋ค๋ ๊ฒ์ ๋ํ๋ด๊ธฐ ์ํด ์ฌ์ฉ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ค์ clone ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ ๊ฐ์ฒด๋ค๋ง ์ฒ๋ฆฌํ๊ธฐ ์ํด์๋ ๋ณ๋ ์ธํฐํ์ด์ค๋ฅผ ์๋กญ๊ฒ ์ ์ํ์ฌ ์ฌ์ฉํด์ผ ํ๋ค.
- 47 -
clone๊ณผ compareTo ๋์ ์ ๊ณต ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ณ ์ถ๋ค. ๊ทธ๋ฐ๋ฐ ์ด ์๋ฃ๊ตฌ์กฐ๋ ์ถ๊ฐ์ ์ผ๋ก ํน์ ๋ฉ์๋๊ฐ ์ ๊ณต๋์ด์ผ ํ๋ค. ์ด๋ป๊ฒ ํด์ผ ํ๋? ์3.10) ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๊ณ ์ถ๋ค. ์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ compareTo ๋ฉ์๋๊ฐ ์ ๊ณต๋์ด์ผ ํ๋ค. ๋ฐฉ๋ฒ. ๋ฐฉ๋ฒ. Comparable, Cloneable์ ๊ตฌํํ ์ ์ธํฐํ์ด์ค๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ์ ์ํ์ฌ ์ฌ์ฉํ๋ค. ์ฐธ๊ณ . ์ฐธ๊ณ . ์ธํฐํ์ด์ค๋ ๋ค์ค์ผ๋ก ์ธํฐํ์ด์ค๋ฅผ ์์ํ ์ ์๋ค. interface Listable extends Comparable, Cloneable{ // int compareTo(Object target); Object clone(); }
๋ณต์ฌ๋ฐฉ์์ผ๋ก ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ณ ์ถ๋ค. ๊ทธ๋ฌ๋ฉด ์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ์ ์ธํฐํ์ด ์ค๋ฅผ ์ ์ํด์ผ ํ๋ค. ๊ทธ๋ฐ๋ฐ ์ด ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ ์ถ๊ฐ์ ์ผ๋ก ํน์ ๋ฉ์๋๊ฐ ์ ๊ณต๋์ด์ผ ํ๋ค. ์ด ๊ฒฝ์ฐ์๋ ์๋กญ๊ฒ ์ ์ํ ์ธํฐํ์ด์ค์ ์ด ๋ฉ์๋๊น์ง ์ ์ธํด์ผ ํ๋ค. ์3.10์ฒ๋ผ ๋ณต์ฌ๋ฐฉ์์ผ๋ก ์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๊ณ ์ถ์ผ๋ฉด Listable์ด๋ผ๋ ์ ์ธํฐํ์ด์ค๋ฅผ ๋ง๋ค๊ณ , ์ด ์ธํฐํ์ด์ค๋ Comparable๊ณผ Cloneable์ ์์๋ฐ๋๋ก ํ๋ค. Comparable์ ์์ ๋ฐ๊ธฐ ๋๋ฌธ์ Listable์ compareTo ๋ฉ์๋๋ ์ ์ธํ์ง ์์๋ ๋์ง๋ง Cloneable์ marker ์ธํฐํ์ด์ค์ด๋ฏ๋ก clone ๋ฉ์๋๋ฅผ ์ ์ธํด์ฃผ์ด์ผ ํ๋ค. ๋ค์์ ์ด๋ ๊ฒ ์ ์ํ Listable ์ธํฐ ํ์ด์ค๋ฅผ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ ๊ตฌํ์ ์์ด๋ค.
clone๊ณผ compareTo ๋์ ์ ๊ณต ์3.11) Listable์ ์ฌ์ฉ ์ class SortedList{ Listable[] list; int size = 0; public SortedList(int capacity){ list = new Listable[capacity]; } public Object get(int index) { return list[index].clone(); } โฆ }
class SortedList{ Object[] list; int size = 0; public SortedList(int capacity){ list = new Object[capacity]; } public Object get(int index) { Listable x = (Listable)list[index]; return x.clone(); } โฆ }
- 48 -
Listable ์ธํฐํ์ด์ค Listable ์ธํฐํ์ด์ค์ ๋ฌธ์ ์ ์๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณตํ๋ Integer์ ๊ฐ์ ๊ธฐ์กด ๊ฐ์ฒด๋ ์ ์ฅํ ์ ์๋ค. ๋ํ ๊ธฐ์กด ๊ฐ์ฒด๋ฅผ ๊ฐ๋จํ๊ฒ Listable ์ ๊ณตํ๋๋ก ๋ค์๊ณผ ๊ฐ์ด ๋ง๋ค ์๋ ์๋ค. class myInteger extends Integer implements Listable{ public myInteger(int val){ super(val); The type myInteger cannot subclass } the final class integer. }
์ ๋ฌธ์ ์ ์ ๋ํ ํจ์จ์ ์ธ ํด๊ฒฐ์ฑ ์ด ์์. ๋ณต์ฌ ๋ฐฉ์์ ๊ตฌํ์ ํฌ๊ธฐํ๊ฑฐ๋, ์๋๋ฉด ์ ์ฅํ ๊ฐ์ฒด๋ง๋ค ์๋กญ๊ฒ Listable์ ๊ตฌํํ๋๋ก ์ ํด๋์ค๋ฅผ ์ ์ํจ.
Listable ์ธํฐํ์ด์ค๋ฅผ ์๋กญ๊ฒ ์ ์ํ์ฌ ์ฌ์ฉํ๋ฉด ๋ชจ๋ ๋ฌธ์ ๊ฐ ๋ถ๋๋ฝ๊ฒ ํด๊ฒฐ๋๋ ๊ฒ์ ์๋ ๋ค. ์๋ฃ๊ตฌ์กฐ์ ์ ์ฅํ๊ณ ์ ํ๋ ๊ฐ์ฒด๋ค์ด Listable์ ๊ตฌํํ๊ณ ์์ด์ผ ํ๋ค. ์ฐ๋ฆฌ๊ฐ ์๋กญ๊ฒ ์ ์ํ๋ ๋ฐ์ดํฐ๋ค์ด Listable์ ๊ตฌํํ๋๋ก ๋ง๋๋ ๊ฒ์ ์ด๋ ต์ง ์์ง๋ง ๊ธฐ์กด ๊ฐ์ฒด๋ค์ด
Listable์ ๊ตฌํํ๋๋ก ๋ง๋๋ ๊ฒ์ ์ฝ์ง ์๋ค. ํนํ ์๋ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ ๊ณต๋๋ ํด๋์ค ๋ค์ ๋ณดํต ์์๋ฐ์ ์ ์๋ final ํด๋์ค์ด๋ฏ๋ก ์ด๊ฒ์ด ๋งค์ฐ ์ด๋ ต๋ค. ๋ฐ๋ผ์ ๋ณดํต์ ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๋ง๋๋ ๊ฒ์ ํฌ๊ธฐํ๋ค.
Object ํ์ ์ ์ด์ฉํ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ์์ฝํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ง๋ค ๊ธฐ ์ํด์๋ ๋ค์ํ ํ์ ์ ์ ์ฅํ ์ ์๋ ํ์ ์ด ํ์ํ๋ค. ์๋ฐ์์๋ Object ํด๋์ค๊ฐ ๊ฐ์ฅ ๋ค์ํ ํ์ ์ ์ ์ฅํ ์ ์์ผ๋ฏ๋ก ๋ณดํต ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ฒ์ฉ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํ ํ๋ค. ๊ทธ๋ฐ๋ฐ ์๋ฃ๊ตฌ์กฐ๋ง๋ค ๊ทธ ์๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋๋ ์์๊ฐ ๋ฐ๋์ ์ ๊ณตํด์ผ ํ๋ ๋ฉ์๋๊ฐ ์์ ์ ์๋ค. ์ด์ ๊ด๋ จํ์ฌ Object ํ์ ์ ์ด์ฉํ ๋ ํฌ๊ฒ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด ์๊ฐํด ๋ณผ ์ ์๋ค. ์ฒซ์งธ, ํ์ํ ๋ฉ์๋๊ฐ Object ํด๋์ค์ ์ ์๋์ด ์๋ ๊ฒฝ์ฐ์ด๋ค. ๋์งธ, ํ์ํ ๋ฉ์๋๊ฐ Object ํด๋์ค์ ์ ์๋์ด ์์ง ์์ ๊ฒฝ์ฐ์ด๋ค. ์ ์์ ๊ฒฝ์ฐ equals์ฒ๋ผ Object์ ์ ์๋์ด ์๊ณ , public ๋ฉ์๋์ด๋ฉด ๋น๊ต์ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ผ๋ฉฐ, ์๋ฃ๊ตฌ์กฐ ์์ฒด๋ณด๋ค๋ ์ ๋ฃ๊ตฌ์กฐ์ ์ ์ฅ๋๋ ์์๋ค์ ํด๋์ค๋ฅผ ๋ง๋ค ๋ equals๋ฅผ overrideํ๋ฉด ๋๋ค. ํ์ง๋ง clone์ฒ ๋ผ ์ ์๋์ด ์์ด๋ protected ๋ฉ์๋์ด๋ฉด ์ด๊ฒ์ ํธ์ถํ ์ ์๋๋ก ์ธํฐํ์ด์ค ๊ธฐ๋ฅ์ ์ด ์ฉํด์ผ ํ๋ค. ํ์์ ๊ฒฝ์ฐ์๋ ํ์ํ ๋ฉ์๋๋ฅผ ์ ์ธ๋์ด ์๋ ์ธํฐํ์ด์ค๋ฅผ ๋ง๋ค๊ฑฐ๋ ์ด์ฉ ํ์ฌ ํด๊ฒฐํ ์ ์๋ค.
- 49 -
์ 5์ฅ ๋ฆฌ์คํธ ์ด ์ฅ์์๋ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณธ๋ค.
5.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ๋ฆฌ์คํธ ๋น์ ๋ ฌ ๋ฆฌ์คํธ ์ ๋ ฌ ๋ฆฌ์คํธ ์๊ณ ๋ฆฌ์ฆ ๋น๊ต Big-O ํ๊ธฐ๋ฒ
5.2. ๋ฆฌ์คํธ
๋ฆฌ์คํธ ๋ฆฌ์คํธ์ ํน์ฑ ๋์ง ๊ตฌ์กฐ: ๊ตฌ์กฐ ๊ตฌ์กฐ์ ์๋ ๋ชจ๋ ์์๋ ๊ฐ์ ํ์ ์ด๋ค. ์์๋ค๊ฐ์ ์ ํ ๊ด๊ณ๊ฐ ์กด์ฌํ๋ค. ์กด์ฌ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ ์ธํ ๋ชจ๋ ์์๋ ์ ํ ์์๊ฐ ์์ผ๋ฉฐ, ๋ง์ง๋ง ์์๋ฅผ ์ ์ธํ ๋ชจ๋ ์์๋ ํ์ ์์๊ฐ ์๋ค. ๋ฆฌ์คํธ์ ์๋ ์์์ ๊ฐ์๋ฅผ ๋ฆฌ์คํธ์ ํฌ๊ธฐ๋ผ ํ๋ค. ๋ฆฌ์คํธ๋ ์ ๋ ฌ๋์ด ์ ์ง๋ ์ ์๊ณ , ๊ทธ๋ ์ง ์์ ์ ์๋ค. ๋น์ ๋ ฌ(unsorted) ๋ฆฌ์คํธ, ์ ๋ ฌ(sorted) ๋ฆฌ์คํธ ์ ๋ ฌ ๋ฆฌ์คํธ์์ ์์๊ฐ ๋ณตํฉ ํ์ ์ผ ๊ฒฝ์ฐ์๋ ์ ๋ ฌ์ ๊ธฐ์ค์ด ๋๋ ํค๊ฐ ์กด์ฌํ๋ค. ์4.1) ํ์ ๊ธฐ๋ก๋ถ: ํ๋ฒ, ํ์ ์ด๋ฆ, ๋์ด, ... ร ํค๋ ๋ค์ํ๊ฒ ๊ฒฐ์ ๋ ์ ์๋ค.
๋ฆฌ์คํธ๋ ๋ค์๊ณผ ๊ฐ์ ํน์ฑ์ ๊ฐ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ์ฒซ์งธ, ๋์ง ๊ตฌ์กฐ์ด๋ค. ๋์งธ, ์์๋ค ๊ฐ์ ์ ํ ๊ด๊ณ๊ฐ ์กด์ฌํ๋ค. ์ ํ ๊ด๊ณ๋ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ์ ํ ์์๊ฐ ์์ผ๋ฉฐ, ๋ง์ง๋ง ์์๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ํ์ ์์๋ฅผ ๊ฐ์ง๋ค๋ ๊ฒ์ ์๋ฏธํ๋ค. ๋ฆฌ์คํธ๋ ์์๋ฅผ ์ด ๋ค ๊ธฐ์ค์ ๋ฐ๋ผ ์ ๋ ฌํ์ฌ ์ ์งํ ์ ์๊ณ , ๊ทธ๋ ์ง ์์ ์ ์๋ค. ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์ ์
- 51 -
์ฅํ๋ ์์๊ฐ ๋ณตํฉ ํ์ ์ด๋ฉด ์ ๋ ฌ์ ๊ธฐ์ค์ด ๋๋ ํค๊ฐ ์กด์ฌํ๋ฉฐ, ์ด ํค๋ ๋ค์ํ๊ฒ ๊ฒฐ์ ํ ์ ์๋ค.
๋ฆฌ์คํธ ADT ๊ตฌํ์ ๊ณ ๋ ค์ฌํญ ์ค๋ณต ํ์ฉ ์ฌ๋ถ ๋์ผํ ๊ฒ์ด ์ฌ๋ฌ ๋ฒ ์ฝ์ ๋ ์ ์๋์ง ์ฌ๋ถ: ์์ฉ์ ์ํด ๊ฒฐ์ ์ ๊ณตํด์ผ ํ๋ ์ฐ์ฐ์ ํํ ๋ณดํต ์๋ฃ๊ตฌ์กฐ๋ ์ฝ์ , ์ญ์ , ๊ฒ์, ์ถ์ถ ์ฐ์ฐ์ ์ ๊ณตํ๋ค. ๊ฐ ์ฐ์ฐ์ ํํ๋ ์ ํด์ ธ ์์ง ์์ผ๋ฉฐ, ์์ฉ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๋ค. ์4.2) ์ญ์ ์ฃผ์ด์ง ํค ๊ฐ์ ๊ฐ์ง ์์๋ฅผ ์ญ์ ์๋ฃ๊ตฌ์กฐ ๋ด์ ํน์ ์์น์ ์ ์ฅ๋ ์์๋ฅผ ์ญ์
๋ฆฌ์คํธ ADT๋ฅผ ๊ตฌํํ ๋ ๋จผ์ ๋ช ๊ฐ์ง ๊ณ ๋ คํด์ผ ํ๋ ์ฌํญ์ด ์๋ค. ์ฒซ์งธ, ์ค๋ณต ์์๋ฅผ ํ ์ฉํ ๊ฒ์ธ์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ์ค๋ณต์ ํ์ฉํ๋ค๋ ๊ฒ์ ๋์ผํ ํค ๊ฐ์ ๊ฐ์ง ์ฌ๋ฌ ์์๊ฐ ์ ๋ฃ๊ตฌ์กฐ์ ์ ์ง๋ ์ ์๋ค๋ ๊ฒ์ ๋งํ๋ค. ์ด๊ฒ์ ์์ฉ์ ๋ฐ๋ผ ํ์ํ ์๋ ์๊ณ , ๊ทธ๋ ์ง ์ ์ ์๋ ์๋ค. ๋์งธ, ์ ๊ณตํด์ผ ํ๋ ์ฐ์ฐ์ ํํ๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค. ์๋ฃ๊ตฌ์กฐ๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์ ๊ณตํด์ผ ํ๋ ์ฐ์ฐ์ ์ ํด์ ธ ์๋ค. ๋ณดํต ์ฝ์ , ์ญ์ , ๊ฒ์, ์ถ์ถ ์ฐ์ฐ์ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํ ๋ฉฐ, ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ๋ ์ด๋ค ์ฐ์ฐ์ ์ ๊ณตํด์ผ ํ๋ค. ๊ทธ๋ฌ๋ ์ด๋ค ๊ฐ ์ฐ์ฐ์ ํํ๋ ๋ณดํต ์ ํด์ ธ ์์ง ์์ผ๋ฉฐ, ์์ฉ์ ์๊ตฌ์ ๋ฐ๋ผ ํ์ํ ํํ๊ฐ ๋ค๋ฅผ ์ ์๋ค. ์๋ฅผ ๋ค์ด ์ญ์ ์ฐ์ฐ ์ ๊ฒฝ์ฐ์๋ ์ด๋ค ํค ๊ฐ์ ๊ฐ์ง ์์๋ฅผ ์ฐพ์ ์ญ์ ํ๋ ์ฐ์ฐ์ ์ ๊ณตํ ์ ์๊ณ , ์๋ฃ๊ตฌ์กฐ ๋ด ์ ํน์ ์์น์ ์ ์ฅ๋์ด ์๋ ์์๋ฅผ ์ญ์ ํ๋ ์ฐ์ฐ์ ์ ๊ณตํ ์๋ ์๋ค. ๋ฌผ๋ก ํ ๊ฐ์ง ํ ํ์ ์ญ์ ์ฐ์ฐ์ ์ ๊ณตํ์ง ์๊ณ , ์ฌ๋ฌ ํํ์ ์ญ์ ์ฐ์ฐ์ ๋์์ ์ ๊ณตํด์ผ ํ๋ ๊ฒฝ์ฐ๋ ์๋ค.
5.3. UnsortedList ์ด ์ฅ์์ ๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ ๊ตฌํ ๋ฐฉ๋ฒ์ ์ดํด๋ณธ๋ค. ๋ฐฐ์ด์ ๊ทธ ์ฉ๋์ด ์์ฑ๋ ๋ ๊ณ ์ ๋๋ฏ๋ก ์์๋ฅผ ์ฝ์ ํ๋ค ๋ณด๋ฉด ๋ ์ด์ ์์๋ฅผ ์ฝ์ ํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ ์ ์ ๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ์์ธ์ ์ํ ์์ ์ ๊ทผ์ ์ ๊ณตํ๋ฏ๋ก ๊ฐ ์์๋ฅผ ์ ๊ทผํ๊ธฐ๊ฐ ์ฉ์ดํ๋ค.
- 52 -
UnsortedList ADT ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ์ ๊ตฌํ int size; capacity? int cursor; Object[] elements; ์์ฑ์ UnsortedList() UnsortedList(int capacity); ์ํ boolean isFull(); boolean isEmpty(); int size(); ๊ฒ์ boolean search(Object item); Object retrieve(Object item);
์กฐ์ boolean insert(Object item); boolean delete(Object item); ์ปค์ ์กฐ์ void reset(); iterator ์ปค์๋ฅผ ์ฒ์์ผ๋ก boolean hasNext(); ํ์ ์์๊ฐ ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค. Object next(); ์ปค์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ฒด๋ฅผ ๋ฐํํ๊ณ , ์ปค์๋ฅผ ๋ค์์ผ๋ก ์ด๋ํ๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ์ด๋ฏ๋ก ํ์ํ ๋ฉค๋ฒ๋ณ์๋ ํ์ฌ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ ์ ์งํ๋ size์ ์์๋ค์ด ์ ์ฅ๋ ๋ฐฐ์ด elements๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ํ์ํ๋ค. ๋ฐฐ์ด์ ์ฉ ๋ ์ ๋ณด๋ ํ์ํ์ง๋ง ์๋ฐ์์๋ length๋ผ๋ ๋ฐฐ์ด์ ๋ฉค๋ฒ๋ณ์๋ฅผ ์ด์ฉํ์ฌ ์ฉ๋ ์ ๋ณด๋ฅผ ํญ ์ ์ป์ ์ ์์ผ๋ฏ๋ก ์ฉ๋์ ์ ์งํ๋ ๋ณ๋์ ๋ฉค๋ฒ๋ณ์๋ฅผ ์ ์งํ ํ์๊ฐ ์๋ค. ๋ฐ๋ณต์๋ ์ด ์ฒ๋ผ ํด๋์ค ์์ฒด์ cursor ๋ฉค๋ฒ๋ณ์๋ฅผ ์ ์ธํ๊ณ , reset, hasNext, next ๋ฑ๊ณผ ๊ฐ์ ๋ฉ์๋๋ฅผ ์ ์ํ์ฌ ์ ๊ณตํ ์ ์๊ณ , ์๋ฐ์ ํด๋์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ฒ๋ผ ๋ณ๋์ ๋ฐ๋ณต์ ๊ฐ์ฒด๋ฅผ ์ ์ํ์ฌ ์ ๊ณตํ ์ ์๋ค. ์ด ์ฅ์์๋ ์ฐ์ ํด๋์ค ์์ฒด์ ํ์ํ ๋ฉ์๋๋ฅผ ์ ์ํ์ฌ ๋ฐ๋ณต์๋ฅผ ์ ๊ณต ํ๋ค. ์ฐธ๊ณ ์ ์ผ๋ก ์ด ์ฅ์์ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ ๋์๋ Object ๋ฐฐ์ด์ ์ด์ฉํ๋ค. ๋ฐ๋ผ์ ๋ณต์ฌ ๋ฐฉ์์ด ์๋ ์ฐธ์กฐ ๋ฐฉ์์ผ๋ก ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๋ค. ๋ํ ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ์ง ์๋๋ค.
boolean search(Object item) ์ฌ์ ์กฐ๊ฑด: item!=null ์ฌํ์กฐ๊ฑด: item์ด ๋ฆฌ์คํธ์ ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๊ณ , ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค. ์ ๋ ฌ๋์ด ์์ง ์๋ ๋ฆฌ์คํธ ์ด๋ฏ๋ก ์ ํ๊ฒ์๋ง ๊ฐ๋ฅํ๋ค. ๊ฒ์ํ ๋ ์ข ๋ฃ์กฐ๊ฑด 1. ์ฐพ๊ณ ์ ํ๋ ๊ฒ์ ๋ฐ๊ฒฌํจ 2. ๋ชจ๋ ์์์ ๋น๊ตํ์์ง๋ง ์ฐพ์ง ๋ชปํจ
boolean search(Object item){ int loc = 0; boolean moreToSearch = (item!=null)&&(loc<size); boolean found = false; while(moreToSearch && !found){ if(item.equals(elements[loc])){ found = true; } else{ loc++; moreToSearch = (loc < size); } } return found; } boolean search(Object item){ if(item==null) return false; for(int loc = 0; loc<size; loc++){ if(item.equals(elements[loc])) return true; return false; }
search ์ฐ์ฐ์ ๋ฆฌ์คํธ์ ์ฃผ์ด์ง ํค ๊ฐ๊ณผ ๊ฐ์ ์์๊ฐ ์๋์ง ๊ฒ์ฌํ๋ ์ฐ์ฐ์ผ๋ก์, Object ํด๋์ค์ equals ๋ฉ์๋๋ฅผ ์ด์ฉํ๋ค. ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ด๋ฏ๋ก ์ฐพ๊ณ ์ ํ๋ ์์๊ฐ ์ด๋์ ์๋ ์ง ๋จ์ ํ ์ ์๋ค. ๋ฐ๋ผ์ ์ ํ๊ฒ์๋ง ํ ์ ์๋ค. ์ ํ๊ฒ์์ด๋ ์ฒซ ๋ฒ์งธ ์์๋ถํฐ ๋ ์ ์๊น์ง ์ฐจ๋ก๋ก ๊ฒ์ฌํ๋ ๋ฐฉ์์ ๋งํ๋ค. ์ ํ ๊ฒ์์ ์ฐพ๊ณ ์ ํ๋ ๊ฒ์ ๋ฐ๊ฒฌํ ๊ฒฝ์ฐ์ ๋ชจ๋
- 53 -
์์์ ๋น๊ตํ์์ง๋ง ๊ฐ์ ์์๊ฐ ์๋ ๊ฒฝ์ฐ์ ์๋ฃํ๋ค. ๋ฐ๋ผ์ search ์ฐ์ฐ์ ์ด ๋ ๊ฐ์ง ์กฐ๊ฑด์ ๊ฐ๊ฐ ๋ํ๋ด๋ found์ moreToSearch ์ง์ญ๋ณ์์ while ๋ฃจํ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ ์ ์๋ค. ์ด ๋ฐฉ๋ฒ ์ธ์ ์ฐ๋ฆฌ๋ ๋ฐฐ์ด์ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ size๋ผ๋ ๋ฉค๋ฒ๋ณ์์ ์ ์ง ํ๋ฏ๋ก size์ for ๋ฌธ์ ์ด์ฉํ์ฌ ๋ณด๋ค ๊ฐํธํ๊ฒ search ์ฐ์ฐ์ ๊ตฌํํ ์๋ ์๋ค. retrieve ์ฐ์ฐ์ search ์ฐ์ฐ๊ณผ ๋ฐํํ๋ ๊ฐ๋ง ๋ค๋ฅผ ๋ฟ ๋์ผํ ์ฐ์ฐ์ด๋ค. retrieve์ ์ฃผ์ด์ง ํค ๊ฐ๊ณผ ๊ฐ์ ์์๋ฅผ ์ฐพ์ ๊ทธ ์์๋ฅผ ๋ฐํํ์ฌ ์ฃผ๋ฉฐ, ์ถ์ถํ๊ณ ์ ํ๋ ์์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ null ๊ฐ ์ ๋ฐํํ๋ค.
boolean insert(Object item) ์ฌ์ ์กฐ๊ฑด: item!=null, ๋ฆฌ์คํธ๊ฐ full์ด ์๋ ์ฌํ์กฐ๊ฑด: ์ฃผ์ด์ง item์ ๋ฆฌ์คํธ์ ๋์ ์ถ๊ฐํ๋ค. ์ถ๊ฐ์ ์ฑ๊ณตํ๋ฉด true๋ฅผ, ๋ชปํ๋ฉด false๋ฅผ ๋ฐํํ๋ค.
boolean insert(Object item){ if(item==null || isFull()) return false; elements[size] = item; // Listable x = (Listable)item; // elements[size] = x.clone(); size++; return true; } item elements elements
item
๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ฝ์ ์ฐ์ฐ์ ์์๋ฅผ ํน์ ์์น์ ์ฝ์ ํ ํ์๊ฐ ์์ผ๋ฏ๋ก ArrayList์ฒ๋ผ ๋ฆฌ์คํธ ๋งจ ๋์ ์ฝ์ ํ๋ ๊ฒ์ด ๋น์ฉ์ธก๋ฉด์์ ๊ฐ์ฅ ์ ๋ ดํ๋ค. ๋ฆฌ์คํธ ๋งจ ๋ ์์ธ์ ํ์ฌ ๋ฆฌ ์คํธ์ ํฌ๊ธฐ ์ ๋ณด๋ก๋ถํฐ ์ฝ๊ฒ ์ป์ ์ ์๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ์ ๊ตฌํ์์๋ ์์ ์ธ๊ธ ํ ๋ฐ์ ๊ฐ์ด ๋ฆฌ์คํธ๊ฐ ๊ฝ ์ฐจ์์ผ๋ฉด ๋ ์ด์ ์ ์์๋ฅผ ์ฝ์ ํ์ง ๋ชปํ๋ค. ์ด ์ฅ์์๋ ๋ํ ์ฐธ์กฐ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๊ณ ์์ผ๋ฏ๋ก ์ฃผ์ด์ง ์ ์์๋ฅผ ๋ณต์ ํ์ง ์๊ณ ์ฐธ์กฐ๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ๋ค. ๋ง์ฝ ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ์ด ๊ตฌํ์ ๋ณ๊ฒฝํ๊ณ ์ ํ๋ฉด ์ฃผ์์ฒ๋ฆฌ๋ ๊ฒ์ฒ๋ผ ์ฃผ์ด์ง ์ธ์๋ฅผ
Listable ํ์ ์ผ๋ก ๋ณํํ์ฌ ๋ณต์ ํ ๊ฒ์ ์ ์ฅํด์ผ ํ๋ค.
- 54 -
boolean delete(Object item) ์ฌ์ ์กฐ๊ฑด: ์ฌ์ ์กฐ๊ฑด item!=null ์ฌํ์กฐ๊ฑด: ์ฌํ์กฐ๊ฑด item์ด ๋ฆฌ์คํธ์ ์์ผ๋ฉด ๊ทธ item์ ์ญ์ ํ๋ค. ์ญ์ ์ ์ฑ๊ณตํ๋ฉด true๋ฅผ ๋ชปํ๋ฉด false๋ฅผ ๋ฐํํ๋ค. ๊ฒ์ํ ๋ ์ข ๋ฃ์กฐ๊ฑด์ search ์ฐ์ฐ๊ณผ ๊ฐ์. ํ์ง๋ง ์ด ๊ฒฝ์ฐ์๋ ๋ ๊ฐ์ boolean ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์์.
์ญ์ ํ ๊ฒ A
D
C
F
A
D
E
F
E
boolean delete(Object item){ int loc = 0; boolean moreToSearch = (item!=null)&&(loc<size); while(moreToSearch){ if(item.equals(element[loc])){ if(loc!=size-1) elements[loc] = elements[size-1]; size--; ์ ๋ ฌ๋์ด ์์ง ์๋ return true; ๋ฆฌ์คํธ์ด๋ฏ๋ก ๊ฐ๋ฅ } else{ loc++; moreToSearch = (loc<size); } } // while return false; } // delete
์ญ์ ์ฐ์ฐ์ ์ฝ์ ์ฐ์ฐ๊ณผ ๋ฌ๋ฆฌ ๋จผ์ ์ญ์ ํ๊ณ ์ ํ๋ ์์๊ฐ ๋ฆฌ์คํธ์ ์๋์ง ๊ฒ์ฌํด์ผ ํ ๋ค. ๋ง์ฝ ๋ฆฌ์คํธ์ ์ญ์ ํ๊ณ ์ ํ๋ ์์๊ฐ ์กด์ฌํ๋ฉด ๊ทธ ์์๋ฅผ ์ ๊ฑฐํด์ผ ํ๋๋ฐ, ์ด ๋ ๋จ ์ํ๊ฒ ๊ทธ ํญ์ null ๊ฐ์ ๋์ ํ๋ค๊ณ ์ญ์ ๋๋ ๊ฒ์ ์๋๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ ๊ตฌํ์ ์๋ ์ค๊ฐ์ ๋นํญ์ด ์์ด์ผ ํ๋ค. ์ด๋ ๊ฒ ํ์ง ์์ผ๋ฉด ์ฝ์ , ๊ฒ์ ๋ฑ ๋ค๋ฅธ ์ฐ์ฐ์ ๋์ ์ ํฅ์ ์ค๋ค. ์ค๊ฐ์ ๋นํญ์ด ์๋๋ก ์์๋ฅผ ์ญ์ ํ๊ธฐ ์ํด ์ญ์ ํ๊ณ ์ ํ๋ ์์์ ๋ชจ๋ ํ์ ์์๋ค์ ํ๋์ฉ ์ด๋ํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ ์ ์๋ค. ํ์ง๋ง ๋ฆฌ์คํธ๊ฐ ์ ๋ ฌ๋์ด ์ ์ง๋๋ ๊ฒ ์ด ์๋๋ฏ๋ก ๋งจ ๋ ์์๋ฅผ ์ญ์ ํ๋ ์์์ ๋์ฒดํจ์ผ๋ก ์ ๋ ดํ๊ฒ ์ญ์ ํ ์ ์๋ค. ๊ฒ์ํ ๋ ์ข ๋ฃํ๋ ์กฐ๊ฑด์ ์์ ์ดํด๋ณธ insert์ ๊ฐ๋ค. ํ์ง๋ง ๋ ๊ฐ์ ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ , ํ๋ ์ ๋ณ์๋ง์ ์ด์ฉํ์ฌ delete๋ฅผ ๊ตฌํํ๊ณ ์๋ค. ์ด์ฒ๋ผ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก๋ง ๋ฉ์๋๋ฅผ ๊ตฌํํ ์ ์๋ ๊ฒ์ ์๋๋ค.
boolean delete(Object item) โ ๊ณ์ boolean delete(Object item){ if(item==null) return false; for(int loc = 0; loc<size; loc++) if(item.equals(element[loc])){ if(loc!=size-1) elements[loc] = elements[size-1]; size--; return true; } return false; }
์ด ์ฌ๋ผ์ด๋์์๋ boolean ๋ณ์๋ฅผ ์ ํ ์ฌ์ฉํ์ง ์๊ณ for๋ฌธ์ ์ด์ฉํ์ฌ ๋ณด๋ค ๊ฐํธํ๊ฒ ๊ตฌ ํํ๊ณ ์๋ค.
- 55 -
Object next(), boolean hasNext() ์ฌ์ ์กฐ๊ฑด: ์์ ์ฌํ์กฐ๊ฑด: ์ปค์๊ฐ ๋ฆฌ์คํธ์ ๋งจ ์ฒ์์ ๊ฐ๋ฆฌํค๋๋ก ํ๋ค.
์ฌ์ ์กฐ๊ฑด: ์์ ์ฌํ์กฐ๊ฑด: ํ์ฌ ์ปค์๊ฐ ๊ฐ๋ฆฌํค๊ณ ์๋ ์์๋ฅผ ๋ฐํํ๊ณ , ์ปค์๋ฅผ ๋ค์ ์์๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ์ด๋ํ๋ค.
void reset(){ cursor=0; }
Object next(){ int loc = cursor; cursor++; return elements[loc]; // Listable x = // (Listable)elements[loc]; // return x.clone(); }
์ฌ์ ์กฐ๊ฑด: ์์ ์ฌํ์กฐ๊ฑด: ์ปค์๊ฐ ๋ฆฌ์คํธ์ ๋์ ๊ฐ๋ฆฌ ํค๊ณ ์์ผ๋ฉด false ๋ฐํํ๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค. boolean hasNext(){ return (cursor<size);
์ฌ์ฉ๋ฒ
}
reset(); while(hasNext()){ next() }
reset(); for(int i=0; i<size(); i++){ next() }
์ด ADT์์ ๋ฐ๋ณต์๋ ADT์์ ์์ฒด์ ์ผ๋ก ์ ๊ณตํ๋ค. ์ด ๋ cursor๋ผ๋ ๋ฉค๋ฒ๋ณ์๋ฅผ ํตํด ๋ค์์ ์ ๊ทผํ ์์๋ฅผ ์ ์งํ๋ค. ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ ๊ฒฝ์ฐ์๋ next ๋ฉ์๋๋ ์ ์ฅ๋์ด ์๋ ์์์ ์ฐธ์กฐ ๊ฐ์ ๋ฐ๋ก ๋ฐํํ์ง ์๊ณ , ์์๋ฅผ ๋ณต์ ํ์ฌ ๋ฐํํด์ฃผ์ด์ผ ํ๋ค.
5.4. SortedList
SortedList ADT UnsortedList์ ์ ๊ณตํด์ผ ๋๋ ์ฐ์ฐ์ด ์ ์ฌํ๋ค. ๋ฆฌ์คํธ๊ฐ ๋ด๋ถ์ ์ผ๋ก ์ ๋ ฌ๋์ด ์ ์ง๋๋ ์ ๋ ฌ๋์ง ์์ ์ํ๋ก ์ ์ง๋๋ ์ธ๋ถ์์ ๋ณด๋ ๊ด์ ์์๋ ์ฐจ์ด๊ฐ ์๋ค. ์ฌ์ฌ์ฉ์ ๊ณ ๋ ค ๋ฐฉ๋ฒ1. ๋ฐฉ๋ฒ1. ์ง์ ์์ ร ๋ ผ๋ฆฌ์ ์ผ๋ก SortedList๊ฐ UnsortedList์ ์์ ํด๋์ค๋ ์๋๋ค. SortedList is a UnsortedList (?) ๋ ผ๋ฆฌ์ ์ผ๋ก ์์์ด ์ ํฉํ์ง ์์๋ ์์์ ์ฌ์ฉํ ์ ์์ง๋ง ๋ค์๊ณผ ๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์๋ค. ์4.3) UnsortedList unsorted; SortedList sorted = new SortedList(10); unsorted = sorted; // ???
SortedList๋ ์์ ๊ตฌํํ UnsortedList์ ์ ๊ณตํด์ผ ๋๋ ์ฐ์ฐ์ด ๋งค์ฐ ์ ์ฌํ๋ค. ์ค์ ๋ด๋ถ์ ์ผ๋ก๋ SortedList๋ ์์๋ค์ ์ด๋ค ๊ธฐ์ค์ ๋ฐ๋ผ ์ ๋ ฌํ์ฌ ์ ์งํด์ผ ํ์ง๋ง ์ฌ์ฉํ๋ ์ธก์์ ๋ UnsortedList์ ์ฐจ์ด๊ฐ ์๋ค. ์ด๋ ๊ฒ ์ ์ฌํ ์ฐ์ฐ๋ค์ ์ ๊ณตํ๋ ADT๋ฅผ ๋ง๋ค ๋ ์ฝ๋๋ฅผ ์ต๋ํ ์ฌ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ์๋ฐ์์๋ ํฌ๊ฒ ์ธ ๊ฐ์ง ๋ฐฉ์์ผ๋ก ์ฌ์ฌ์ฉ์ ๊ณ ๋ คํ ์ ์๋ค. ์ฒซ์งธ, UnsortedList๋ก๋ถํฐ ์ง์ ์์๋ฐ์ SortedList๋ฅผ ๊ตฌํํ๋ ๊ฒ์ด๋ค. ํ์ง๋ง ์ ์์ ๋ ผ๋ฆฌ์ ์ผ๋ก ์์ ๊ด๊ณ๊ฐ ์ฑ๋ฆฝํ๋ ๊ฒฝ์ฐ์๋ง ์ฌ์ฉํด์ผ ํ๋ค. ๋จ์ํ ์ฝ๋ ์ฌ์ฌ์ฉ ๋ชฉ์ ์ผ๋ก ๋ ผ๋ฆฌ์ ์ผ๋ก ์์ ๊ด๊ณ๊ฐ ์ฑ๋ฆฝ๋์ง ์๋ ๊ฒ์ ์์ํ๋ ๊ฒ์ ๋ฐ๋์งํ์ง ์๋ค.
- 56 -
SortedList ADT โ ๊ณ์ ๋ฐฉ๋ฒ2. ๋ฐฉ๋ฒ2. abstract ํด๋์ค ์ฌ์ฉ List๋ผ๋ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ , UnsortedList์ SortedList ๋ชจ๋ List์ ์์ ํด๋์ค๋ก ๋ง๋ ๋ค. ์ด ๊ฒฝ์ฐ ๋ ํด๋์ค์ ๊ณตํต๋ ์ฝ๋๋ List์ ํ๋ฒ ์ ์ํ์ฌ ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง search, insert, delete ๋ฉ์๋๋ ๋ ํด๋์ค์ ๊ฒฝ์ฐ ๋ฌ๋ผ์ผ ํ๋ฏ๋ก List์์ ์ ๊ณตํ ์ ์๋ค. ร ์ถ์ ํด๋์ค ๋ฐฉ๋ฒ3. ๋ฐฉ๋ฒ3. ์ธํฐํ์ด์ค ์ฌ์ฉ ์ธํฐํ์ด์ค๋ ์ฝ๋์ ์ฌ์ฌ์ฉ์ ์๋๋ค. ์ฌ์ฉ์์๊ฒ ๋ ํด๋์ค๊ฐ ๊ณตํต๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํ๋ค๋ ๊ฒ์ ์๋ ค์ฃผ๋ ์ญํ ๋ฐ์ ์์ UnsortedList์ SortedList๊ฐ List ํด๋์ค ์ธ์ ๋ค๋ฅธ ํด๋์ค๋ฅผ ์์๋ฐ์์ผ ํ๋ฉด ์ธํฐํ์ด์ค๊ฐ ์ ์ผํ ๋์
๋์งธ, ์ถ์ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์ฆ, List๋ผ๋ ์ถ์ ํด๋์ค๋ฅผ ๋ง๋ค๊ณ , UnsortedList์
SortedList๊ฐ ๋ชจ๋ List์ ์์ ํด๋์ค๊ฐ ๋๋๋ก ๋ง๋๋ ๊ฒ์ด๋ค. ์ด ๊ฒฝ์ฐ ๋ ํด๋์ค์ ๊ณตํต๋ ์ฝ๋๋ List ํด๋์ค์ ํ๋ฒ๋ง ์ ์ํ๋ฉด ๋๋ค. ์๋ฅผ ๋ค์ด isFull, isEmpty, size ๋ฉ์๋ ๋ฑ์ ์ ๋ ฌ ๋ฆฌ์คํธ๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ ๊ฐ์ผ๋ฏ๋ก ์ด๋ค์ List ํด๋์ค์ ์ ์ํ๋ค. ์ ์งธ, ์ธํฐํ์ด์ค ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ํ์ง๋ง ์ธํฐํ์ด์ค๋ ์ฝ๋๋ฅผ ์ฌ์ฌ์ฉํ๋ ๊ฒ์ด ์๋๋ฏ๋ก ์ด ๊ฒฝ์ฐ์๋ ๋ ๋ฒ์งธ ๋ฐฉ๋ฒ์ด ๊ฐ์ฅ ๋ฐ๋์งํ๋ค. public abstract class List{ public final int DEF_CAPACITY=50; protected Object[] elements; protected int size = 0; protected int cursor = -1; public List(){ โฆ } public List(int capacity){ โฆ } private void setup(int capacity){ โฆ } public boolean isFull(){ return (size >= element.length); } public int size(){ return size; } public boolean isEmpty(){ return (size == 0); } public abstract boolean search(Object item); public abstract boolean insert(Object item); public abstract boolean delete(Object item); public abstract Object retrieve(Object item); public void reset(){ cursor = 0; } public List(){ public boolean hasNext(){ setup(DEF_CAPACITY); return cursor<size; } } public List(int capacity){ public Object next(){ if(capacity>0) setup(capacity); int loc = cursor; else setup(DEF_CAPACITY); cursor++; } return element[loc]; private void setup(int capacity){ } elements = new Object[capacity]; } // List }
List ์ถ์ ํด๋์ค๋ ์ ์ฌ๋ผ์ด๋์ ๊ฐ์ด ์ ์ํ ์ ์๋ค.
- 57 -
SortedList ADT public class SortedList extends List{ public SortedList(){ super(); } public SortedList(int capacity){ super(capacity); } public boolean search(Object item){ โฆ } public boolean insert(Object item){ โฆ } public boolean delete(Object item){ โฆ } public Object retrieve(Object item){ โฆ } } // SortedList
List ์ถ์ ํด๋์ค๋ฅผ ์์๋ฐ์ ๊ตฌํํ SortedList ํด๋์ค๋ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค.
boolean insert(Object item) ์ฌ์ ์กฐ๊ฑด: item!=null, ๋ฆฌ์คํธ๊ฐ full์ด ์๋ ์ฌํ์กฐ๊ฑด: ๋ฆฌ์คํธ๊ฐ ๊ณ์ ์ ๋ ฌ๋์ด ์๋๋ก ์ฃผ์ด์ง item์ ์ถ๊ฐํ๋ค. ์ถ๊ฐ์ ์ฑ๊ณตํ๋ฉด true๋ฅผ, ๋ชปํ๋ฉด false๋ฅผ ๋ฐํํ๋ค. ๋ฐฉ๋ฒ 1. ์ฝ์ ํ ์์น๋ฅผ ์ฐพ๋๋ค. 2. ์ฝ์ ํ ๊ณต๊ฐ์ ๋ง๋ ๋ค. 3. ์ ์์๋ฅผ ๋ฆฌ์คํธ์ ์ฝ์ ํ๋ค. ์ด ๋ ๋งจ ์์, ์ค๊ฐ์, ๋์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ๋งจ ์์ด๋ ์ค๊ฐ์ด๋ ์ ์ฐจ๋ ๊ฐ๋ค.
public boolean insert(Object item){ int loc = 0; boolean moreToSearch = (loc<size); if(item!=null || isFull()) return false; Comparable x = (Comparable)item; while(moreToSearch){ if(x.compareTo(elements[loc])<0) moreToSearch = false; else{ loc++; moreToSearch = (loc < size); } } // while for(int i=size; i>loc; i--) elements[i] = elements[i-1]; elements[loc] = item; size++; return true; }
์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ฝ์ ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๋นํด ๋ณต์กํ๋ค. ์ด๊ฒ์ ์ฃผ์ด์ง ์์๋ฅผ ์๋ฌด ์์น ์ ์ ์ฅํ ์ ์๊ณ ๊ธฐ์กด ์์๋ค๊ณผ ๋น๊ตํ์ฌ ์ฝ์ ํ ์์น๋ฅผ ๊ฒฐ์ ํด์ผ ํ๋ค. ๋ํ ๊ธฐ์กด ์์ ๋ค ์ฌ์ด์ ์ ์ฅํด์ผ ํ ๊ฒฝ์ฐ์๋ ์ ์ฅ๋์ด ์๋ ์ผ๋ถ ์์๋ค์ ์ด๋ํ์ฌ ์ ์์๊ฐ ์ฝ์ ๋ ์๋ฆฌ๋ฅผ ๋ง๋ค์ด ์ฃผ์ด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค. ๊ธฐ์กด ์์๋ค๊ณผ์ ๋น๊ต๋ compareTo ๋ฉ์๋๋ฅผ ์ฌ์ฉํ ๊ฒ ๋๋ค. ๋ฐ๋ผ์ ์ธ์๋ก ์ฃผ์ด์ง ๊ฐ์ฒด๋ ๋ฌผ๋ก ์ ์ฅ๋์ด ์๋ ์์๋ค์ Comparable ์ธํฐํ์ด ์ค๋ฅผ ๊ตฌํํ๊ณ ์๋ ํด๋์ค์ ์ธ์คํด์ค์ด์ด์ผ ํ๋ค. ์ ์ฌ๋ผ์ด๋์์ ์์๋ฅผ ๋ฆฌ์คํธ ๋งจ ๋ ์ ์ฝ์ ํ ๊ฒฝ์ฐ์๋ loc์ ๊ฐ ๋๋ฌธ์ for ๋ฌธ์ ์คํ๋์ง ์๋๋ค.
- 58 -
boolean insert(Object item) A
B
A
B
A
B
D
C
E D
E
D
E public boolean insert(Object item){ int loc; if(item!=null || isFull()) return false; Comparable x = (Comparable)item; for(loc=0; loc<size; loc++){ if(item.compareTo(elements[loc])<0) break; for(int i=size; i>loc; i--) elements[i] = elements[i-1]; elements[loc] = item; size++; return true; }
boolean delete(Object item) ์ฌ์ ์กฐ๊ฑด: item!=null, ์ฌํ์กฐ๊ฑด: item์ด ๋ฆฌ์คํธ์ ์กด์ฌํ๋ฉด ์ญ์ ํ๋ค. ์ญ์ ์ ์ฑ๊ณตํ๋ฉด true๋ฅผ, ๋ชปํ๋ฉด false๋ฅผ ๋ฐํํ๋ค.
A
B
C
D
A
B
D
E
E
public boolean delete(Object item){ int loc = 0, comp = 0; boolean moreToSearch = (item!=null)&&(loc<size); boolean found = false; Comparable x = (Comparable)item; while(moreToSearch && !found){ comp = x.compareTo(elements[loc]); if(comp==0) found = true; else if(comp<0) moreToSearch = false; else{ loc++; moreToSearch = (loc < size); } } // while if(found){ for(int i=loc; i<size-1; i++) elements[i] = elements[i+1]; size--; return true; } else return false; }
์ญ์ ์ฐ์ฐ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ์ญ์ ์ ์ ์ฌํ๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ์๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ฒ๋ผ ๋งจ ๋ ์์๋ฅผ ์ญ์ ํ ์์์ ๋์ฒดํ์ฌ ์ญ์ ํ ์ ์๊ณ , ์ญ์ ํ ์์์ ์ค๋ฅธ์ชฝ์ ์๋ ๋ชจ๋ ์ ์๋ค์ ํ๋์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ค.
- 59 -
public boolean delete(Object item){ if(item==null) return false; int loc = 0, comp = 0; boolean found = false; Comparable x = (Comparable)item; for(loc=0; loc<size; loc++){ comp = item.compareTo(elements[loc]); if(comp==0){ found = true; break; } else if(comp<0){ found = false; break; } } // for if(found){ for(int i=loc; i<size-1; i++) elements[i] = elements[i+1]; size--; return true; } else return false; }
public boolean search(Object item){ int first = 0, mid = 0, last = size-1, comp = 0; boolean moreToSearch = true; boolean found = false; if(item!=null || isEmpty()) return false; Comparable x = (Comparable)item; while(moreToSearch && !found){ mid = (first + last) / 2; comp = x.compareTo(elements[mid]); if(comp==0) found = true; else if(comp<0){ last = mid - 1; moreToSearch = (first <= last); } else{ first = mid + 1; moreToSearch = (first <= last); } ์ฌ์ ์กฐ๊ฑด: item!=null, } // while return found; ์ฌํ์กฐ๊ฑด: item์ด ๋ฆฌ์คํธ์ ์์ผ๋ฉด true๋ฅผ, } ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค.
A
B
C
D
E
F
G
H
D
E
F
G
H
D
E
F
G H
first=0 last=7 mid=3 A
B
C
first=0 last=2 mid=1 A
B
C
first=2 last=2 mid=2
์์๋ค์ด ์ ๋ ฌ๋์ด ์ ์ง๋๊ณ ์๋ ๊ฒฝ์ฐ์๋ ์ ํ ๊ฒ์์ ํ์ง ์๊ณ ์ด์ง ๊ฒ์์ ํ ์ ์ ๋ค. ๋ํ ์ ํ ๊ฒ์์ ํ๋๋ผ๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ์ค๊ฐ์ ๋ฉ์ถ ์ ์๋ค. ์ด์ง ๊ฒ์์ ํ๋ฒ ๋น๊ตํ ๋๋ง๋ค ๋ค์์ ๋น๊ตํด์ผ ํ๋ ์์์ ๊ฐ์๋ฅผ ๋ฐ์ฉ ์ค์ด๋ ๋ฐฉ์์ด๋ค. ์ฆ, ์ฒ์ ์ 10๊ฐ์ ์์๊ฐ ์์ ๋ ํ๋ฒ ๋น๊ตํ ํ์๋ ์ด ์ค์ 5๊ฐ๋ ํ๋ณด์์ ์ ์ธํ ์ ์๋ค. ์ด ์ฌ๋ผ์ด๋์ ์๋ ์์ ๋ C๋ฅผ ์ฐพ๋ ๊ฒฝ์ฐ์ด๊ณ , ๋ค์ ์ฌ๋ผ์ด๋์ ์๋ ์์ ๋ F๋ฅผ ์ฐพ๋ ๊ฒฝ์ฐ ์ด๋ค.
- 60 -
A
B
C
D
E
G
H
A
B
C
D
E
G
H
A
B
C
D
E
G
H
A
B
C
D
E
G
H
first=0 last=6 mid=3 first=4 last=6 mid=5 first=4 last=4 mid=4
first=5 last=4 mid=?
5.5. ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ์ด์ง ๊ฒ์ํ์ฌ ์์๋ฅผ ์ฐพ์ ์๋ ์๊ณ , ์ ํ ๊ฒ์์ ํ์ฌ ์์๋ฅผ ์ฐพ์ ์๋ ์๋ค. ์ฆ, ์ด๋ค ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ด ์ค์ง ํ๋ ์กด์ฌํ๋ ๊ฒ์ ์๋๋ค. ์ฌ๋ฌ ํด๊ฒฐ์ฑ ์ด ์กด์ฌํ ๋ ์ด๋ค ํด๊ฒฐ์ฑ ์ ์ฌ์ฉํ ๊ฒ์ธ์ง ๊ฒฐ์ ํ ์ ์์ด์ผ ํ๋ค.
์๊ณ ๋ฆฌ์ฆ ๋น๊ต ์๊ณ ๋ฆฌ์ฆ์ ๋น๊ต๋ ๋ณดํต ์ฑ๋ฅ์ ๋น๊ต Which one is faster(efficient)? ๋น๊ตํ๊ธฐ ์ํด์๋ ๋น๊ต ๊ธฐ์ค์ด ์์ด์ผ ํ๋ค. ๊ฐ์ฅ ๋จ์ํ ๋ฐฉ๋ฒ: ์คํ ์๊ฐ ๋น๊ต ์ฃผ์ด์ง ์ ๋ ฅ์ ๋ํด ์ฃผ์ด์ง ์ปดํจํฐ์์๋ A ์๊ณ ๋ฆฌ์ฆ์ด B ์๊ณ ๋ฆฌ์ฆ๋ณด๋ค๋ ํจ์จ์ ์ด๋ผ๋ ๊ฒ ๋ฐ์๋ ์ ์ ์๋ค. ์ํ๋๋ ํ๋ก๊ทธ๋จ ๋ฌธ์ฅ ์๋ฅผ ๋น๊ต ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ์์กดํ๋ค. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ง๋ค ๋ค๋ฅผ ์ ์๋ค. ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ด ๋๋ ์ฐ์ฐ์ ์ํ ํ์ ๋น๊ต ๊ฒ์: ๋น๊ต ์ฐ์ฐ ์ฃผ์ด์ง ์ ๋ ฅ์ ๋ํ ํจ์๋ก ํ์๋ฅผ ๋ํ๋
์๊ณ ๋ฆฌ์ฆ์ ๋น๊ตํ ๋์๋ ๋ณดํต ์ฑ๋ฅ์ ๋น๊ตํ๋ค. ์ฑ๋ฅ ์ธ์ ํ์ํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ๋ฑ ๋ค๋ฅธ ๊ธฐ์ค์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ฐ์์ฑ์ ๋น๊ตํ ์๋ ์๋ค. ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ๋น๊ตํ๊ธฐ ์ํด์๋ ๋น ๊ต ๊ธฐ์ค์ด ์์ด์ผ ํ๋ค. ๊ฐ์ฅ ๋จ์ํ ๋ฐฉ๋ฒ์ ์คํ ์๊ฐ์ ๋น๊ตํ๋ ๊ฒ์ด๋ค. ํ์ง๋ง ์คํ ์ ๊ฐ์ ์ปดํจํ ํ๊ฒฝ์ ๋ฐ๋ผ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์ ๋์ ์ธ ๋น๊ต ๊ธฐ์ค์ด ๋๊ธฐ ์ด๋ ต๋ค. ์ํ๋๋ ํ๋ก ๊ทธ๋จ์ ๋ฌธ์ฅ ์๋ฅผ ๋น๊ตํ๋ ๊ฒ๋ ์ญ์ ๊ณตํํ ๋น๊ต๊ฐ ๋๊ธฐ ์ด๋ ต๋ค. ํ๋ก๊ทธ๋จ์ ๋ฌธ์ฅ ์๋ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ๋ง์ด ์์กดํ๋ฉฐ, ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฐ๋ผ ๋ค๋ฅผ ์๋ ์๋ค. ๋ฐ๋ผ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ๋น๊ตํ ๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๊ธฐ์ค์ ์๊ณ ๋ฆฌ์ฆ์ ํต์ฌ์ด ๋๋ ์ฐ์ฐ์ ์ํ
- 61 -
ํ์์ด๋ค. ์๋ฅผ ๋ค์ด ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ๋น๊ต ์ฐ์ฐ์ด ํต์ฌ ์ฐ์ฐ์ด ๋๋ฉฐ, ๋น๊ต ์ฐ์ฐ์ ์ผ๋ง๋ ๋ง์ด ํ๋๋์ ๋ฐ๋ผ ๊ฒ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ๊ฒฐ์ ๋๋ค.
Big-O ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ = ํต์ฌ ์ฐ์ฐ์ ์ํ ํ์ = f(์ ๋ ฅ์ ํฌ๊ธฐ) Big-O ํ๊ธฐ๋ฒ์ ์ด์ฉํ์ฌ ํจ์๋ฅผ ์์ฝํ์ฌ ํํํ ์ ์๋ค. ์4.4) f(N)=N4+100N2+10N+50 ร O(N4) N์ด ๋งค์ฐ ํฌ๋ฉด N4๊ฐ ๋ค๋ฅธ ๊ฒ์ ์๋ํ๊ฒ ๋๋ค. ์ ๋ ฅ์ ํฌ๊ธฐ๋? ๊ณ ๋ ค๋๋ ๋ฌธ์ ์ ํฌ๊ธฐ ร ์4.5) ๋ฆฌ์คํธ์ ์๋ ์์์ ๊ฐ์ ์4.6) ๋ฆฌ์คํธ์ ์๋ ์์๋ฅผ ํ์ผ์ ๊ธฐ๋กํ๊ธฐ open file while(more elements in list) write the next element close file (Nยฑํ ์์๋ฅผ ๊ธฐ๋กํ๋๋ฐ ์์๋๋ ์๊ฐ) + (ํ์ผ ์ด๊ณ ๋ซ๋ ์๊ฐ) O(N)
์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ๋ํ๋ผ ๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ํ๊ธฐ๋ฒ ์ค ํ๋๋ Big-O ํ๊ธฐ๋ฒ์ด๋ค. ์ด ํ๊ธฐ๋ฒ์ ํต์ฌ ์ฐ์ฐ์ ์ํ ํ์๋ฅผ ์ ๋ ฅ ํฌ๊ธฐ์ ๊ดํ ํจ์๋ก ๋ํ๋ธ๋ค. ์ฌ๊ธฐ์ ์ ๋ ฅ ํฌ๊ธฐ๋ ๊ณ ๋ ค๋๋ ๋ฌธ์ ์ ํฌ๊ธฐ๋ก์ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ๋ฆฌ์คํธ์ ์๋ ์์์ ๊ฐ์๋ฅผ ์ ๋ ฅ ํฌ๊ธฐ๋ก ์ฌ ์ฉํ ์ ์๋ค. Big-O ํ๊ธฐ๋ฒ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ ๋ํ๋ผ ๊ฒฝ์ฐ์๋ ๊ฐ์ฅ ์๋ํ๋ ์์๋ง ์ ์ฌ์ฉํ์ฌ ๋ณดํต ์ถ์ฝํ์ฌ ๋ํ๋ธ๋ค.
Common Order of Magnitude O(1): ์ ๋ ฅ ํฌ๊ธฐ์ ์ ํ ์ํฅ์ ๋ฐ์ง ์๋ ๊ฒฝ์ฐ ์4.7) ๋ฐฐ์ด์ ํ ์์ ์ ์ฅํ๊ธฐ O(logN): ๋ก๊ทธ ์๊ฐ ํ๋ฒ์ ์ฒ๋ฆฌํด์ผ ํ๋ ์์ด ๋ฐ์ฉ ์ค์ด๋๋ ๊ฒฝ์ฐ ์4.8) ์ด์ง ๊ฒ์ N logN NlogN O(N): ์ ํ ์๊ฐ 1 0 1 ์4.9) ์ ํ ๊ฒ์ 4 2 8 O(NlogN) O(N2) 8 3 24 O(2N): ์ง์ ์๊ฐ 32 5 160 O(N!): ๊ณ์น ์๊ฐ 256
8
2048
N2
2N
1
2
16
16
256
65536
32768
5๋
16777216
donโt ask
์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ์ Big-O ํ๊ธฐ๋ฒ์ ๋ฐ๋ผ ๋ช ๊ฐ์ ๊ทธ๋ฃน์ผ๋ก ๋๋ ์ ์๋ค. O(1)์ ์์ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ํ๋ฉฐ, ์ด๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ ๋ ฅ ํฌ๊ธฐ์ ์ ํ ์ํฅ์ ๋ฐ์ง ์๊ณ ํญ์ ์ผ์ ํ ์๊ฐ ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค. O(logN)์ ๋ก๊ทธ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ํ๋ฉฐ, ์ด๋ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ง ๊ฒ์ ์ฒ๋ผ ํ๋ฒ์ ์ฒ๋ฆฌํด์ผ ํ๋ ์์ด ๋ฐ์ฉ ์ค์ด๋ ๋ค. O(N)์ ์ ํ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ํ๋ฉฐ, ์ ๊ณ ๋ฆฌ์ฆ ์ฑ๋ฅ์ด ์ ๋ ฅ ํฌ๊ธฐ์ ๋น๋กํ์ฌ ์ฆ๊ฐํ๋ค. ํ์์ ์ ์ ์๋ฏ์ด O(NlogN)๊น์ง๋ง ์ ๋ ฅ ํฌ๊ธฐ์ ๋ฌด๊ดํ๊ฒ ์ฌ์ฉํ ์ ์๋ ์ค์ฉ์ ์ธ ์๊ณ ๋ฆฌ์ฆ์ด๋ผ ๋ณผ ์ ์์ผ๋ฉฐ, ๊ทธ ์ด์์ ์๊ณ ๋ฆฌ์ฆ
- 62 -
์ ์ ๋ ฅ ํฌ๊ธฐ๊ฐ ์กฐ๊ธ๋ง ์ปค์ ธ๋ ํ์ค์ ์ผ๋ก ์ฌ์ฉํ๊ธฐ๊ฐ ์ด๋ ต๋ค.
1๋ถํฐ N๊น์ง ํฉ์ฐํ๋ ์๊ณ ๋ฆฌ์ฆ ์๊ณ ๋ฆฌ์ฆ 1. sum = 0; for(int i=1; i<=n; i++) sum = sum + count; ์๊ณ ๋ฆฌ์ฆ 2. sum = ((n+1) * n)/2; ์๊ณ ๋ฆฌ์ฆ 1์ O(N)์ด์ง๋ง ์๊ณ ๋ฆฌ์ฆ 2๋ O(1)์ด๋ค. ํ์ง๋ง ๊ธฐ์ค์ด ๋๋ ์ฐ์ฐ์ด ๋ค๋ฅด๋ค. ๊ทธ๋ฌ๋ฉด ํญ์ ์๊ณ ๋ฆฌ์ฆ 2๊ฐ ์๊ณ ๋ฆฌ์ฆ 1๋ณด๋ค ์ข์๊ฐ? N์ด ๋งค์ฐ ์์ ๊ฒฝ์ฐ์๋ ์๊ณ ๋ฆฌ์ฆ 1์ ๋ง์ ์ฐ์ฐ๋ง ์ฌ์ฉํ๋ฏ๋ก ๋ ์ข์ ์ ์๋ค. ์๊ณ ๋ฆฌ์ฆ ์ดํด๋ ์ธก๋ฉด์์ ์๊ณ ๋ฆฌ์ฆ 1์ด ๋ ์ข์ ์ ์๋ค. Big-O๋ N์ด ๋งค์ฐ ํด ๊ฒฝ์ฐ์ ๋ํ ๋น๊ต ์ฒ๋์ด๋ค.
1๋ถํฐ N๊น์ง ํฉ์ฐํ๋ ๋ ์ข ๋ฅ์ ์๊ณ ๋ฆฌ์ฆ์ Big-O ํ๊ธฐ๋ฒ์ ์ด์ฉํ์ฌ ๋ํ๋ด๋ณด์. ์ฐ์ ์ฐ์ ์ฐ์ฐ์ ๊ธฐ๋ณธ ์ฐ์ฐ์ผ๋ก ์๊ฐํ๋ฉด ์๊ณ ๋ฆฌ์ฆ 1์ N๋ฒ์ ๋ง์ ์ด ํ์ํ๋ฏ๋ก O(N)์ด๋ฉฐ, ์ ๊ณ ๋ฆฌ์ฆ 2๋ ์ ๋ ฅ์ ํฌ๊ธฐ์ ์๊ด์์ด ๋ง์ , ๊ณฑ์ , ๋๋์ ์ด ๊ฐ๊ฐ ํ๋ฒ์ฉ ํ์ํ๋ฏ๋ก O(1)์ด ๋ค. ์ด ๊ฒฝ์ฐ N์ด ์ปค์ง๋ฉด ์๊ณ ๋ฆฌ์ฆ 2๊ฐ ํจ์ฌ ์ฑ๋ฅ์ด ์ข๋ค. ํ์ง๋ง N์ด ์์ ๊ฒฝ์ฐ์๋ ์๊ณ ๋ฆฌ์ฆ 1์ด ์คํ๋ ค ๋ ์ข๋ค. ๊ทธ๊ฒ์ ๋ง์ ์ด ๊ณฑ์ ๋๋ ๋๋์ ์ ๋นํด ๋งค์ฐ ์ ๋ ดํ ์ฐ์ฐ์ด๊ธฐ ๋๋ฌธ์ด๋ค. ์ฆ, Big-O๋ ์์ฝํ์ฌ ์ฑ๋ฅ์ ๋ํ๋ด๋ฏ๋ก N์ด ๋งค์ฐ ํด ๊ฒฝ์ฐ์๋ง ์ ํํ๊ฒ ์ ์ฉ๋ ์ ์๋ค.
UnsortedList์ SortedList์ ๋น๊ต ์ฐ์ฐ
UnsortedList
SortedList
size, isFull, isEmpty, reset, next
O(1)
O(1)
search
O(N)
O(N) O(logN) ์ด์ง๊ฒ์
insert ์ฐพ๊ธฐ ์ฝ์ ์ ์ฒด
O(1) O(1) O(1)
O(N) O(N) O(N)
delete ์ฐพ๊ธฐ ์ญ์ ์ ์ฒด
O(N) O(1) O(N)
O(N) O(N) O(N)
์ด ์ฅ์์ ์ดํด๋ณธ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ Big-O ํ๊ธฐ๋ฒ์ ์ด์ฉํ์ฌ ๋น๊ตํ์ฌ ๋ณด์. ๊ฒ์ ์ฐ์ฐ์ ๊ฒฝ์ฐ์๋ ์ ๋ ฌ ๋ฆฌ์คํธ๋ ์ด์ง ๊ฒ์์ ํ ์ ์์ผ๋ฏ๋ก ์ฑ๋ฅ์ด ๋ ์ข๋ค. ํ์ง๋ง ์ฝ์ ์ ์ ๋ ฌ ๋ฆฌ์คํธ๋ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ์์ผ ํ๋ฏ๋ก ๋น์ ๋ ฌ ๋ฆฌ์คํธ๊ฐ ๋ ์ข๋ค.
์ญ์ ๋ ๋
๋ค ์ญ์ ํ๊ณ ์ ํ๋ ์์๋ฅผ ์ฐพ์์ผ ํ๋ ๋น์ฉ์ด ์์๋์ง๋ง ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ์ญ์ ์์ฒด๋ ์์ ์๊ฐ์ ํ ์ ์๋ค.
- 63 -
์ 6์ฅ ์คํ, ํ ์ด ์ฅ์์๋ ๋ฐฐ์ด์ ์ด์ฉํ ์คํ(stack)๊ณผ ํ(queue) ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ ๋ฐฉ๋ฒ์ ์ดํด๋ณธ๋ค.
6.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์คํ๊ณผ ํ์ ํน์ฑ์ ์ดํด๋ณด๊ณ , ๋ฐฐ์ด์ ์ด์ฉํ ์คํ๊ณผ ํ์ ๊ตฌํ๋ฐฉ๋ฒ์ ํ์ตํ๋ค.
6.2. ์คํ
์คํ โ ๋ ผ๋ฆฌ์ ๋จ๊ณ ์คํ์ ํน์ฑ ์์๊ฐ ์๋ ๋์ง ๊ตฌ์กฐ ๊ฐ์ฅ ์ต๊ทผ์ ์ถ๊ฐ๋ ์์๊ฐ ๋งจ ์(top)์ ์๊ณ , ๊ฐ์ฅ ์ค๋ ์ ์ ์ถ๊ฐ๋ ์์๊ฐ ๋งจ ๋ฐ(bottom)์ ์๋ค. LIFO(LastLIFO(Last-InIn-FirstFirst-Out) ๊ตฌ์กฐ: ๊ตฌ์กฐ ์์์ ์ ๊ฑฐ ๋๋ ์ถ๊ฐ๋ ์คํ์ top์์๋ง ์ด๋ฃจ์ด์ง๋ค. ์ฐ์ฐ push: ์์๋ฅผ ์ถ๊ฐํ๋ ์ฐ์ฐ pop: ์์๋ฅผ ์คํ์์ ์ ๊ฑฐํ๊ณ , ๋งจ ์ ์์๋ฅผ ๋ฐํํด์ฃผ๋ ์ฐ์ฐ top: ์คํ์ ๋ณํ ์์ด ๋งจ ์ ์์๋ฅผ ๋ฐํํด์ฃผ๋ ์ฐ์ฐ
์คํ์ ๋ฆฌ์คํธ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋์ง ๊ตฌ์กฐ์ด๋ค. ํ์ง๋ง ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ํญ์ ๊ฐ์ ์์น์์ ์ด ๋ฃจ์ด์ง๋ ๊ตฌ์กฐ์ด๋ค. ๋์ ์ ์๋๋ค๊ณ ์๊ฐํ์ฌ ๋ณด์. ๊ทธ๋ฌ๋ฉด ๋์ ์ ์ถ๊ฐ๋ ํญ์ ๋งจ ์์ ์ฌ๋ ค๋์ ์๋ฐ์ ์๋ค. ๋ํ ๋์ ์ ์ ๊ฑฐ๋ ๋งจ ์์์๋ง ๊ฐ๋ฅํ๋ค. ์ด๋ฐ ํํ๋ฅผ ์คํ์ด๋ผ ํ๋ค. ์ด ๋ ์์๊ฐ ์ถ๊ฐ๋๊ณ , ์ญ์ ๋๋ ์์น๋ฅผ ์คํ์ ํฑ(top)์ด๋ผ ํ๋ค. ์ด๋ฐ ๋ฐฉ์์ผ๋ก ์ถ
- 65 -
๊ฐ์ ์ญ์ ๊ฐ ์ด๋ฃจ์ด์ง๊ธฐ ๋๋ฌธ์ ์คํ์ LIFO(Last-In-First-Out) ๊ตฌ์กฐ๋ผ ํ๋ค. ์ฆ, ๊ฐ์ฅ ๋์ค ์ ์ถ๊ฐ๋ ์์๊ฐ ๊ฐ์ฅ ๋จผ์ ์ถ์ถ๋๋ ๊ตฌ์กฐ์ด๋ค. ์คํ์ ๋ณดํต ํฌ๊ฒ push, pop, top ์ธ ๊ฐ์ง ์ฐ์ฐ์ ์ ๊ณตํ๋ค. push๋ ์์๋ฅผ ์คํ์ ์ถ๊ฐํ ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์ด๊ณ , pop์ ์คํ ํฑ์ ์ ๋ ์์๋ฅผ ์ ๊ฑฐํ ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์ด๋ฉฐ, top์ ์คํ ํฑ์ ์๋ ์์๋ฅผ ์ด๋ํ ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์ด๋ค. push์ pop์ ์คํ์ ์ํ๋ฅผ ๋ณํ์ํค์ง๋ง top์ ์คํ์ ์ํ๋ฅผ ๊ทธ๋๋ก ์ ์งํ ๋ค.
์คํ โ ๋ ผ๋ฆฌ์ ๋จ๊ณ stack = new Stack()
stack.push(2)
stack.push(3)
3 2
stack.top()
stack.pop()
3
2
2
์์ธ ์ํฉ push: ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๊ตฌํํ ๊ฒฝ์ฐ์๋ ๋ ์ด์ ์ถ๊ฐํ ์ ์๋ ์ํฉ์ด ๋ฐ์ํ ์ ์๋ค. pop, top: ์คํ์ ์์๊ฐ ํ๋๋ ์์ ์ ์๋ค.
๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์คํ์ ๊ตฌํํ ๋ ๋ค์๊ณผ ๊ฐ์ ์์ธ ์ํฉ์ ๊ณ ๋ คํด์ผ ํ๋ค. ์ฒซ์งธ, ๋ฐฐ์ด์ ๋ชจ๋ ํญ์ ์์๊ฐ ์์ด ๋ ์ด์ ์ ์์๋ฅผ ์ถ๊ฐํ ์ ์๋ ์ํฉ์ push ์ฐ์ฐ์ ์๋ํ ์ ์๋ค. ๋์งธ, pop, top ์ฐ์ฐ์ ์คํ์ ์๋ฌด๋ฐ ์์๋ ์์ ๋ pop ๋๋ top ์ฐ์ฐ์ ์๋ํ ์ ์๋ค.
์คํ โ ์์ธ StackOverflowException: ์คํ์ด ๊ฝ ์ฐจ์์ ๋ push๋ฅผ ์๋ํ๋ฉด ๋ฐ์ public class StackOverflowException extends RuntimeException{ public StackOverflowException(){ super(โ์คํ์ด ๊ฝ ์ฐจ ์๋ ์ํ์์ push๋ฅผ ์๋ํ์์.โ); } public StackOverflowException(String msg){ super(msg); } }
StackUnderflowException: ์คํ์ด ๋น์ด ์์ ๋ pop ๋๋ top์ ์๋ํ๋ฉด ๋ฐ์ public class StackUnderflowException extends RuntimeException{ public StackUnderflowException(){ super(โ์คํ์ด ๋น์ด ์๋ ์ํ์์ pop/top์ ์๋ํ์์.โ); } public StackUnderflowException(String msg){ super(msg); } }
์ด ์ฅ๋ถํฐ๋ ADT๋ฅผ ๊ตฌํํ ๋ ์์ธ์ ์ธ ์ํฉ์ ๋ํด์๋ ์๋ก์ด ์์ธ๋ฅผ ์ ์ํ์ฌ ์์ธ๋ฅผ ๋ฐ์ํ๋ค. ์คํ์ ๊ฒฝ์ฐ์๋ ์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ๋ ๊ฐ์ง ์ข ๋ฅ์ ์์ธ๊ฐ ์์ ์ ์๋ค. ์ด๋ฅผ ์ํด StackOverflowException๊ณผ StackUnderflowException์ ์ ์ํ์ฌ ์ฌ์ฉํ๋ค. ์ฐธ๊ณ ์
- 66 -
์ผ๋ก ์ ์์ธ ํด๋์ค๋ฅผ ์ ์ํ ๋ ์ด ์์ธ๋ฅผ checked ๋๋ unchecked๋ก ํ ๊ฒ์ธ์ง์ ๋ฐ๋ผ ์์๋ฐ๋ ํด๋์ค๊ฐ ๋ค๋ฅด๋ค. checked ์์ธ์ด๋ฉด Exception ํด๋์ค๋ฅผ ์์๋ฐ๊ณ , unchecked ์ ์ธ์ด๋ฉด RuntimeException ํด๋์ค๋ฅผ ์์๋ฐ๋๋ค. ์ ์์ธ ํด๋์ค๋ฅผ ์ ์ํ ๋์๋ ๋ณดํต ๋ ๊ฐ์ ์์ฑ์๋ง์ ์ ์ํ๋ค. ์ด๋ค ์์ฑ์๋ getMessage ๋ฉ์๋๊ฐ ๋ฐํํ ๋ฉ์์ง๋ฅผ ์ค์ ํด ์ฃผ์ด์ผ ํ๋ค.
์คํ โ ๋ ผ๋ฆฌ์ ๋จ๊ณ ๋ฒ์ฉ ์คํ์ ๊ตฌ์ฑ SortedList์ ๊ฒฝ์ฐ์๋ ์ฝ์ ํ ์์น๋ฅผ ์ ํ๊ธฐ ์ํด ๋น๊ตํ ์ ์์ด์ผ ํ์ง๋ง ์คํ์ ๊ทธ๋ ์ง ์๋ค. ์คํ์์๋ search์ ๊ฐ์ ์ฐ์ฐ์ด ํ์ ์๋ค. Object ํด๋์ค๋ง ํ์ฉํ์ฌ๋ ๊ฐ๋ฅํ๋ค. Object ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ ๊ฒฝ์ฐ์๋ ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๊ธฐ๊ฐ ์ด๋ ต๋ค. ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๊ณ ์ถ์ผ๋ฉด Listable ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ๋ค.
์คํ์ ์ฝ์ ๊ณผ ์ญ์ ์ฐ์ฐ์ด ์ด๋ค ๋น๊ต ์์ด ์์น์ ์ํด ๊ฒฐ์ ๋๋ฏ๋ก equals, compareTo์ ๊ฐ์ ์ฐ์ฐ์ด ํ์ ์๋ค. ๋ฐ๋ผ์ Object ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค. ํ์ง๋ง ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๊ณ ์ ํ ๊ฒฝ์ฐ์๋ 4์ฅ์์ ์ค๋ช ํ ๋ฐ์ ๊ฐ์ด Listable ์ธํฐํ์ด์ค๋ฅผ ํ์ฉํด ์ผ ํ๋ค. ์ด ์ฅ์์๋ Listable ์ธํฐํ์ด์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ฐ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋ค.
ArrayStack ADT ๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๊ตฌํ ์กฐ์ int topindex=-1; void push(Object item); isFull()์ด ์ฐธ์ด๋ฉด Object[] elements; StackOverflowException ์ฐธ๊ณ . ์ฐธ๊ณ . size๊ฐ ํ์ ์์ ๋ฐ์ ์์ฑ์ void pop(); ArrayStack() isEmpty()๊ฐ ์ฐธ์ด๋ฉด ArrayStack(int capacity); StackUnderflowException ๋ฐ์ ์ํ Object top(); boolean isFull(); isEmpty()๊ฐ ์ฐธ์ด๋ฉด ์กฐ๊ฑด: topindex==elements.length-1 StackUnderflowException boolean isEmpty(); ๋ฐ์ ์กฐ๊ฑด: topindex==-1
๋ฐฐ์ด์ ์ด์ฉํ ์คํ ADT๋ ์คํ์ ํฑ์ ๋ํ๋ผ topindex์ ์ถ๊ฐ๋ ์์๋ค์ ์ ์ฅํ Object ๋ฐฐ์ด elements๊ฐ ํ์ํ๋ค. ํ์ง๋ง ์คํ์ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ topindex๋ก๋ถํฐ ์ป ์ ์ ์๊ธฐ ๋๋ฌธ์ ๋ณ๋์ ๋ฉค๋ฒ๋ณ์๋ฅผ ์ ์ธํ์ฌ ์ ์งํ ํ์๊ฐ ์๋ค. isFull๊ณผ isEmpty ๋ฉ์
- 67 -
๋๋ ์ญ์ topindex ์ ๋ณด๋ฅผ ํตํด ํ๋ณํ ์ ์๋ค. Listable ์ธํฐํ์ด์ค๋ฅผ ํ์ฉํ์ฌ ๋ณต์ฌ ๋ฐฉ์ ์ผ๋ก ๊ตฌํํ๋๋ผ๋ ์ด ์ฌ๋ผ์ด๋์ฒ๋ผ ์ ๋ ฅ ํ์ , ์ถ๋ ฅ ํ์ , ๋ด๋ถ ๋ฐฐ์ด ํ์ ์ ๊ณ์ Object๋ฅผ ์ฌ์ฉํ ์ ์๋ค. push ๋ฉ์๋์ ์ธ์ ํ์ ์ Listable๋ก ์ฌ์ฉํ๋ ๊ฒ๊ณผ Object๋ก ์ฌ์ฉํ๋ ๊ฒ์ ์ฐจ์ด์ ์ ๋ค์๊ณผ ๊ฐ๋ค. Listable ํ์ ์ ์ฌ์ฉํ๋ฉด ์ด ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ์ธก์์๋ ์ด ์ฌ์ค์ ์๊ณ ๋ณดํต Listable ํ์ ์ ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ ๊ฒ์ด๋ค. ํ์ง๋ง Object ํ์ ์ผ๋ก ๋์ด ์ ์ผ๋ฉด Listable ํ์ ์ด ์๊ตฌ๋๋์ง ๋ชฐ๋ผ Listable ํ์ ์ด ์๋ ๋ค๋ฅธ ํ์ ์ ๊ฐ์ฒด๋ฅผ ์ ๋ฌํ ์ ๋ ์๋ค. ์ด ์ธก๋ฉด์์ ๋ณด๋ฉด ์ธ์ ํ์ ์ Listable๋ก ์ฌ์ฉํ๋ ๊ฒ์ด ๋ณด๋ค ํจ๊ณผ์ ์ธ ๋ฐฉ๋ฒ์ด์ง ๋ง ์ด๋ฒ ์ฅ์ ์ ์ธํ๊ณ ๋ ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ์ง ์๊ธฐ ๋๋ฌธ์ ์ธ์ ํ์ ์ด๋ ์ถ๋ ฅ ํ์ ์ผ ๋ก Object ํ์ ์ ์ฌ์ฉํ๋ค.
push public void push(Object item) throws StackOverflowException{ if(isFull()) throw new StackOverflowException(โPush attempted on a full stack.โ); Listable x = (Listable)item; topindex++; elements[topindex] = x.clone(); } topindex = -1
topindex = 0
topindex = 1
topindex = 2
2
2
2
push(2)
push(3)
3
push(5)
3 2
2
3
5
5
3 2
๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๊ตฌํํ ๋ 0๋ฒ์งธ ์์ธ์ ์คํ์ ํฑ์ผ๋ก ์ ์งํ๋ฉด topindex ์ ๋ณด ์์ฒด ๋ฅผ ์ ์งํ ํ์๊ฐ ์๋ค. ํ์ง๋ง ๋งค๋ฒ ์ถ๊ฐ ๋๋ ์ญ์ ํ ๋๋ง๋ค ๋ชจ๋ ์์๋ฅผ ํ๋์ฉ ์ด๋ํด ์ผ ํ๋ค. ๋ฐ๋ผ์ ์ด๋ฐ ์ด๋ ์์ด ์ถ๊ฐํ๊ณ ์ญ์ ํ๊ธฐ ์ํด์๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ์์๋ฅผ ์ถ ๊ฐํ๋ฏ์ด ๋งจ ๋์ ์ถ๊ฐํด์ผ ํ๋ค. ๋ฐ๋ผ์ ๋งค๋ฒ ์ถ๊ฐํ ๋๋ง๋ค topindex ์ ๋ณด๋ฅผ ํ๋ ์ฆ๊ฐ์ ํจ ํ์ ๊ทธ ์์น์ ์ถ๊ฐํ๋ค.
- 68 -
push โ ๊ณ์ topindex = 3
2 push(1)
3 5 1
topindex = 4
2
1 5 3 2
push(7)
3 5 1
topindex = 3
7
2
1 5 3 2
push(8)
pop()
์คํจ
3 5 1
1 5 3 2
7
pop, top public void pop() throws StackUnderflowException{ if(isEmpty()) throw new StackUnderflowException(โPop attempted on an empty stackโ); elements[topindex] = null; // ๋ถํ์ topindex--; } public Object top() throws StackUnderflowException{ if(isEmpty()) throw new StackUnderflowException(โTop attempted on an empty stackโ); Listable x = (Listable)elements[topindex]; return x.clone(); }
pop ์ฐ์ฐ์ topindex๋ฅผ ํ๋ ๊ฐ์๋ง ์ํค๋ฉด ๋๋ค. ์ด ๋ elements[topindex] = null ๋ฌธ์ฅ์ ๋ฐ๋์ ํ ํ์๋ ์๋ค. ํ์ง๋ง ์ด๊ฒ์ ์๋ฐ์ garbage collection์ ์ด์ง์ํฌ ์ ์๊ธฐ ๋๋ฌธ ์ ์ฌ์ฉ์์ ํ๋ก๊ทธ๋๋ฐ ์คํ์ผ์ ๋ฐ๋ผ ์ด๋ ๊ฒ ํ๋ ๊ฒ์ ๊ถ์ฅํ๋ ๊ฒฝ์ฐ๋ ์๋ค.
- 69 -
ArrayList๋ฅผ ์ด์ฉํ Stack์ ๊ตฌํ ์ผ๋ฐ ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ public class ArrayListStack{ ์ฉ๋์ด ๊ณ ์ ๋์ด ์์ง private ArrayList stack; ์๋ค. ๋ฐ๋ผ์ push๋ public ArrayListStack(){ stack = new ArrayList(); } ํญ์ ์ฑ๊ณตํ๋ฉฐ, public void push(Object item){ stack.add(item); } isFull์ด ์ฐธ์ด ๋๋ public void pop() throws StackUnderflowException{ ๊ฒฝ์ฐ๊ฐ ์๋ค. if(isEmpty()) add๋ ํญ์ ๋ฆฌ์คํธ throw new StackUnderflowException(โโฆโ); ๋์ ์ถ๊ฐํ๋ค. ๋ฐ๋ผ์ stack.remove(stack.size()-1); ์คํ์ ArrayList๋ก } ๊ตฌํํ์ฌ๋ ๋น์ฉ ์ธก๋ฉด public Object top() throws StackUnderflowException{ ์์ ๋ฌธ์ ๊ฐ ์๋ค. if(isEmpty()) throw new StackUnderflowException(โโฆโ); by clone ๋ฐฉ์์ผ๋ก return stack.get(stack.size()-1); ๋ณ๊ฒฝํ ๊ฒฝ์ฐ์๋ } ๋ค์๊ณผ ๊ฐ์ด ํ๋ค. public boolean isEmpty() { return (stack.size() == 0); } public void push(Object item){ public boolean isFull() { return false; } Listable x = (Listable)item; } stack.add(x.clone()); }
์คํ์ push, pop, top ์ฐ์ฐ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ๋ฆฌ์คํธ์ ๋งจ ๋ ์์๋ฅผ ์กฐ์ํ๋ ๊ฒฝ์ฐ์ ํด๋น๋๋ฏ๋ก ๋จ์ ๋ฐฐ์ด ๋์ ์ ์ด๋ฏธ ๊ฐ๋ฐํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ ์๋ฐ์์ ์ ๊ณตํ๋ ArrayList๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ ์๋ ์๋ค.
- 70 -
6.3. ํ
ํ โ ๋ ผ๋ฆฌ์ ๋จ๊ณ ํ(queue)์ ํน์ฑ ์์๊ฐ ์๋ ๋์ง ๊ตฌ์กฐ ๊ฐ์ฅ ์ต๊ทผ์ ์ถ๊ฐ๋ ์์๊ฐ ๋งจ ๋ค(rear)์ ์๊ณ , ๊ฐ์ฅ ์ค๋ ์ ์ ์ถ๊ฐ๋ ์์๊ฐ ๋งจ ์(front)์ ์๋ค. FIFO(FirstFIFO(First-InIn-FirstFirst-Out) ๊ตฌ์กฐ: ๊ตฌ์กฐ ์์์ ์ถ๊ฐ๋ ํ์ ๋์ ์ด๋ฃจ์ด์ง๊ณ , ์์์ ์ ๊ฑฐ๋ ์์์ ์ด๋ฃจ์ด์ง๋ค. ์ฐ์ฐ enqueue: ์์๋ฅผ ํ์ ๋์ ์ถ๊ฐํ๋ ์ฐ์ฐ dequeue: ํ์ ๋งจ ์์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ๊ณ , ๊ทธ ์์๋ฅผ ๋ฐํํด์ฃผ๋ ์ฐ์ฐ
ํ๋ ์คํ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์์น์ ์ํด ๊ฒฐ์ ๋๋ค. ํ์ง๋ง ์คํ๊ณผ ๋ฌ๋ฆฌ ๊ฐ์ ์ ์น์์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋ชจ๋ ์ด๋ฃจ์ด์ง๋ ๊ฒ์ด ์๋๊ณ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์๋ก ๋ค๋ฅธ ์์น์ ์ผ์ด ๋๋ค. ๋ฒ์ค์ ์น์ฐจํ๊ธฐ ์ํด ์ผ๋ ฌ๋ก ๊ธฐ๋ค๋ฆฌ๋ ์ฌ๋๋ค์ด ๋ฐ๋ก ์ ํ์ ์ธ ํ์ ๋ชจ์ต์ด๋ค. ์ด ๊ฒฝ์ฐ ๊ฐ์ฅ ๋จผ์ ์น์ฐจํ๋ ์ฌ๋์ ์ค ๋งจ ์์ ์๋ ์ฌ๋์ด๊ณ , ๋์ค์ ์จ ์ฌ๋์ผ์๋ก ์ค ๋์ ์๊ฒ ๋๋ค. ๋ฐ๋ผ์ ํ์์ ์ฝ์ ์ ํ์ ๋งจ ๋ค์์ ์ด๋ฃจ์ด์ง๊ณ , ์ญ์ ๋ ๋งจ ์์์ ์ด๋ฃจ์ด์ง ๋ค. ์ด๋ฐ ๋ฐฉ์์ผ๋ก ์์๊ฐ ์ถ๊ฐ๋๊ณ ์ญ์ ๋๋ฏ๋ก ํ๋ฅผ FIFO(First-In-First-Out) ๊ตฌ์กฐ๋ผ ํ๋ค. ํ๋ ํฌ๊ฒ enqueue, dequeue ๋ ๊ฐ์ง ์ฐ์ฐ์ ์ ๊ณตํ๋ค. enqueue๋ ํ์ ์์๋ฅผ ์ถ๊ฐํ ๋ ์ฌ์ฉํ๋ ์ฐ์ฐ์ด๊ณ , dequeue๋ ํ์์ ์์๋ฅผ ์ ๊ฑฐํ ๋ ์ฌ์ฉ๋๋ ์ฐ์ฐ์ด๋ค. ์คํ๊ณผ ๋ฌ๋ฆฌ ํ๋ pop๊ณผ top ์ฐ์ฐ์ ๊ธฐ๋ฅ์ ํ๋์ ์ฐ์ฐ dequeue์์ ๋ชจ๋ ์ ๊ณตํ๋ค.
ํ โ ๋ ผ๋ฆฌ์ ๋จ๊ณ queue = new Queue()
queue.enq(2)
2
queue.enq(3)
3
queue.enq(1)
2
1
3
queue.deq()
2
1
3
์์ธ ์ํฉ enqueue: ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๊ตฌํํ ๊ฒฝ์ฐ์๋ ๋ ์ด์ ์ถ๊ฐํ ์ ์๋ ์ํฉ์ด ๋ฐ์ํ ์ ์๋ค. dequeue: ํ์ ์์๊ฐ ํ๋๋ ์์ ์ ์๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ํ์ ๊ตฌํ๋ ์คํ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐฐ์ด์ ๋ชจ๋ ํญ์ ์์๊ฐ ๋ค์ด์์ ๋
enqueue๋ฅผ ์๋ํ๋ฉด ๊ทธ๊ฒ์ ์ฒ๋ฆฌํ ์ ์๋ค. ํ์ ์์๊ฐ ํ๋๋ ์๋ ๊ฒฝ์ฐ์ dequeue๋ฅผ ์๋ํ๋ ๊ฒฝ์ฐ์๋ ์ ์์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค. ์ด ๋ ๊ฐ์ง ๊ฒฝ์ฐ์ ํด๋นํ๋ ์์ธ ํด๋์ค
- 71 -
QueueOverflowException๊ณผ QueueUnderflowException๋ฅผ ์ ์ํ์ฌ ์ฌ์ฉํ๋ค. ์ด๊ฒ์ ์คํ์ ์ ์์ธ ํด๋์ค๋ฅผ ์ ์ํ ๊ฒ๊ณผ ์ ์ฌํ๊ฒ ์ ์ํ๋ฉด ๋๋ค.
๊ณ ์ ๋ Front ์ค๊ณ ๋ฐฉ๋ฒ front=0, rear=-1 front=0, rear=0
enq(10);
10
enq(20);
10
20
enq(30);
10
20
30
20
30
deq(); 20
front=0, rear=1 front=0, rear=2
front=0, rear=1
30
๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์ฌ๋กฏ์ ํญ์ front๋ก ๊ณ ์ ํด์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ ์ค์ front ๋ฉค๋ฒ ๋ณ์๊ฐ ํ์ ์์ enq๋ ํญ์ size-1 ์ฌ๋กฏ์ ์ถ๊ฐํ๋ฉด ๋๋ค. rear ๋ฉค๋ฒ ๋ณ์๋ ํ์ ์์ front, rear, size ์ค size ํ๋๋ง ์ฌ์ฉํ์ฌ ๊ตฌํ ๊ฐ๋ฅ deq์ ๊ฒฝ์ฐ์๋ ์ต์ ์ ๊ฒฝ์ฐ n-1๊ฐ์ ์์๋ฅผ ํ๋์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ํ์ ๊ตฌํ์์ ํ์ ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด๋ฅผ ์ด๋ป๊ฒ ์ ์งํ๋๋์ ๋ฐ๋ผ ๊ณ ์ ๋ front ์ค๊ณ ๋ฐฉ๋ฒ, ์ ๋ front ์ค๊ณ ๋ฐฉ๋ฒ์ผ๋ก ๋๋์ด์ง๋ค. ๊ณ ์ ๋ front ์ค๊ณ ๋ฐฉ๋ฒ์์ ๋ ๋ฐฐ์ด์ 0๋ฒ์งธ ํญ์ด ํญ์ ํ์ ๋งจ ์์ด ๋๋ค. ๋ฐ๋ผ์ ํ์์ ์์๊ฐ ์ ๊ฑฐ๋๋ฉด ๋ชจ๋ ์์ ๋ฅผ ํ๋์ฉ ์ผ์ชฝ์ผ๋ก ์ด๋ํด์ผ ํ๋ ๋ฒ๊ฑฐ๋ก์์ด ์๋ค. ํ์ง๋ง ํ ๋งจ ์์ ์์น๊ฐ ๊ณ ์ ๋์ด ์์ผ๋ฏ๋ก ๋งจ ์ ์ ๋ณด๋ฅผ ๋ณ๋๋ก ์ ์งํ ํ์๊ฐ ์์ผ๋ฉฐ, ํ์ ๋งจ ๋ค ์ ๋ณด๋ ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ํตํด ์ ์ ์์ผ๋ฏ๋ก ๋ณ๋๋ก ์ ์งํ ํ์๊ฐ ์๋ค. ์ฆ, ํ๋์ ๋ฉค๋ฒ๋ณ์ ์ ๋ณด๋ฅผ ์ด์ฉ ํ์ฌ ํ์ ๋งจ ์, ํ์ ๋งจ ๋ค, ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ๋ชจ๋ ๋ํ๋ผ ์ ์๋ค.
์ ๋ Front ์ค๊ณ ๋ฐฉ๋ฒ enq(10);
10
deq(); enq(20);
20
enq(30);
20
30
enq(40);
20
30
40
enq(50);
20
30
40
20
30
40
enq(60);
60
front=0, rear=-1 front=0, rear=0 front=1, rear=0 front=1, rear=1 front=1, rear=2 front=1, rear=3 50 front=1, rear=4 50 front=1, rear=0
front๊ฐ ๊ณ ์ ๋์ด ์์ง ์๋ค. enq, deq ๋ชจ๋ O(1)์ด๋ค. enq: rear ์ฆ๊ฐ deq: front ์ฆ๊ฐ ์ถ๊ฐ์ ์ผ๋ก front, rear ๋ฉค๋ฒ ๋ณ์๋ฅผ ์ ์งํด์ผ ํ๋ฉฐ, front์ rear ๊ฐ์ ํตํด ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ์ ์ ์์ผ๋ฉด ์ถ๊ฐ์ ์ผ๋ก size ๋ฉค๋ฒ๋ณ์๊ฐ ํ์ํ๋ค. ์์์ ์ ์ ์๋ฏ์ด full ์ํ์ empty ์ํ์์ front์ rear ๊ฐ์ ์ฐจ์ด๊ฐ ๋์ผํจ
์ ๋ front ์ค๊ณ ๋ฐฉ๋ฒ์์๋ ํ์ ๋งจ ์ ์์น๊ฐ ๊ณ์ ๋ฐ๋๋ค. ๋ฐ๋ผ์ ๋งจ ์ ์์น์ ๋งจ ๋ค ์ ์น๊ฐ ๋ชจ๋ ๋ณํ๋ ํํ์ด๋ค. ๊ทธ๋ฌ๋ฏ๋ก ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด๋ฅผ ๋ณ๋์ ๋ฉค๋ฒ๋ณ์๋ฅผ ํตํด ์ ์งํด์ผ ํ๋ค. enqueue๋ฅผ ํ ๊ฒฝ์ฐ์๋ ํ ๋ค์ ์ถ๊ฐํ๋ ๊ฒ์ด๋ฏ๋ก ๋งจ ๋ค ์ ๋ณด๋ฅผ ๋ํ๋ด๋
rear ๊ฐ์ ํ๋ ์ฆ๊ฐ์์ผ์ผ ํ์ง๋ง ๋งจ ์ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ front ๊ฐ์ ๋ณํ์ง ์๋๋ค. ๋ฐ๋
- 72 -
๋ก dequeue๋ฅผ ํ ๊ฒฝ์ฐ์๋ ํ ์์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ๋ ์ฐ์ฐ์ด๋ฏ๋ก front ๊ฐ์ด ํ๋ ์ฆ๊ฐ ํ์ง๋ง rear ๊ฐ์ ๋ณํ์ง ์๋๋ค. ๊ทธ๋ฐ๋ฐ ์ด ์ฌ๋ผ์ด๋์ฒ๋ผ front์ rear ๊ฐ์ ์ ์งํ๋ฉด ์ด ๋ ์ ๋ณด๋ฅผ ํตํด ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ํ์ ํ ์ ์๋ค. ์ด๊ฒ์ ํ๊ฐ ๋น์ด์๋ ์ํ์ ํ๊ฐ ๊ฝ ์ฐฌ ์ํ๊ฐ ์ด ๋ ์ ๋ณด๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ณด๋ฉด ๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค. ์ฆ, ์ ๋ front ์ค๊ณ ๋ฐฉ๋ฒ์ ํ์ ๋งจ ์, ํ์ ๋งจ ๋ค, ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ ์ธ ๊ฐ์ง ๋ฉค๋ฒ๋ณ์๋ฅผ ๊ฐ๊ฐ ์ ์งํด์ผ ํ๋ค. ๊ฒฐ๋ก ์ ์ผ๋ก ๊ณ ์ front ์ค๊ณ ๋ฐฉ์์ ํ๋์ ๋ฉค๋ฒ๋ณ์๋ง ์ ์งํ๋ฉด ๋์ง๋ง dequeue ์ฐ ์ฐ์ ์ต์ ์ ๊ฒฝ์ฐ O(n) ๋น์ฉ์ด ํ์ํ๋ค. ๋ฐ๋๋ก ์ ๋ front ์ค๊ณ ๋ฐฉ์์ ๋ณดํต 3๊ฐ์ ๋ฉค๋ฒ๋ณ ์๋ฅผ ์ ์งํด์ผ ํ์ง๋ง enqueue์ dequeue๋ฅผ ๋ชจ๋ O(1)์ ๋น์ฉ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
ArrayQueue ADT ๋ฐฐ์ด์ ์ด์ฉํ ์ ๋ front ๋ฐฉ์์ ํ ๊ตฌํ int front=0; int rear=-1; int size=0; Object[] elements; ์์ฑ์ ArrayQueue() ArrayQueue(int capacity);
์ํ boolean isFull(); ์กฐ๊ฑด: size==elements.length boolean isEmpty(); ์กฐ๊ฑด: size==0 ์กฐ์ void enq(Object item); isFull()์ด ์ฐธ์ด๋ฉด QueueOverflowException ๋ฐ์
Object deq(); isEmpty()๊ฐ ์ฐธ์ด๋ฉด QueueUnderflowException ๋ฐ์
์ด ์ ์์๋ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ํ๋ฅผ ๊ตฌํํด ๋ณธ๋ค. ์ด ๋ ์ ๋ front ๋ฐฉ์์ ์ฌ์ฉํ๋ฉฐ, Object ๋ฐฐ์ด์ ์ด์ฉํ์ง๋ง ๋ณต์ฌ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๊ณ , ์์ธ ์ฒ๋ฆฌ๋ฅผ ํ๋ค. ๋ค์ ํ๋ฒ ์ธ๊ธํ์ง๋ง ์ ๋
front์ ๊ฒฝ์ฐ์๋ ์ผ๋ฐ์ ์ผ๋ก ํ์ ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ํ์ ์๋ ์์์ ๊ฐ์๋ฅผ ์ ์ ์๋ค. ๋ฐ๋ผ์ isFull๊ณผ isEmpty ๋ฉ์๋๋ size ๋ฉค๋ฒ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํด์ผ ํ๋ค.
Enqueue public void enq(Listable item) throws QueueOverflowException{ if(isFull()) throw new QueueOverflowException(โEnqueue attempted on a full queue.โ); rear = (rear + 1) % elements.length; elements[rear] = item.clone(); size++; } 10 deq();
20
30
40
50
20
30
40
50
deq(); enq(55);
55
enq(70);
55
70
30
40
30
40
30
40
front=0, rear=4 front=1, rear=4
front=2, 50 rear=4 front=2, 50 rear=0 50
front=2, rear=1
30 deq();
40
front=2, rear=3 front=3, rear=3 front=4, rear=3 front=4, 55 rear=4
deq(); enq(55); enq(70);
40
65
55 front=4, rear=0
enqueue ์ฐ์ฐ์ ์ ์์๋ฅผ ํ ๋์ ์ถ๊ฐํ๋ ์ฐ์ฐ์ด๋ค. ์ด ์ฐ์ฐ์ด ์ฑ๊ณตํ๊ธฐ ์ํด์๋ ์ฐ์
- 73 -
ํ๊ฐ ๊ฝ ์ฐฌ ์ํ๊ฐ ์๋์ด์ผ ํ๋ค. ํ๊ฐ ๊ฝ ์ฐฌ ์ํ๊ฐ ์๋๋ฉด ํ ๋ ์ ๋ณด๋ฅผ ํ๋ ์ฆ๊ฐ์ํจ ํ์ ๊ทธ ์์น์ ์ ์์๋ฅผ ๋ณต์ ํ์ฌ ์ถ๊ฐํ๋ค. enqueue ์ฐ์ฐ์ ํ ์ ์ ๋ณด์๋ ์๋ฌด๋ฐ ์ ํฅ์ ์ฃผ์ง ์๋๋ค.
Dequeue public Object deq() throws QueueUnderflowException{ if(isEmpty()) throw new QueueUnderflowException(โDequeue attempted on an empty queueโ); Object tmp = element[front]; elements[front] = null; // ๋ถํ์ front = (front + 1) % elements.length; size--; return tmp; // tmp.clone() ๋ถํ์ } int loc = front; front = (front + 1) % elements.length; size--; return elements[loc];
dequeue ์ฐ์ฐ์ ํ ๋งจ ์์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ๋ ์ฐ์ฐ์ด๋ค. ๋ฐ๋ผ์ ํ์ฌ ํ ์ ์ ๋ณด์ ์ ๋ ์์๋ฅผ ์์ ๋ณด๊ดํ ํ์ ํ front ์ ๋ณด๋ฅผ ํ๋ ์ฆ๊ฐ์ํค๊ณ , ์์ ๋ณด๊ดํ์๋ ์์๋ฅผ ๋ฐ ํํ๋ฉด ๋๋ค. ์์ ์์ฒด๋ฅผ ์์ ๋ณด๊ดํ๋ ๋์ ์ ๊ทธ ์์น๋ฅผ ๋ณด๊ดํ์ฌ ์ฒ๋ฆฌํ ์ ์์ง๋ง ์ฑ ๋ฅ์ด๋ ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์ ๋ ๋ฐฉ๋ฒ์ ์ฐจ์ด๊ฐ ์๋ค.
ํจ์จ์ ์ธ ์ ๋ front ๊ตฌํ front์ rear ์ ๋ณด๋ง์ ์ด์ฉํ์ฌ ํ์ฌ ํ์ ์ํ(full ๋๋ empty)๋ฅผ ํ๋ณํ ์ ์๋๊ฐ? ํ์ฌ ๊ตฌํ์ ๊ฒฝ์ฐ์๋ ๋ ์กฐ๊ฑด์ด ๊ฐ๋ค. ๋ ์กฐ๊ฑด์ด ๊ฐ์ผ๋ฏ๋ก ์ด ์กฐ๊ฑด์ ๊ตฌ๋ถํ๋ boolean flag์ ์ฌ์ฉํ๋ค. size๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ์ฐจ์ด๊ฐ ์์ public void enq(Object item) throws QueueOverflowException{ if(isFull()) throw new QueueOverflowException(โโฆโ); Listable x = (Listable)item; rear = (rear + 1) % elements.length; elements[rear] = x.clone(); isFull = ((rear + 1) % elements.length)==front)? true : false; }
๋ฐฐ์ด์ ํ ๊ณต๊ฐ์ ์ฌ์ฉํ์ง ์์ผ๋ฉด ํ๋ณํ ์ ์๋ค. (How?)
์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ์ ๋ front ์ค๊ณ ๋ฐฉ์์์๋ ํ ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด๋ง์ ์ด์ฉํ ์ฌ ํ์ ์ํ๋ฅผ ํ๋ณํ๊ธฐ๊ฐ ์ด๋ ต๋ค. ์ด๊ฒ์ ํ๊ฐ ๋น์ด์๋ ์ํ์ ํ๊ฐ ๊ฝ ์ฐฌ ์ํ์์ ํ ์ ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด์ ์ํ๊ฐ ๊ฐ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๊ฒ์ ๊ตฌ๋ณํ๊ธฐ ์ํ ๋ณ๋์ flag์ ์ ์งํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํ ์ ์์ง๋ง ์ด๊ฒ์ ํฌ๊ธฐ ์ ๋ณด๋ฅผ ์ถ๊ฐ๋ก ์ ์งํ๋ ๊ฒ์ ๋นํด ๊ณต๊ฐ์ ์ธ ์ด์ ์ด ์๋ค. ๊ทธ๋ฐ๋ฐ ๋ฐฐ์ด์ ํ ๊ณต๊ฐ์ ๋ ์ฌ์ฉํ์ง ์์ผ๋ฉด ๋ณ๋์ flag์ ์ฌ์ฉํ์ง ์๊ณ ๋ ์ํ๋ฅผ ํ๋ณํ ์ ์๋ค.
- 74 -
ํจ์จ์ ์ธ ์ ๋ front ๊ตฌํ โ ๊ณ์ ์ด ๋ฐฉ๋ฒ์ size ์ ๋ณด๋ฅผ ์ ์งํ์ง ์์๋ ๋๋ค. ํ์ง๋ง ํญ์ ๋ฐฐ์ด ํ ์ฌ๋กฏ์ด ์ฌ์ฉ๋์ง ์๋๋ค. ๊ณต๊ฐ ์ธก๋ฉด์์๋ ๊ธฐ์กด size๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ์ฐจ์ด๋ ์๋ค. ์๊ฐ ์ธก๋ฉด์์๋ size๋ฅผ deq(); ์ ์งํ๋ ๋น์ฉ์ด ์์ผ๋ฏ๋ก ํจ์จ์ ์ด๋ค.
front=5, rear=5 front=5, rear=0
10 20
30
40
50
front=5, rear=4
20
30
40
50
front=0, rear=4
deq();
30
40
50
front=1, rear=4
enq(60);
30
40
50
10
60
front=1, rear=5
๋ฐฐ์ด์ ํ ํญ์ ๋ ์ฌ์ฉํ์ง ์๊ณ , ํ์ ๋งจ ์ ์ ๋ณด๊ฐ ํ์ ๋งจ ์์ ๊ฐ๋ฆฌํค๋ ๋์ ์ ๋ฐ๋ก ์ ์์น๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ฉด ๋ณ๋์ flag์ ์ฌ์ฉํ์ง ์๊ณ ํ์ ๋งจ ์ ์ ๋ณด์ ๋งจ ๋ค ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ํ์ ์ํ๋ฅผ ํ๋ณํ ์ ์๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ์๋ ๋ ํ ๊ณต๊ฐ์ ๋ญ๋นํ๊ฒ ๋๋ฏ๋ก ๊ธฐ์กด์ ์์์ ๊ฐ์๋ฅผ ์ ์งํ๋ ๋ฐฉ์์ ๋นํด ๋ณ๋ก ํฅ์๋ ์ ์ด ์๋ค.
- 75 -
์ 7์ฅ ์ฐ๊ฒฐ๊ตฌ์กฐ ์ด ์ฅ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ฐ ์ข ์๋ฃ๊ตฌ์กฐ์ ๊ตฌํ์ ๋ํด ์ดํด๋ณธ๋ค.
7.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์ํ ํ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ ๊ตฌํ
7.2. ์ฐ๊ฒฐ๊ตฌ์กฐ
์ฐ๊ฒฐ๊ตฌ์กฐ๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ ์ฐ๊ฒฐ๊ตฌ์กฐ ๊ณ ์ ๋ ๊ณต๊ฐ์ ๋ฏธ๋ฆฌ ํ๋ณดํ์ฌ ์ฌ์ฉํ์ง ์๊ณ , ํ์ํ ๋๋ง๋ค ๋์ ์ผ๋ก ํ๋ณดํ์ฌ ์ฌ์ฉํ๋ ๊ตฌ์กฐ๋ฅผ ๊ตฌ์กฐ ๋งํ๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ ๋ฐฉ์์์๋ ์์๋ฅผ ์ ์ฅํ ๊ณต๊ฐ์ ๋ฏธ๋ฆฌ ํ๋ณดํ๋ฉฐ, ์ด ๊ณต๊ฐ์ด ๊ณ ์ ๋์ด ์๋ค. ๋ฐ๋ผ์ ๊ณต๊ฐ์ด ๋ญ๋น๋๊ฑฐ๋ ๋ถ์กฑํ ์ ์๋ค. ArrayList์ฒ๋ผ ๋ถ์กฑํ๋ฉด ๋ณด๋ค ํฐ ๊ณต๊ฐ์ ํ๋ณดํ์ฌ ์ ๊ณต๊ฐ์ ๊ธฐ์กด ์์๋ฅผ ๋ณต์ฌํ์ฌ ์ฌ์ฉํ๋ ๋ฐฉ์์ ์ทจํ ์ ์๋ค. ์ด ๋ฐฉ์์ ๊ณต๊ฐ์ด ๋ถ์กฑํ ๋ ๋ง์ ๋น์ฉ์ด ์์๋๋ค๋ ๋ฌธ์ ์ ์ด ์๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ๋ ํ๋์ ์์๋ฅผ ์ ์ฅํ ๋๋ง๋ค ๊ณต๊ฐ์ ํ๋ณดํ๋ค. ์ด๋ ๊ฒ ํ๋ณดํ ๊ณต๊ฐ์ ์ฐ๊ฒฐํ์ง ์์ผ๋ฉด ์ ์ฅํ ์์๋ค์ ์ ๊ทผํ๊ธฐ ์ด๋ ต๊ธฐ ๋๋ฌธ์ ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ํ๋์ ์์๋ฅผ ์ ์ฅํ ๋๋ง๋ค ์ถ๊ฐ ๊ณต๊ฐ์ด ํ์ํ๋ค. ์ด๊ฒ์ด ์ฐ๊ฒฐ๊ตฌ์กฐ์ ํ ๊ฐ์ง ๋จ์ ์ด๋ค. ํ์ info
info
info
info
info
info
๋ฐฐ์ด๋ฐฉ์
info
info
์ฐ๊ฒฐ ๊ตฌ์กฐ ๋ฐฉ์
์ฐ๊ฒฐ๊ตฌ์กฐ๋ ์ง๊ธ๊น์ง ์ดํด๋ณธ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ๊ณผ ๋ฌ๋ฆฌ ๊ณ ์ ๋ ๊ณต๊ฐ์ ๋ฏธ๋ฆฌ ํ๋ณดํ์ฌ ์ฌ์ฉ ํ์ง ์๊ณ ํ์ํ ๋๋ง๋ค ๋์ ์ผ๋ก ํ๋ณดํ์ฌ ์ฌ์ฉํ๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์์๋ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์ ๋ฐ์ํ ์ ์๋ ๊ณต๊ฐ ๋ญ๋น ๋๋ ๋ถ์กฑ ๋ฌธ์ ๋ ๋ฐ์ํ์ง ์๋๋ค. ๋ฌผ๋ก ๋ฐฐ์ด ๋ ๊ณต๊ฐ ๋ถ์กฑ ๋ฌธ์ ๋ฅผ ๊ทน๋ณตํ๊ธฐ ์ํด ArrayList์ฒ๋ผ ๋ถ์กฑํ ๋๋ง๋ค ๋ณด๋ค ํฐ ๊ณต๊ฐ์ ํ๋ณดํ์ฌ
- 77 -
ํด๊ฒฐํ ์ ์์ง๋ง ํฐ ๊ณต๊ฐ์ ํ๋ณดํ์ฌ ๊ธฐ์กด ์ ๋ณด๋ฅผ ์ด๋ํ๋ ๋น์ฉ์ด ๋งค์ฐ ํฌ๋ฉฐ, ๊ณต๊ฐ ๋ญ๋น ๋ฌธ์ ๋ ์ฌ์ ํ ์กด์ฌํ๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ๋ ํ๋์ ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ์๋กญ๊ฒ ๊ณต๊ฐ์ ํ๋ณดํ๊ธฐ ๋๋ฌธ์ ์ด๋ค์ ์ฐ๊ฒฐํ์ง ์์ผ๋ฉด ์ ์ฅ๋์ด ์๋ ์์๋ค์ ์ ๊ทผํ๊ธฐ๊ฐ ์ด๋ ต๋ค. ๋ฐ๋ผ์ ํ๋์ ์์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด ๊ธฐ์กด ๋ฐฐ์ด๋ณด๋ค ๋ ๋ฐฐ์ ๊ณต๊ฐ์ด ํ์ํ๋ค.
์ฐ๊ฒฐ๊ตฌ์กฐ vs. ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ ๋ฐฉ์
๊ณต๊ฐ๋ถ์กฑ/๋ญ๋น ๋ฌธ์ ํ ์์๊ฐ ์ฐจ์งํ๋ ๊ณต๊ฐ ๊ณต๊ฐ ํ๋ณด ๋น์ฉ
๊ฐ ์์ ์ ๊ทผ ๋ฐฉ์
์ค๊ฐ์ ์์ ์ฝ์
์ฐ๊ฒฐ๊ตฌ์กฐ
๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ ๋ฐฉ์
์์
์์
์์+์ฐ๊ฒฐ ์ ์์๋ฅผ ์ฝ์ ํ ๋๋ง๋ค ํ๋ณดํด์ผ ํจ ์์ฐจ ์ ๋ ฌ ๊ตฌ์กฐ์ ๊ฒฝ์ฐ์๋ ์ด์ง ๊ฒ์์ ํ ์ ์์ ์ฐ๊ฒฐ๋ง ๋ณ๊ฒฝ (์์ ์๊ฐ)
์์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฒ์ ์์ฑํ ๋ ํ๋ฒ ํ๋ณด ์์ ์ ๋ ฌ ๊ตฌ์กฐ์ ๊ฒฝ์ฐ์๋ ์ด์ง ๊ฒ์ ๊ฐ๋ฅ ์ ๋ ฌ ๊ตฌ์กฐ์ผ ๊ฒฝ์ฐ์๋ ํ์ ์์๋ค์ ๋ชจ๋ ์ด๋ํด์ผ ํจ.
์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ ๋ฐฉ์์ ์๋ก ์ฅ๋จ์ ์ ๊ฐ์ง๊ณ ์๋ค. ๊ณต๊ฐ ๋ถ์กฑ๊ณผ ๋ญ๋น ๋ฌธ์ ์ธก๋ฉด์์ ์ฐ๊ฒฐ๊ตฌ์กฐ๊ฐ ์ฐ์ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ์ ํ ์์๊ฐ ์ฐจ์งํ๋ ๊ณต๊ฐ์ด ๋ฐฐ์ด๋ณด๋ค ๋ง๋ค. ๋ฐฐ ์ด์ ์ฒ์ ์์ฑํ ๋ ํ๋ฒ ํ๋ณดํ๋ ๋ฐ๋ฉด์ ์ฐ๊ฒฐ๊ตฌ์กฐ ์ ์์๋ฅผ ์ฝ์ ํ ๋๋ง๋ค ํ๋ณดํด์ผ ํ ๋ฏ๋ก ๊ณต๊ฐ ํ๋ณด ๋น์ฉ ์ธก๋ฉด์์๋ ๋ฐฐ์ด์ด ์ฐ์ํ๋ค. ๋ฐฐ์ด์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ์์ธ์ ์ํ ์ ์ ์ ๊ทผ์ ์ ๊ณตํ๋ค๋ ๊ฒ์ด๋ค. ๋ฐ๋ฉด์ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๊ฐ์ฅ ํฐ ๋จ์ ์ ์์ฐจ ์ ๊ทผ๋ง ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ด๋ค. ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ๋ ์ค๊ฐ์ ์๋ ์์์ ์ฝ์ ์ด๋ ์ญ์ ๋ ์ฐ๊ฒฐ ์ ๋ณด๋ง ๋ณ๊ฒฝํ์ฌ ๊ฐ ๋ฅํ ๋ฐ๋ฉด์ ๋ฐฐ์ด์ ์ด์ฉํ ์ ๋ ฌ ๋ฆฌ์คํธ ๊ตฌํ์์๋ ์ค๊ฐ ์ดํ์ ๋ชจ๋ ์์๋ฅผ ์ด๋ํด์ผ ํ ๋ ๋ฌธ์ ์ ์ด ์๋ค. ์ด์ฒ๋ผ ์ด๋ ํ ๋ฐฉ์์ด ํญ์ ์ฐ์ํ๋ค๊ณ ๋จ์ ํ ์ ์๋ค. ๋ฐ๋ผ์ ์์ฉ์ ๋ฐ๋ผ ์ด๋ค ๋ฐฉ์์ ๊ตฌํ์ ์ฌ์ฉํ ์ง ๊ฒฐ์ ํด์ผ ํ๋ค.
- 78 -
7.3. ์คํ
Stack๊ณผ Queue์ Class Hierarchy Stack
ArrayStack
LinkedStack
use inner class
StackNode
LinkedQueue
use inner class
QueueNode
Queue
ArrayQueue
6์ฅ์์ ๋ฐฐ์ด์ ์ด์ฉํ ์คํ๊ณผ ํ ๊ตฌํ์ ์ดํด๋ณด์๋ค. ์ด ์ ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ ๊ณผ ํ์ ๊ตฌํ์ ์ดํด๋ณด๋ฉฐ, ์ด๋ค ํด๋์ค ๊ฐ์ ๊ด๊ณ๋ ์ด ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ์ฌ๊ธฐ์ Stack๊ณผ
Queue๋ ์ธํฐํ์ด์ค์ด๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๊ตฌํ๊ณผ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ์ ๊ตฌํ์ ๋ ๋ค ๊ฐ์ ์ข ๋ฅ์ ์ฐ์ฐ์ ์ ๊ณตํด์ผ ํ์ง๋ง ๋ด๋ถ์ ์ผ๋ก ์ ํ ๋ค๋ฅด๊ฒ ๊ตฌํ๋๋ฏ๋ก ์ฝ๋๋ฅผ ์ฌ ์ฌ์ฉํ ์๋ ์๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ธํฐํ์ด์ค ๋์ ์ ์ถ์ ํด๋์ค๋ฅผ ์ฌ์ฉํ ์ ์๋ค.
๋ฐฐ์ด๋ก ์คํ์ ๊ตฌํ ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ, ์คํ, ํ์ ๋ฌธ์ ์ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ์์ฑํ ๋ ๊ณ ์ ๋จ ร ๊ณต๊ฐ์ ๋ญ๋น, ๊ณต๊ฐ์ ๋ถ์กฑ ๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๋ฌผ๋ฆฌ์ ๋ทฐ vs. ๋ ผ๋ฆฌ์ ๋ทฐ ArrayStack stack = new ArrayStack(4); stack
topIndex element
-1 null
null
null
null
null
null
null
stack.push(new Integer(10)) stack
topIndex
0
element
10
- 79 -
10
์ฐ๊ฒฐ๊ตฌ์กฐ๋ก ์คํ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ info
link
info
A
link
info
B
null
private class StackNode{ public Object info; public StackNode link; }
C
์ฐ๊ฒฐ๊ตฌ์กฐ๋ก ์คํ์ ๊ตฌํ stack.push(new Integer(20));
LinkedStack stack = new LinkedStack(); stack
top
null
stack
top
stack.push(new Integer(10)); stack
top
info
null
10
info
info
20
10
null
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์์ ํ๋์ ์์๋ฅผ ์ ์ฅํ๊ธฐ ์ํด์๋ ๊ทธ ์์๋ฅผ ์ ์ฅํ ๊ณต๊ฐ๊ณผ ๋ค๋ฅธ ์์๋ค ๊ณผ ์ฐ๊ฒฐํ๊ธฐ ์ํ ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ์ํ ๊ณต๊ฐ์ด ํ์ํ๋ค. ์ด ๋ ๊ณต๊ฐ์ ํฉ์ณ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋ ๋ผ ํ๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ฅผ ๋ํ๋ด ๊ธฐ ์ํ ํ์ ์ด ํ์ํ๋ค. ์๋ฐ์์๋ ๋ณดํต ๋ด๋ถ ํด๋์ค๋ฅผ ์ด์ฉํ์ฌ ๋ ธ๋ ํ์ ์ ์ ์ํ๋ค. ์ด ํ์ ์๋ ๋ ๊ฐ์ง ๋ฉค๋ฒ ๋ณ์๊ฐ ํ์ํ๋ค. ํ๋๋ ์ค์ ์์๋ฅผ ์ ์ฅํ ๋ณ์์ด๊ณ , ๋ค๋ฅธ ํ ๋๋ ๋ค์ ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํ๊ธฐ ์ํ ๋ณ์์ด๋ค.
LinkedStack ADT ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ์ ๊ตฌํ StackNode top = null;
์กฐ์ void push(Object item);
์ฐ๊ฒฐ ๊ตฌ์กฐ์ด๋ฏ๋ก ๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ์์ธ์ด ์๋ ์ฐธ์กฐ ํ์ ์ผ๋ก ์คํ top์ ์ ์งํจ
StackOverflowException์ด ๋ฐ์ํ์ง ์์
void pop();
์์ฑ์ LinkedStack() ์ํ boolean isFull(); ์กฐ๊ฑด: ํญ์ ๊ฑฐ์ง boolean isEmpty(); ์กฐ๊ฑด: top==null
isEmpty()๊ฐ ์ฐธ์ด๋ฉด StackUnderflowException ๋ฐ์
Object top(); isEmpty()๊ฐ ์ฐธ์ด๋ฉด StackUnderflowException ๋ฐ์ stack
top
null
์คํ์์ ๊ฐ์ฅ ์ค์ํ ์ ๋ณด๋ ์คํ ํฑ์ ๋ํ๋ด๋ ์ ๋ณด์ด๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์๋ ๋ฐฐ ์ด์ ํน์ ์์ธ์ด ์คํ ํฑ ์ญํ ์ ํ์์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ํ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ ๊ฐ์ด ์ด ์ญํ ์ ํ๊ฒ ๋๋ค. ๋ํ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์๋ ๋ฐฐ์ด์ ์๋ ๋ชจ๋ ํญ์ ์ ์๊ฐ ์ ์ฅ๋์ด ์์ผ๋ฉด ๋ ์ด์ ์ ์์๋ฅผ ์ถ๊ฐํ ์ ์์๋ค. ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ์์๋ ์์คํ ์์ ๋ ์ด์ ํ์ฉํ์ง ์์ ๋๊น์ง ๊ณ์ ์ ์์๋ฅผ ์ํ ๊ณต๊ฐ์ ํ๋ณดํ์ฌ ์ฌ์ฉํ ์ ์๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ์์ isFull ๋ฉ์๋๋ ๋ณดํต ํญ์ false๋ฅผ ๋ฐํํ๋๋ก ์ ์ํ๋ฉฐ, ์ ์์๋ฅผ ์ฝ ์ ํ๋ ์ฐ์ฐ์ OverflowException์ ๋ฐ์์ ๊ณ ๋ คํ์ง ์๋๋ค.
- 80 -
Inner Class public class LinkedStack implements Stack{ private class StackNode{ public Object item; public StackNode link; } private StackNode top = null; public StackNode() {} โฆ }
ํด๋์ค ๋ด๋ถ์ ์ ์ํ ํด๋์ค๋ฅผ ๋ด๋ถ ํด๋์ค(inner class)๋ผ ํ๋ค.
class public class private class
private ๋ด๋ถ ํด๋์ค๋ ๊ทธ๊ฒ์ ์ธ๋ถ ํด๋์ค๋ฅผ ์ ์ธํ๊ณ ๋ ์ ๊ทผํ ์ ์์ผ๋ฏ๋ก ๋ด๋ถ ํด๋์ค์ ๋ฉค๋ฒ ๋ณ์๋ฅผ public์ผ๋ก ์ ์ธํ์ฌ๋ ์์ ํ๋ค.
public class
ํจํค์ง
์๋ฐ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ฅผ ๋ณดํต ๋ด๋ถ ํด๋์ค๋ก ๊ตฌํํ๋ค. ์ด๊ฒ์ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ ํด ๋น ํด๋์ค ๋ด์์๋ง ํ์ํ ์ ๋ณด์ด๋ฉฐ ์ธ๋ถ์์๋ ์ ๊ทผํ ํ์๊ฐ ์๋ ์ ๋ณด์ด๊ธฐ ๋๋ฌธ์ด๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ธ๋ถ์์ ์ ๊ทผํ ํ์๊ฐ ์๋ ์ ๋ณด๋ค์ ์ธ๋ถ๋ก๋ถํฐ ์จ๊ธฐ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ์ ๋ฐ์์ private ๋ด๋ถ ํด๋์ค๋ ๋ค๋ฅธ ํจํค์ง์ ์๋ ํด๋์ค๋ ๋ฌผ๋ก ๊ฐ์ ํจ๊ธฐ์ง ๋ด์ ์๋ ๋ค ๋ฅธ ํด๋์ค๋ค๋ก๋ถํฐ ์จ๊ธธ ์ ์๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ฅผ ๋ํ๋ด๋ ํด๋์ค๋ ๋ด๋ถ ํด๋ ์ค๋ก ์ ์ํ์ฌ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ๊ฐ์ ์ด์ ์์ private ๋ด๋ถ ํด๋์ค์ ๋ฉค๋ฒ๋ค์
public์ผ๋ก ์ง์ ํ์ฌ๋ ์์ ํ๋ค.
Inner Class ๋ด๋ถ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๋ชฉ์ ๋ด๋ถ ํด๋์ค๋ ๊ทธ๊ฒ์ ์์ฑํ ์ธ๋ถ ํด๋์ค ๊ฐ์ฒด์ ๊ตฌํ (๋ฉค๋ฒ ๋ณ์, ๋ฉ์๋)์ ์ ๊ทผ ๊ถํ๊ณผ ๋ฌด๊ดํ๊ฒ ๋ชจ๋ ์ ๊ทผํ ์ ์๋ค. ๊ฐ์ ํจํค์ง์ ์๋ ๋ค๋ฅธ ํด๋์ค๋ก๋ถํฐ ์จ๊ธธ ์ ์๋ค. (name control ์ธก๋ฉด) ์ฐ๊ฒฐ ๊ตฌ์กฐ์์๋ ์ด ์ธก๋ฉด ๋๋ฌธ์ ์ฌ์ฉ private ๋ด๋ถ ํด๋์ค๋ฅผ ์ฌ์ฉํ์ฌ ์ฌ๊ฑด ๊ธฐ๋ฐ ํ๋ก๊ทธ๋จ์ ์์ฑํ ๋ ๋งค์ฐ ์ ์ฉํ๋ค. top level class
๋น์ฐํ ํน์ฑ inner class
์ธ๋ถ ํด๋์ค ๊ฐ์ฒด์ ๊ตฌํ์ ์ ๊ทผํ ์ ์๋ค. static inner class์ธ ๊ฒฝ์ฐ์๋ ๊ฐ๋ฅํ์ง ์๋ค.
์ฐธ๊ณ ์ ์ผ๋ก ์๋ฐ์์ ๋ด๋ถ ํด๋์ค ๊ฐ์ฒด๋ ๊ทธ๊ฒ์ ์ธ๋ถ ํด๋์ค ๊ฐ์ฒด์ ๋ฉค๋ฒ ๋ณ์์ ๋ฉ์๋๋ฅผ ์ ๊ทผ ๊ถํ๊ณผ ์๊ด์์ด ์ ๊ทผํ ์ ์๋ค. ๋ํ ์ธ๋ถ ํด๋์ค ๊ฐ์ฒด๋ ์์ ์ ๋ฉค๋ฒ์ธ ๋ด๋ถ ํด๋ ์ค ๊ฐ์ฒด์ ๋ชจ๋ ๋ฉค๋ฒ๋ฅผ ์ ๊ทผํ ์ ์๋ค.
- 81 -
public class Test{ public static void main(String[] args){ public class Outer{ Outer obj = new Outer(2, 3); private int oVal; obj.g(3); private Inner X; obj.print(); private class Inner{ } private int iVal; } public Inner(int n){ ๊ฒฐ๊ณผ: oVal = 6, iVal = 9 iVal = n; } obj public void f(int n){ iVal = oVal + n; // Outer.this.oVal+n oVal X } 2 ๋ด๋ถ ํด๋์ค๋ ์ธ๋ถ ํด๋์ค์ } // class Inner private ๋ฉค๋ฒ๋ฅผ ์ ๊ทผํ ์ ์๋ค. public Outer(int n1, int n2){ oVal = n1; X = new Inner(n2); } ์ธ๋ถ ํด๋์ค๋ ๋ด๋ถ ํด๋์ค์ public void g(int n){ private ๋ฉค๋ฒ๋ฅผ ์ ๊ทผํ ์ ์๋ค. 3 oVal = X.iVal + n; X.f(n); iVal Outer } public void print(){ System.out.println("oVal = "+oVal+", " ๋ด๋ถ ํด๋์ค์ ๊ฐ์ฒด๊ฐ ์์ฑ๋ ๋ +"iVal = "+X.iVal); ์ด ๊ฐ์ฒด์ ์ธ๋ถ ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ } ํ์ฌ ๊ฐ์ฒด์ this๊ฐ์ผ๋ก ์ค์ ๋๋ค. } // class Outer
Outer ํด๋์ค์ ๊ฐ์ฒด obj๊ฐ ์์ฑ๋๋ฉด obj๋ ๋ฉค๋ฒ๋ก ๋ด๋ถ ํด๋์ค ํ์ ์ธ X๋ฅผ ๊ฐ์ง๊ฒ ๋๋ค. ์ด obj๋ private์ผ๋ก ์ ์ธ๋์ด ์์์๋ ๋ถ๊ตฌํ๊ณ X์ ๋ฉค๋ฒ ๋ณ์์ธ iVal์ ์ ๊ทผํ ์ ์๋ค. ์ด ๋ X ํธ๋ค์ ์ด์ฉํ์ฌ iVal์ ์ ๊ทผํ๊ฒ ๋๋ค. ๋ฐ๋๋ก obj์ ๋ฉค๋ฒ์ธ X๋ ์์ ์ ๋ด๋ถ ๋ฉ ์๋์์ ์์ ์ ํฌํจํ๊ณ ์๋ ์ธ๋ถ ๊ฐ์ฒด obj์ private ๋ฉค๋ฒ์ธ oVal์ ๋จ์ ์ด๋ฆ์ผ๋ก ์ ๊ทผ ํ ์ ์๋ค. ๋ด๋ถ ํด๋์ค ๊ฐ์ฒด๋ ์์ ์ ํฌํจํ๋ ์ธ๋ถ ๊ฐ์ฒด์ ๋ํ ํฌ์ธํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ผ ๋ฉฐ, ์์ ์ ํฌํจํ๋ ์ธ๋ถ ๊ฐ์ฒด๋ ์ค์ง ํ๋์ด๋ฏ๋ก ๋จ์ ์ด๋ฆ์ ์ฌ์ฉํ๋๋ค๋ก ๋ชจํธํ์ง ์ ๋ค.
push push ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ 1. ์ ์์๋ฅผ ์ํ ๋ ธ๋ ์์ฑ ๋จ๊ณ 2. ์ด ์์์ info ๊ฐ์ item ํ ๋น ๋จ๊ณ 3. ์ด ์์์ link๊ฐ ๊ธฐ์กด top์ ๊ฐ๋ฆฌํค๋๋ก ํจ ๋จ๊ณ 4. top์ด ์ด ์์๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํจ stack
public void push(Object item){ StackNode newNode = new StackNode(); newNode.info = item; newNode.link = top; top = newNode; }
top
4 1. ์์ฑ info
info
null
3 2
10
20
๋ฐฐ์ด์ ์ด์ฉํ ์คํ ๊ตฌํ์์๋ ์ ์์๋ฅผ ํญ์ ๋งจ ๋์ ์ฝ์ ํ์๋ค. ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์ ์์๋ ๊ฐ์ฅ ๋น ๋ฅด๊ฒ ์ ๊ทผํ ์ ์๋ ์์๋ ์ฒซ ์์์ด๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ์ด์ฉํ ์คํ ๊ตฌํ์์๋ ์ ์์๋ฅผ ์ฒซ ์์๋ก ์ฝ์ ํ๋ค. ๋ฐ๋ผ์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๊ตฌํ์์ ์ฒซ ์์๊ฐ ์ค ํ์ ํฑ์ด ๋๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ ๊ตฌํ์์ ์์ ์ฝ์ ๊ณผ ๊ด๋ จ๋ ๋ฉ์๋์์ ์ผ๋ฐ ์ ์ผ๋ก ๊ฐ์ฅ ๋จผ์ ํ๋ ์ผ์ ์ ์์๋ฅผ ๋ํ๋ผ ๋ ธ๋๋ฅผ ์์ฑํ๋ ์ผ์ด๋ค. ๋ํ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ ์์ผ๋ก ๊ตฌํํ ๋ ๊ฐ์ฅ ์ฃผ์ํด์ผ ํ๋ ๊ฒ์ ์ฐ๊ฒฐ์ ๋ณ๊ฒฝํ๋ ์์์ด๋ค. ์๋ฅผ ๋ค์ด ์ ์์
- 82 -
์ newNode.link = top ๋ฌธ์ฅ๊ณผ top = newNode ๋ฌธ์ฅ์ ์์๊ฐ ๋ฐ๋๋ฉด ๊ธฐ์กด ์์๋ค๊ณผ์ ์ฐ ๊ฒฐ์ด ๋์ด์ง๊ฒ ๋๋ค.
pop pop ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ 1. ์คํ์ด ๋น์ด ์๋์ง ํ์ธํจ ๋จ๊ณ 2. top์ด top.link์ ๊ฐ๋ฆฌํค๋๋ก ํจ
stack
top
public void pop() throws StackUnderflowException{ if(isEmpty()) throw new StackUnderflowException(โโฆโ); top = top.link; }
1 info
info
20
10
null
garbage
์ฐ๊ฒฐ๊ตฌ์กฐ์ ์ฒซ ์์๊ฐ ์คํ์ ํฑ์ด ๋๋ฏ๋ก pop ์ฐ์ฐ์ ์ฒซ ์์๋ฅผ ์ ๊ฑฐํ๋ฉด ๋๋ค. ์ฆ, ์ฒซ ์ ์๋ฅผ ์คํ ํฑ์ผ๋ก ์ฌ์ฉํด์ผ push์ pop ์ฐ์ฐ์ ๋ชจ๋ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๋ค.
top public Object top() throws StackUnderflowException{ if(isEmpty()) throw new StackUnderflowException(โโฆโ); return top.info; }
stack
top
info
info
null
10 20
top ์ฐ์ฐ์ ์คํ์ ์ํ๋ฅผ ๋ณ๊ฒฝํ์ง ์๊ณ ์คํ์ ํฑ์ ์๋ ์์๋ฅผ ๋ฐํํ๋ฉด ๋๋ค.
- 83 -
ArrayStack VS. LinkedStack ArrayStack
LinkedStack
push
O(1)
O(1)
pop
O(1)
O(1)
constructor space
O(N)
O(1)
N+1 ์ฐธ์กฐ, 1 ์์ธ
2N+1 ์ฐธ์กฐ (no waste)
Which one is better? ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅด๋ค. ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์ LinkedStack์ด ์ฐ์ ์คํ์ ํฌ๊ธฐ๊ฐ ๋งค์ฐ ๊ฐ๋ณ์ ์ธ ๊ฒฝ์ฐ LinkedStack์ด ์ฐ์ ArrayStack์ ๊ณต๊ฐ ๋ญ๋น ๊ฐ๋ฅ push๊ฐ ๋น๋ฒํ๊ฒ ์ผ์ด๋๋ ๊ฒฝ์ฐ: ArrayStack ์ฐ์ LinkedStack์ ๋งค๋ฒ ์ ๊ณต๊ฐ์ ํ๋ณดํด์ผํจ
๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๊ตฌํ๊ณผ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์คํ ๊ตฌํ์ ๋น๊ตํ์ฌ ๋ณด์. ์ ํ์์ ์ ์ ์๋ฏ์ด ๋ ๊ตฌํ ๋ชจ๋ push์ pop์ ์์ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ๊ณต๊ฐ์ ์ด ๊ธฐ์ ๋ชจ๋ ํ๋ณดํ๋ ๋ฐ๋ฉด ์คํ์ ์ ์์๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ํ๋ณดํ๋ค. ๊ณต๊ฐ์ ์ธ ์ธก๋ฉด์์๋ ๋ฐฐ์ด์ N๊ฐ์ ์์๊ฐ ์ ์ฅ๋์ด ์๋ค๋ฉด N+1 ์ฐธ์กฐ์ ์คํ์ ํฑ ์ ๋ณด๋ฅผ ๋ํ๋ด๋ ์์ธ ์ ๋ณด ๊ฐ ํ์ํ๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ์ด๊ธฐ์ ๊ณต๊ฐ์ ํ๋ณดํ๊ณ , ์ด ๊ณต๊ฐ์ด ๊ณ ์ ๋์ด ์์ผ๋ฏ๋ก ๋ญ๋น๊ฐ ๋๋ ๊ณต๊ฐ์ด ์์ ์ ์๋ค. ๋ฐ๋๋ก ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ตฌํ์์ N๊ฐ์ ์์๊ฐ ์ ์ฅ๋์ด ์ ๋ค๋ฉด 2N๊ฐ์ ๊ณต๊ฐ์ด ํ์ํ๋ฉฐ, ์คํ์ ํฑ ์ ๋ณด๋ฅผ ์ ์งํ๋ ์ฐธ์กฐ ํ์ ์ ๋ณ์๊ฐ ์ถ๊ฐ๋ก ํ ์ํ๋ค. ํ์ง๋ง ์ด ๊ณต๊ฐ๋ค ์ค์ ๋ญ๋น๊ฐ ๋๋ ๊ณต๊ฐ์ ์๋ค. ์ด๋ฐ ์ธก๋ฉด์์ ๋ณด๋ฉด ์ด๋ ๊ตฌํ ๋ฐฉ์์ด ์ ๋์ ์ผ๋ก ์ฐ์ํ๋ค๊ณ ๋งํ ์ ์๋ค. ์ํฉ์ ๋ฐ๋ผ ๊ตฌํ๋ฐฉ์์ ๊ฒฐ์ ํด์ผ ํ๋ค.
- 84 -
7.4. ํ
๋ฐฐ์ด๋ก ํ์ ๊ตฌํ ๋ฐฐ์ด์ ์ด์ฉํ ํ์ ๋ฌผ๋ฆฌ์ ๋ทฐ vs. ๋ ผ๋ฆฌ์ ๋ทฐ
ArrayQueue queue = new ArrayQueue(4); queue
0
front
rear null
element
-1
null
0
size null
null
queue.enq(new Character(โAโ)) queue
0
front
0
rear
null
element
front
rear 1
size null
A
null
A
queue.enq(new Character(โBโ)) queue
0
front
1
rear
A
2
size null
element
front
rear
B
null
A
B
์ฐ๊ฒฐ๊ตฌ์กฐ๋ก ํ์ ๊ตฌํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ก ํ์ ๊ตฌํ LinkedQueue queue = new LinkedQueue(); queue
front
null
rear null
size
0
size
1
private class QueueNode{ public Object info; public QueueNode link; }
queue.enq(new Character(โAโ)); queue
front
info A
rear
null
queue.enq(new Character(โBโ)); queue
front
size
rear
info
info
A
B
2
null
์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ ๊ตฌํ๋ ์คํ์ ๊ตฌํ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ฅผ ๋ํ๋ด๊ธฐ ์ ํ ํด๋์ค๋ฅผ ์ ์ํด์ผ ํ๋ค. ์ด ํด๋์ค ์ญ์ ๋ด๋ถ ํด๋์ค๋ก ์ ์ํ๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ์ ๊ตฌํ๊ณผ ๋ฌ๋ฆฌ ํ๋ ๋ ๊ฐ์ง ์์น์์ ์ ๊ทผ์ด ์ด๋ฃจ์ด์ง๋ฏ๋ก ํ์ ๋งจ ์ฒ์(์ฒซ ๋ ธ๋)๊ณผ ๋งจ ๋(๋ง์ง๋ง ๋ ธ๋)์ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ ํ์ ์ ๋ฉค๋ฒ๋ณ์๊ฐ ํ์ํ๋ค. ๋ํ ํ์ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ ์ ์งํ๋ ๋ณ์๊ฐ ํ์ํ๋ค. ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์ฐธ์กฐ ํ์ ์ ์ด์ฉํ์ฌ ์ ์ฅ๋์ด ์๋ ์์์ ๊ฐ์๋ฅผ ๊ณ์ฐํ ์ ์์ง๋ง ์์ฐจ์ ์ผ๋ก ๋ฐฉ๋ฌธํ์ฌ ๊ฐ์๋ฅผ ์์ ๋ด์ผ ํ๋ฏ๋ก ๋น์ฉ ์ธก๋ฉด์์ ๊ฐ์๋ฅผ ์ ์งํ๋ ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ๋ณด๋ค ํจ๊ณผ์ ์ด๋ค.
- 85 -
LinkedQueue ADT ์ฐ๊ฒฐ ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ ๊ตฌํ QueueNode front = null; QueueNode rear = null; int size = 0; ์์ฑ์ LinkedQueue() ์ํ boolean isFull(); ์กฐ๊ฑด: ํญ์ ๊ฑฐ์ง boolean isEmpty(); ์กฐ๊ฑด: front==null
์กฐ์ void enq(Object item); QueueOverflowExceptio์ ๋ฐ์ํ์ง ์์
Object deq(); isEmpty()๊ฐ ์ฐธ์ด๋ฉด QueueUnderflowException ๋ฐ์
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๊ตฌํ์ด๋ฏ๋ก ์คํ๊ณผ ๋ง์ฐฌ๊ธฐ์ง๋ก isFull ๋ฉ์๋๋ ํญ์ false๋ฅผ ๋ฐํํ๋๋ก ๊ตฌ ํํ๋ค. isEmpty๋ ํ์ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ front์ ์ด์ฉํ์ฌ ๊ฒ์ฌํ ์๋ ์๊ณ , front์ ์ด ์ฉํ์ง ์๊ณ , size๋ฅผ ์ด์ฉํ์ฌ ๊ฒ์ฌํ ์๋ ์๋ค.
enqueue enqueue ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ 1. ์ ์์๋ฅผ ์ํ ๋ ธ๋ ์์ฑ ๋จ๊ณ 2. ์ด ์์์ info ๊ฐ์ item ํ ๋น ๋จ๊ณ 3. ์ด ์์๋ฅผ rear์ ์ถ๊ฐ ๋จ๊ณ 4. rear๊ฐ ์ด ์์๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝํจ public void enq(Object item) { QueueNode newNode = new QueueNode(); newNode.info = item; newNode.link = null; // ํ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ if(rear == null) front = newNode; // ํ์ ์์๊ฐ ์๋ ๊ฒฝ์ฐ else rear.link = newNode; rear = newNode; size++; }
queue
front
size
rear
3 info 10
2
info
2 1. ์์ฑ null
20
enqueue๋ ํ์ ๋งจ ๋์ ์ถ๊ฐํ๋ ๊ฒ์ด๋ฏ๋ก ๋ณดํต ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋งจ ๋ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ rear ์ ๋ณด๋ง ๋ณ๊ฒฝํ๋ฉด ๋๋ค. ํ์ง๋ง ํ์ฌ ํ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ์๋ ๋งจ ์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ front ์ ๋ณด๋ ๋ณ๊ฒฝ๋์ด์ผ ํ๋ค. ์ ์ฌ๋ผ์ด๋์ ์ฝ๋๋ฅผ ๋ณด๋ฉด rear๋ฅผ ์ด์ฉํ์ฌ ํ๊ฐ ๋น์ด ์๋์ง ๊ฒ์ฌํ๊ณ ์๋ค. ์ด ๋ถ๋ถ์ size๋ฅผ ์ด์ฉํ์ฌ ๊ฒ์ฌํ ์๋ ์๊ณ , isEmpty ๋ฉ์๋๋ฅผ ํธ ์ถํ์ฌ ๊ฒ์ฌํ ์๋ ์๋ค. ๋ฌผ๋ก ๋ฉ์๋์ ํธ์ถ๋ณด๋ค๋ ๋ฉค๋ฒ ๋ณ์๋ฅผ ๊ฒ์ฌํ์ฌ ํ๋จํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋ค.
- 86 -
dequeue dequeue ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ 1. queue๊ฐ ๋น์ด์๋์ง ๊ฒํ ๋จ๊ณ 2. front.item์ ์์ ๋ณด๊ด ๋จ๊ณ 3. front๊ฐ front.link๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝํจ ๋จ๊ณ 4. ํ์ ๋ ์ด์ ์์๊ฐ ์์ผ๋ฉด rear๋ฅผ null๋ก ์ค์ ํจ ๋จ๊ณ 5. ์์ ๋ณด๊ดํ item์ ๋ฐํ queue
front
rear
size
1
info
info
null
10
20
2
tmp
1
public Object deq() throws QueueUnderflowException{ if(isEmpty()) throw new QueueUnderflowException(โโฆโ); Object tmp = front.info; front = front.link; size--; if(isEmpty()) rear = null; return tmp; }
dequeue๋ enqueue์ ๋ฐ๋๋ก ๋ณดํต ํ์ ๋งจ ์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ front ์ ๋ณด๋ง ๋ณ๊ฒฝํ ๋ฉด ๋๋ค. ํ์ง๋ง dequeue ๊ฒฐ๊ณผ ํ๊ฐ ๋น ์ํ๊ฐ ๋๋ฉด ๋งจ ๋ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๋ rear ์ ๋ณด ๋ ๋ณ๊ฒฝ๋์ด์ผ ํ๋ค. ์ด์ฒ๋ผ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ ๋์๋ ๋จผ์ ๊ฐ๋ฅํ ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ์๊ฐํด๋ณด ๊ณ , ๊ฐ ๊ฒฝ์ฐ๊ฐ ๋์ผํ ํ๋์ ํตํด ํด๊ฒฐ ๊ฐ๋ฅํ์ง ๊ฒํ ํด์ผ ํ๋ค.
Circular Linked Queue queue
rear
info
info
info
10
20
30
์ํ ์ฐ๊ฒฐ ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ๋ฉด ํ๋์ ์ฐธ์กฐ๋ง์ ์ด์ฉํ์ฌ ํ๋ฅผ ๊ตฌํํ ์ ์๋ค. front๋ง ์ ์งํ๋ฉด dequeue๋ O(1)์ด์ง๋ง enqueue๋ O(n)์ด ๋๋ค. rear๋ง ์ ์งํ๋ฉด ํ ๋งจ ๋ค๋ rear๋ก ํ ๋งจ ์์ rear.link๋ก ๋ฐ๋ก ์ ๊ทผํ ์ ์๋ค.
ํ๋ ๋ณดํต ๋ ๊ฐ์ง ์์น์์ ์ ๊ทผ์ด ํ์ํ๋ฏ๋ก ๊ฐ ์์น ์ ๋ณด๋ฅผ ๋ณ๋์ ๋ฉค๋ฒ ๋ณ์์ ์ ์งํ ๋ค. ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๊ตฌํ์์๋ ๋ง์ง๋ง ๋ ธ๋๊ฐ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ์ฌ ํ๋์ ๋ฉค๋ฒ๋ณ์๋ง ์ ์งํ ์ ์๋ค. ์ด ๋ ์ด ๋ฉค๋ฒ ๋ณ์๋ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ์ฌ์ผ ํ๋ค. ์ด๊ฒ์ ์ฒซ ๋ ธ๋๋ง์ ์ ์งํ๋ ๋ณ์๋ง ์ฌ์ฉํ๋ฉด ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ ๊ทผํ๊ธฐ ์ด๋ ต๊ธฐ ๋๋ฌธ์ด๋ค. ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ณ์๋ฅผ ์ ์งํ ๊ฒฝ์ฐ์๋ ์์ ๋ ธ๋์ ๋ ๋ ธ๋๋ฅผ ๋ชจ๋ ํจ๊ณผ์ ์ผ๋ก ์ ๊ทผํ ์ ์๋ค. ์ด๋ฐ ๋ฐฉ์์ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ๋ฅผ ์ํ ํ๋ผ ํ๋ค.
- 87 -
Circular Linked Queue: enq public void enq(Object item) { QueueNode newNode = new QueueNode(); newNode.info = item; newNode.link = null; if(rear == null){ // list๊ฐ empty์ธ ๊ฒฝ์ฐ rear = newNode; rear.link = newNode; } else{ newNode.link = rear.link; rear.link = newNode; rear = newNode; } size++; }
queue
3
rear
info
info
10
20
2
info 30
1
ArrayQueue VS. LinkedQueue ArrayQueue
LinkedQueue
O(1)
O(1)
dequeue
O(1)
O(1)
constructor
O(N)
O(1)
N+1 ์ฐธ์กฐ, 3 ์์ธ
2N+2 ์ฐธ์กฐ(no waste)
enqueue
space
Which one is better? ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅด๋ค. ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์ LinkedStack์ด ์ฐ์: ํ์ ์๋ ์์๊ฐ ๋ฐฐ์ด ์ฉ๋์ ๋ฐ ์ดํ์ผ ๊ฒฝ์ฐ
๋ฐฐ์ด์ ์ด์ฉํ ํ์ ๊ตฌํ๊ณผ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ํ์ ๊ตฌํ์ ๋น๊ต๋ ์คํ์ ๋น๊ต์ ์ ์ฌํ ๋ค. ์คํ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ ๊ตฌํ ๋ฐฉ์์ ์ํ enqueue์ dequeue๋ ๋ชจ๋ ์์์๊ฐ ์๊ณ ๋ฆฌ ์ฆ์ด๋ค. ์ฆ, ๋ ๊ตฌํ ๋ฐฉ์์ ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์๋ง ๋ค๋ฅด๋ค.
- 88 -
7.5. ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋ฆฌ์คํธ์ ๊ตฌํ ์ด ์ ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ์ ์ดํด๋ณธ๋ค. ๋ํ ๋ฐ ๋ณต์ ํด๋์ค๋ฅผ ์ ์ํ์ฌ ์ฌ์ฉํด๋ณธ๋ค. ์ง๊ธ๊น์ง ๋ฐ๋ณต์๋ ADT๋ฅผ ๊ตฌํํ๋ ํด๋์ค ๋ด์ ํ์ ํ ๋ฉ์๋๋ฅผ ์ง์ ๊ตฌํํ์ฌ ์ ๊ณตํ์์ง๋ง ์ด ์ ๋ถํฐ๋ ๋ณ๋์ ํด๋์ค๋ฅผ ํตํด ๋ฐ๋ณต์๋ฅผ ์ ๊ณต ํ๋ค.
List Class Hierarchy List
ArrayList
UnsortedArrayList
import java.util.Iterator; public interface List extends Iterable{ boolean isEmpty(); boolean isFull(); void clear(); int size(); boolean search(Object item); void insert(Object item); boolean delete(Object item); Object retrieve(Object item); Iterator iterator(); } // List
LinkedList
SortedArrayList
use inner class
UnsortedLinkedList
ListNode
SortedLinkedList
๋ฆฌ์คํธ์ ๊ด๋ จ๋ ์ ์ฒด ํด๋์ค์ ๊ณ์ธต๊ตฌ์กฐ๋ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ์ฌ๊ธฐ์ List๋ ์ธํฐํ์ด์ค ๋ก์ ๋ชจ๋ ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํด์ผ ํ๋ ์ฐ์ฐ๋ค์ ์ ์ธํ๊ณ ์๋ค. java,lang ํจํค์ง์๋ Iterable ์ธํฐํ์ด์ค๊ฐ ์ ์๋์ด ์์ผ๋ฉฐ, ์ด ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค๋
Iterator iterator(); ํํ์ ๋ฐ๋ณต์๋ฅผ ์ ๊ณตํด์ผ ํ๋ค. Iterator๋ java.util ํจํค์ง์ ์ ์๋์ด ์ ๋ ์ธํฐํ์ด์ค๋ก์, ๋ฐ๋ณต์ ํด๋์ค๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณตํด์ผ ํ๋ ์ฐ์ฐ๋ค์ ์ ์ธํ๊ณ ์๋ค.
ArrayList์ LinkedList๋ ๊ฐ๊ฐ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ, ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ตฌํ์ ์ํ ์ถ์ ํด ๋์ค์ด๋ค.
Import java.util.Iterator; public abstract class LinkedList implements List{ protected class ListNode{ public Object info; public ListNode next; } // ListNode protected class ListIterator implements Iterator{ โฆ ListNode์ ListIterator ๋ด๋ถ ํด๋์ค๊ฐ } // ListIterator protected์ธ ์ด์ ๋ ์์ ํด๋์ค์ธ protected ListNode list = null; UnsortedLinkedList์ protected int size = 0; SortedLinkedList์์ ํ์ฉํ๊ธฐ ์ํจ์ด๋ค. public LinkedList(){} public boolean isFull(){ return false; } public boolean isEmpty(){ return (list == null); } void clear(){ โฆ } public int size(){ return size; } public Iterator iterator() { return new ListIterator(list); } public abstract boolean search(Object item); public abstract void insert(Object item); public abstract boolean delete(Object item); public abstract Object retrieve(Object item); } // LinkedList
- 89 -
๋ฐ๋ณต์ ํด๋์ค๋ LinkedList์ ๋ด๋ถ ํด๋์ค๋ก ์ ์ํ์๋ค. ์ด๊ฒ์ ์ธ๋ถ๋ก๋ถํฐ ์ด ํด๋์ค๋ฅผ ์จ๊ธฐ๊ธฐ ์ํ ๋ชฉ์ ๋ณด๋ค๋ ๋ด๋ถ ํด๋์ค๋ ๊ทธ ํด๋์ค๊ฐ ์ํ ์ธ๋ถ ํด๋์ค์ ๋ฉค๋ฒ๋ฅผ ์ฝ๊ฒ ์ ๊ทผ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์ด ๊ธฐ๋ฅ์ ํ์ฉํ๊ธฐ ์ํจ์ด๋ค. ํ์ง๋ง ๋ฐ๋์ ์ด์ ๊ฐ์ด ๋ฐ๋ณต์ ํด๋์ค ๋ฅผ ๋ด๋ถ ํด๋์ค๋ก ๊ตฌํํ ํ์๋ ์๋ค. ๋ฐ๋ณต์ ํด๋์ค ListIterator์ ๋ ธ๋๋ฅผ ๋ํ๋ด๋
ListNode ํด๋์ค๋ฅผ protected๋ก ์ ์ธํ ์ด์ ๋ ์์ ํด๋์ค๋ค์ธ UnsortedLinkedList์ SortedLinkedList์์ ์ด๋ค์ ๋ํ ์ ๊ทผ์ ์ฉ์ดํ๊ฒ ํ๊ธฐ ์ํจ์ด๋ค.
๋ฐ๋ณต์ ํด๋์ค protected class ListIterator implements Iterator{ public ListNode cursor; public int traverseCount = 0; public ListIterator(ListNode node){ cursor = node; } public Object next(){ ๋ฐ๋์ ๋ฐ๋ณต์ ํด๋์ค๋ฅผ ๋ด๋ถ ํด๋์ค๋ก Object tmp = cursor.info; ๊ตฌํํ ํ์๋ ์๋ค. cursor = cursor.next; traverseCount++; return tmp; } traverseCount ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ public boolean hasNext(){ cursor๋ง์ ์ด์ฉํ์ฌ ๊ตฌํํ ์๋ ์๋ค. return (traverseCount<size); ํ์ง๋ง CircularLinkedList๊น์ง ๊ณ ๋ คํ์ฌ // return (cursor!=null) traverseCount ๋ณ์๋ฅผ ํ์ฉํ๊ณ ์๋ค. } public void remove(){ throw new UnsupportedOperationException(); } } // ListIterator
java.util ํจํค์ง์ ์ ์๋์ด ์๋ Iterator ์ธํฐํ์ด์ค์๋ next, hasNext, remove ์ธ ๊ฐ์ง ๋ฉ ์๋๊ฐ ์ ์ธ๋์ด ์๋ค. ์ด ์ค remove๋ ํ์ฌ ๋ฐฉ๋ฌธ ์ค์ธ ์์๋ฅผ ์ญ์ ํ ๋ ์ฌ์ฉํ๋ ๋ฉ์๋ ์ด๋ค. ์ด ๋ฉ์๋๋ฅผ ์ ๊ณตํ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ UnsupportedOperationException ์์ธ๋ฅผ ๋ฐ ์ํ๋๋ก ๊ตฌํํ๋ฉด ๋๋ค. LinkedList์์ ์ฌ์ฉํ๋ ๋ฐ๋ณต์ ํด๋์ค๋ traverseCount๋ผ๋ ๋ฉค๋ฒ ๋ณ์๋ฅผ ์ฌ์ฉํ๊ณ ์๋๋ฐ, ์ด ๋ฉค๋ฒ ๋ณ์๋ฅผ ์ฌ์ฉํ์ง ์๊ณ hasNext() ๋ฉ์๋์์ cursor!=null ์ ์ด์ฉํ์ฌ ๊ตฌํํ ์ ์๋ค. ํ์ง๋ง ์ฌ๊ธฐ์ traverseCount๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋ ๋ค์ ์ฅ์์ ์ดํด๋ณผ ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์๋ ๊ฐ์ ๋ฐ๋ณต์ ํด๋์ค๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํจ์ด๋ค. ์์ฑ์์์
cursor๋ฅผ list๋ก ์ด๊ธฐํํ์ง ์๊ณ node๋ผ๋ ๋งค๊ฐ๋ณ์๋ฅผ ๋ฐ์ cursor๋ฅผ ์ด๊ธฐํํ๋ ์ด์ ๋ ๊ฐ ์ ์ด์ ์ด๋ค.
- 90 -
UnsortedLinkedList, SortedLinkedList public class UnsortedLinkedList extends LinkedList{ public UnsortedLinkedList() { super(); } public boolean search(Object item) throws ListUnderflowException{ โฆ } public void insert(Object item){ โฆ } public boolean delete(Object item) throws ListUnderflowException{ โฆ } public Object retrieve(Object item) throws ListUnderflowException{ โฆ} } // UnsortedLinkedList public class SortedLinkedList extends LinkedList{ public SortedLinkedList() { super(); } public boolean search(Object item) throws ListUnderflowException{ โฆ } public void insert(Object item){ โฆ } public boolean delete(Object item) throws ListUnderflowException{ โฆ } public Object retrieve(Object item) throws ListUnderflowException{ โฆ} } // UnsortedLinkedList
์ด์ง๊ฒ์์ ํ ์ ์๋ค. ์๋ค. ์ ๋ ฌ๋์ด ์์ ๊ฒฝ์ฐ์๋ ๊ฒ์์ ์ค๊ฐ์ ์ค๋จํ ์ ์๋ค.
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ ํด๋์ค๋ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ๋ฐฐ์ด์ ์ด์ฉ ํ ๊ตฌํ๊ณผ ๋ฌ๋ฆฌ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ ฌ ๋ฆฌ์คํธ๋ ์์ ์ ๊ทผ์ ์ ๊ณตํ์ง ์์ผ๋ฏ๋ก ์ด์ง ๊ฒ์ ์ ํ ์ ์๋ค.
UnsortedLinkedList: search public boolean search(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); // if(item==null) return false; ListNode loc = list; boolean moreToSearch = true; do{ if(item.equals(loc.info)) return true; else{ loc = loc.next; moreToSearch = (loc != null); } }while(moreToSearch); return false; } // UnsortedList: search loc info
info
info
info
10
50
30
20
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ด๋ฏ๋ก ์ ๋ ฌ ๋ฆฌ์คํธ์ด์ด๋ ์์ฐจ์ ์ผ๋ก ๊ฒ์ํ ์๋ฐ์ ์๋ค. item์ด null์ธ์ง ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ์ฌ nullPointerException์ ์ง์ ๋ฐ์ํ ์ ์๊ณ , ์ฃผ์๊ณผ ๊ฐ์ด false ๋ฐํํ ์ ๋ ์๋ค. ์ ์๋ ๋ฌธ์ ์ ์์ธ์ ์ ํํ๊ฒ ์ ๋ฌํ๋ ์ธก๋ฉด์์ ์ด์ ์ด ์๊ณ , ํ์๋ ์์ธ ๋ฐ ์์์ด ํ๋ก๊ทธ๋จ์ด ๊ณ์ ์ํ๋๋ค๋ ์ธก๋ฉด์์ ์ด์ ์ด ์๋ค. ๊ฒ์์์ ๋น๊ต๋ ๋ณดํต equals ๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ๋ค. ์ข ๋ฃ์กฐ๊ฑด์ ๋ํ๋ด๋ moreToSearch๋ผ๋ ๋ณ์๋ฅผ ํ์ฉํ ์ ์ ๊ณ , ์ด๊ฒ์ ์ฌ์ฉํ์ง ์๊ณ ๋ค์ ์ฌ๋ผ์ด๋์ฒ๋ผ size ์ ๋ณด๋ฅผ ์ด์ฉํ ์๋ ์๋ค.
- 91 -
UnsortedLinkedList: search
public boolean search(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); ListNode loc = list; for(int i=0; i<size; i++){ if(item.equals(loc.info)) return true; else loc = loc.next; } // for return false; } // UnsortedList: search
SortedLinkedList: search public boolean search(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); Comparable x = (Comparable)item; ListNode loc = list; boolean moreToSearch = true; do{ int compResult = x.compareTo(loc.info); if(compResult==0) return true; else if(compResult<0) return false; else{ loc = loc.next; moreToSearch = (loc != null); } }while(moreToSearch); return false; } // SortedLinkedList: search (์ค๊ฐ์ ์ค๋จ ๊ฐ๋ฅ) list info
info
info
info
10
20
30
50
๋ฐฐ์ด์ ์ด์ฉํ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ์์๋ ์ด์ง ๊ฒ์์ ์ฌ์ฉํ์ฌ ๋ก๊ทธ ์๊ฐ์ ๊ฒ์์ ํ ์ ์๋ค. ๊ทธ๋ฌ๋ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ ฌ ๋ฆฌ์คํธ์์๋ ์์ ์ ๊ทผ์ ์ ๊ณตํ์ง ์์ผ๋ฏ๋ก ์ ๋ ฌ ๋ฆฌ ์คํธ์์๋ ์ ํ ๊ฒ์๋ฐ์๋ ํ ์ ์๋ค. ํ์ง๋ง ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ์ ๋ ฌ๋์ด ์์ผ๋ฏ๋ก ๊ฒ์์ ์ค๊ฐ์์ ์ค๋จํ ์๋ ์๋ค. ์ค๊ฐ์ ์ค๋จํ๊ธฐ ์ํด์๋ equals ๋ฉ์๋ ๋์ ์
compareTo ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ผ ํ๋ค. ๋ํ ์ด๋ฅผ ์ํด ์ธ์๋ก ๋ฐ์ item์ Comparable ํ์ ์ผ๋ก ํ์ ๋ณํํด์ผ ํ๋ค.
- 92 -
SortedLinkedList: search public boolean search(Object item) throws ListUnderflowException{ if(item==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; ListNode loc = list; for(int i=0; i<size; i++){ int compResult = x.compareTo(loc.info); if(compResult==0) return true; else if(compResult<0) return false; else loc = loc.next; } // for return false; } // SortedLinkedList: search (์ค๊ฐ์ ์ค๋จ ๊ฐ๋ฅ)
public boolean delete(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); ListNode loc = list; ListNode prevLoc = null; for(int i=0; i<size; i++){ if(x.equals(loc.info)){ // ์ญ์ ํ ์์๊ฐ ์๋ ๊ฒฝ์ฐ if(prevLoc==null) list = list.next; // ๋ฆฌ์คํธ์ ์ฒ์ else prevLoc.next = loc.next; size--; return true; } else{ // ๊ฒ์์ ๊ณ์ํด์ผ ํ๋ ๊ฒฝ์ฐ prevLoc = loc; loc = loc.next; } } // for return false; } // UnsortedLinkedList: delete list
prevLoc
loc
info
info
info
info
10
50
30
10
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ค๊ฐ ๋ ธ๋๋ฅผ ์ญ์ ํ๊ธฐ ์ํด์๋ ๊ทธ ๋ ธ๋์ ์ ํ ๋ ธ๋์ ํ์ ๋ ธ๋ ์ ๋ณด๋ฅผ ๋ชจ๋ ์์์ผ ํ๋ค. ์ฆ, ๊ทธ ๋ ธ๋์ ์ ํ ๋ ธ๋์ ์ฐ๊ฒฐ ์ ๋ณด๋ฅผ ๋ ธ๋์ ํ์ ๋ ธ๋๋ก ๋ณ๊ฒฝํด์ฃผ์ด์ผ ํ๋ค. ์ด๋ฅผ ์ํด ์ญ์ ํ๊ณ ์ ํ๋ ์์๋ฅผ ์ฐพ์ ๋ ํ์ฌ ๋ ธ๋ ์ ๋ณด(loc) ์ ํ์ฌ ๋ ธ๋์ ์ ํ ๋ ธ๋ ์ ๋ณด(prevLoc)๋ฅผ ํจ๊ป ์ ์งํด์ผ ํ๋ค. ๋ ๋ฆฌ์คํธ์ ์กฐ์ํ ๋์๋ ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด ๊ณ ๋ คํด์ผ ํ๋ค. ์ฒซ์งธ, ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ ๋์งธ, ๋ฆฌ์คํธ ๋งจ ์์ ์์๋ฅผ ์ถ๊ฐ/๋งจ ์์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ ์ ์งธ, ๋ฆฌ์คํธ ์ค๊ฐ์ ์์๋ฅผ ์ถ๊ฐ/์ค๊ฐ์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ ๋ท์งธ, ๋ฆฌ์คํธ ๋งจ ๋์ ์์๋ฅผ ์ถ๊ฐ/๋งจ ๋์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ ์ญ์ ์ ๊ฒฝ์ฐ์๋ ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ์๋ ListUnderflowException์ ๋ฐ์ํ๋ค. ๋งจ ์์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ์๋ ๋ฆฌ์คํธ์ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ list ์ ๋ณด๋ ๋ณ๊ฒฝํด์ผ ํ๋ค. ์ค ๊ฐ ๋๋ ๋์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ๋ ๋ชจ๋ ํ์ฌ ๋ ธ๋์ ์ ํ ๋ ธ๋์ ์ฐ๊ฒฐ์ ํ์ฌ ๋ ธ ๋์ ํ์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋๋ค. ์ฆ, ์ค๊ฐ ๋๋ ๋์ ์๋ ์์์ ์ญ์ ๋ ๋
- 93 -
์ผํ๊ฒ ์ทจ๊ธํ ์ ์๋ค.
SortedLinkedList: delete public boolean delete(Object item) throws ListUnderflowException{ if(item==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; ListNode loc = list; ListNode prevLoc = null; for(int i=0; i<size; i++){ int compResult = x.compareTo(loc.info); if(compResult==0){ // ์ญ์ ํ ์์๊ฐ ์๋ ๊ฒฝ์ฐ if(prevLoc==null) list = list.next; // ๋ฆฌ์คํธ์ ์ฒ์ else prevLoc.next = loc.next; size--; return true; } // ์ญ์ ํ ์์๊ฐ ์๋ ๊ฒฝ์ฐ else if(compResult<0) return false; else{ // ๊ฒ์์ ๊ณ์ํด์ผ ํ๋ ๊ฒฝ์ฐ prevLoc = loc; loc = loc.next; } } // for return false; } // SortedLinkedList: delete
์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ญ์ ๋ ์ญ์ ํ๊ณ ์ ํ๋ ์์๋ฅผ ์ฐพ์ ๋ ๋ฆฌ์คํธ ์ค๊ฐ์์ ๊ฒ์์ ์ค๋จํ ์ ์๋ค๋ ๊ฒ์ ์ ์ธํ๊ณ ๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฐ๋ค.
UnsortedLinkedList: insert ๋ฐฐ์ด ๊ตฌํ์ ๊ฒฝ์ฐ์๋ ๋งจ ๋์ ์ฐ๊ฒฐ ๊ตฌ์กฐ ๊ตฌํ์ ๊ฒฝ์ฐ์๋ ๋งจ ์ฒ์์
2
public void insert(Object item){ ListNode newNode = new ListNode(); newNode.info = item; newNode.next = list; list = newNode; size++; } // UnsortedLinkedList: insert
list
info 25
1 info
info
info
info
10
50
30
10
๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ์์ ์ฝ์ ์ ํญ์ ๋ฆฌ์คํธ์ ๋์ ์ด๋ฃจ์ด์ก๋ค. ํ์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ตฌํ์์๋ ์ฝ์ ์ ํญ์ ๋ฆฌ์คํธ ๋งจ ์์ ํ๋ ๊ฒ์ด ๊ฐ ์ฅ ํจ์จ์ ์ด๋ค.
- 94 -
public void insert(Object item){ if(item==null) throw new NullPointerException(โโฆโ); Comparable x = (Comparable)item; ListNode newNode = new ListNode(); newNode.info = item; ListNode loc = list; ListNode prevLoc = null; for(int i=0; i<size; i++){ // ์ฝ์ ํ ์์น ๊ฒฐ์ if(x.compareTo(loc.info)<0) break; else{ prevLoc = loc; loc = loc.next; } } // for if(prevLoc==null){ // ๋ฆฌ์คํธ์ ๋งจ ์ฒ์ newNode.next = list; list = newNode; 2 } else{ // ๋ฆฌ์คํธ ์ค๊ฐ ๋๋ ๋ newNode.next = loc; info prevLoc.next = newNode; } 20 size++; } // SortedLinkedList: insert
list
1 info 10
info 25
1 info 30
์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ์์ผ ํ๋ฉฐ, ์ญ์ ์ฐ์ฐ์ ์ค๋ช ํ ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ฌ ๊ตฌํํด์ผ ํ๋ค. ์ฝ์ ์ ๊ฒฝ์ฐ์๋ ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ์ ๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ๋ฅผ ๋์ผํ๊ฒ ์ทจ๊ธํ ์ ์๋ค. ๋ํ ๋ฆฌ์คํธ ์ค๊ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ์ ๋ฆฌ์คํธ ๋งจ ๋์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ๋ฅผ ๋์ผํ๊ฒ ์ทจ๊ธํ ์ ์๋ค.
๋ฐ๋ณต์์ ์ฌ์ฉ void print(SortedLinkedList l){ Iterator i = l.iterator(); while(i.hasNext()){ System.out.print(i.next()+โ,โ); } System.out.println(); }
๋ด๋ถ ํด๋์ค๋ก ๊ตฌํ๋ ๋ฐ๋ณต์ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ์ฆ, iterator ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ๋ฐ๋ณต์๋ฅผ ์์ฑํ ๋ค์์ hasNext์ next ๋ฉ์๋๋ฅผ ์ด์ฉํ์ฌ ๊ตฌ์กฐ์ ์ ์ฅ๋์ด ์๋ ์์๋ค์ ์ฐจ๋ก๋ก ๋ฐฉ๋ฌธํ ์ ์๋ค.
- 95 -
List์ ๋น๊ต Unsorted, Array
Unsorted, Linked
Sorted, Array
Sorted, Linked
search
O(N)
O(N)
O(logN)
O(N)
retrieve
O(N)
O(N)
O(logN)
O(N) O(N), O(1) ์ ์ฒด: O(N)
insert
O(1)
O(1)
O(logN), O(N) ์ ์ฒด: O(N)
delete
O(N), O(1) ์ ์ฒด: O(N)
O(N), O(1) ์ ์ฒด: O(N)
O(logN), O(N) ์ ์ฒด: O(N)
O(N), O(1) ์ ์ฒด: O(N)
space
N+1 ์ฐธ์กฐ, 2 ์ ์
2N+2 ์ฐธ์กฐ, 1 ์ ์
N+1 ์ฐธ์กฐ, 2 ์ ์
2N+2 ์ฐธ์กฐ, 1 ์ ์
์ง๊ธ๊น์ง ์ดํด๋ณธ ๋ค ๊ฐ์ง ๋ฆฌ์คํธ์ ์ฑ๋ฅ์ ๋น๊ตํ์ฌ ๋ณด์. ์ฐ์ ๊ตฌํ๋ฐฉ์๊ณผ ์๊ด์์ด ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ ์ ํ ๊ฒ์๋ง ๊ฐ๋ฅํ๋ฏ๋ก ๊ฒ์, ์ญ์ ๋ ๋ชจ๋ ์ต์ ์ ํ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์๋ ์ด์ง ๊ฒ์์ ํ ์ ์์ผ๋ฏ๋ก ๋ก๊ทธ ์๊ฐ ์ ๊ณ ๋ฆฌ์ฆ์ด์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ตฌํ์์๋ ์ฌ์ ํ ์ ํ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ(์ต์ ์ ๊ฒฝ์ฐ)์ด๋ค. ์ฝ์ ์ ๊ฒฝ์ฐ์๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ๊ตฌํ๋ฐฉ์๊ณผ ์๊ด์์ด ์์ ์๊ฐ์ ๊ฐ๋ฅํ์ง๋ง ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ์ฝ์ ์์น๋ฅผ ์ฐพ์์ผ ํ๋ฏ๋ก ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์ ์ต์ ๋ก๊ทธ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๊ณ , ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ตฌํ์ ์ต์ ์ ํ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ด๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ์ด ์ฉํ ๊ตฌํ์์๋ ํ์ ์์๋ค์ ๋ชจ๋ ํ๋์ฉ ์ด๋ํด์ผ ํ๋ฏ๋ก ๊ฒฐ๊ตญ ์ต์ ์ ํ ์๊ฐ ์๊ณ ๋ฆฌ ์ฆ์ด๋ค. ๋ฐ๋๋ก ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๊ตฌํ์์๋ ์ค์ ์ฝ์ ์ ์ฐ๊ฒฐ๋ง ๋ฐ๊พธ๋ฉด ๋๋ค.
- 96 -
์ 8์ฅ ์ฐ๊ฒฐ๊ตฌ์กฐ ํ์ฅ ์ด ์ฅ์์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋ฆฌ์คํธ ๊ตฌํ์ ์ฌ๋ฌ ๊ฐ์ง ํ์ฅ์ ์ดํด๋ณธ๋ค.
8.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋ฆฌ์คํธ ๊ตฌํ
8.2. ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ
์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๋ง์ง๋ง ๋ ธ๋์ ๋งํฌ๋ฅผ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณํํ ๋ฆฌ์คํธ list
info
info
info
10
20
30
์ฅ์ . ์ฅ์ . ์ด๋ค ๋ ธ๋์์ ์ถ๋ฐํด๋ ์ ์ฒด ๋ฆฌ์คํธ๋ฅผ ๋ฐฉ๋ฌธํ ์ ์๋ค. ๊ธฐ์กด ์ฐ์ฐ๋ค์ ํญ์ ๋ง์ง๋ง ๋ ธ๋๊ฐ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ์์ ํด์ผ ํ๋ค. ์์ ์ ๊ฐ์ฅ ํฐ ๋ฌธ์ ์ ์ฒซ ๋ ธ๋์ ์ญ์ ๋๋ ๋ฆฌ์คํธ ๋งจ ์์ ๋ ธ๋์ ์ฝ์ : ๋ง์ง๋ง ๋ ธ๋๊น์ง ์ด๋ํ์ฌ์ผ ํ๋ค.
์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ 7์ฅ์์ ์ดํด๋ณธ ์ํ ์ฐ๊ฒฐ ํ์ ์ ์ฌํ๋ค. ๋ณดํต ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋ฆฌ์ค ํธ์์๋ ์ฒซ ๋ฒ์งธ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์ ๋ณด๋ง ์ ์งํ๊ณ ๋ง์ง๋ง ๋ ธ๋์ ์ฐ๊ฒฐ ์ ๋ณด๋ null ๊ฐ์ ๊ฐ์ง๊ฒ ๋๋ค. ์ด๊ฒ์ ๋ณํํ์ฌ ๋ง์ง๋ง ๋ ธ๋๊ฐ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํ๋ฉด ์ด๋ค ๋ ธ๋์์ ์ถ ๋ฐํ์ฌ๋ ์ ์ฒด ๋ฆฌ์คํธ๋ฅผ ๋ฐฉ๋ฌธํ ์ ์๋ ์ด์ ์ ์ป์ ์ ์๋ค. ํ์ง๋ง ์ด์ ์ฒ๋ผ ์ฒซ ๋ฒ์งธ ๋ ธ
- 97 -
๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์ ๋ณด๋ง ์ ์งํ ๊ฒฝ์ฐ์๋ ์ฒซ ๋ ธ๋๋ก ์ ์์๊ฐ ์ฝ์ ๋๊ฑฐ๋ ์ฒซ ๋ ธ๋๋ฅผ ์ญ์ ํด ์ผ ํ๋ ๊ฒฝ์ฐ์ ๋น์ฉ์ด ๋๋ฌด ๋ง์ด ์์๋๋ค.
์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ โ ๊ณ์ ํด๊ฒฐ์ฑ : ํด๊ฒฐ์ฑ ์ฒซ ๋ ธ๋ ๋์ ์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ์ ์ง info
info
info
10
20
30
list
์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ ๊ทผํ๊ธฐ๊ฐ ๋ชจ๋ ์ฉ์ดํจ ๋ง์ง๋ง ๋ ธ๋์ ๋ด์ฉ: list.info ์ฒซ ๋ ธ๋์ ๋ด์ฉ: list.next.info info
list
30
์ด๊ฒ์ ํด๊ฒฐํ์ฌ ์ํด ์ฒซ ๋ ธ๋์ ๋ํ ์ ๋ณด๋ฅผ ์ ์งํ์ง ์๊ณ ๋ง์ง๋ง ๋ ธ๋์ ๋ํ ์ ๋ณด๋ฅผ ์ ์งํ ์ ์๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋์ ๋ํ ์ ๊ทผ์ด ๋ชจ๋ ์ฉ์ดํด์ง๋ค. ๋ฐ๋ผ์ ์ฒซ ๋ ธ๋๋ก ์ ์์๋ฅผ ์ฝ์ ํ๋ ๋น์ฉ์ด๋ ์ฒซ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๋น์ฉ์ด ๋ชจ๋ ์์ ์๊ฐ์ด๋ค. ๋ฟ๋ง ์๋๋ผ ์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ๊ตฌํํ๋ฉด ๊ฐ์ฅ ํฐ ๊ฐ๊ณผ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ์ ์๊ฐ์ ์ ๊ทผํ ์ ์์ผ๋ฏ๋ก ์ด๋ฅผ ์ด์ฉํ์ฌ ๊ฐ ์ข ์ฐ์ฐ๋ค์ ๋งค์ฐ ํจ์จ์ ์ผ๋ก ๊ฐ์ ํ ์ ์๋ค.
List Class Hierarchy List
ArrayList
UnsortedArrayList
LinkedList
SortedArrayList
UnsortedLinkedList
SortedLinkedList
CircularSortedLinkedList
์ด ์ ์์๋ ์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ์ ์ดํด๋ณธ๋ค. ์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๊ธฐ์ ์์ ๊ธฐ์กด ๋ฆฌ์คํธ ๊ด๋ จ ํด๋์ค ๊ณ์ธต ๊ตฌ์กฐ์์ ์ด๋์ ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์์น ํด์ผ ํ๋์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๊ธฐ์กด ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋ฆฌ์คํธ์ ๋ง์ฐฌ๊ฐ์ง ๋ก ListNode๋ผ๋ ๋ด๋ถ ํด๋์ค๋ฅผ ์ฌ์ฉํด์ผ ํ๋ฉฐ, isFull, isEmpty, size์ ๊ฐ์ ๋ฉ์๋๋ค์
LinkedList ์ถ์ ํด๋์ค์ ์ ์๋์ด ์๋ ๊ฒ์ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์๋ค. ํ์ง๋ง ์ฝ์ , ์ญ์ ,
- 98 -
๊ฒ์ ๋ฉ์๋๋ ๊ธฐ์กด ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ ์๋์ด ์๋ ๋ฉ์๋๋ฅผ ๊ทธ๋๋ก ์ฌ์ฉํ ์ ์ ๋ค. ์ด๊ฒ์ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ list๋ผ๋ ๋ฉค๋ฒ ๋ณ์๊ฐ ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํจ ๋ฐ๋ฉด ์ํ ์ฐ๊ฒฐ ๋ฐฉ์์์๋ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ณ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋
SortedLinkedList๋ฅผ ์์๋ฐ๋ ๊ฒ๋ณด๋ค๋ LinkedList๋ฅผ ์์๋ฐ๋ ๊ฒ์ด ์ฌ๋ฐ๋ฅด๋ค.
CircularSortedLinkedList public class CircularSortedLinkedList extends LinkedList{ public CircularSortedLinkedList() { super(); } public boolean search(Object item) throws ListUnderflowException{ โฆ } public void insert(Object item){ โฆ } public boolean delete(Object item) throws ListUnderflowException{ โฆ } public Object retrieve(Object item) throws ListUnderflowException{ โฆ } public Iterator iterator() { return (list==null) ? new ListIterator(null) : new ListIterator(list.next); } }
CircularSortedLinkedList์ search public boolean search(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; ListNode loc = list.next; for(int i=0; i<size; i++){ int compResult = x.compareTo(loc.info); if(compResult==0) return true; else if(compResult<0) return false; else loc = loc.next; } return false; } // CircularSortedList::search loc
list
info
info
info
info
10
20
30
40
์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๊ฒ์์ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๊ฒ์๊ณผ loc์ ์ด๊ธฐํ๋ง ๋ค๋ฅผ ๋ฟ ๊ฐ๋ค. ์ญ์ ์ ์ฝ์ ์ฐ์ฐ์ loc์ ์ด๊ธฐํ๋ฟ๋ง ์๋๋ผ ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๊ฐ ์กฐ์๋๋ฉด ์ํ์ ์ ์งํ๊ธฐ ์ํ ์ถ๊ฐ ์์ ์ด ํ์ํ๋ค.
- 99 -
CircularSortedLinkedList์ delete prevLoc
loc
list
info
info
info
info
10
20
30
40
prevLoc
loc
list
info
info
info
info
10
20
30
40
์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ prevLoc.next = loc.next;
์ฒซ ๋ ธ๋ list.next = list.next.next; ๋๋ list.next = loc.next;
CircularSortedLinkedList์ delete loc prevLoc
list
info
info
info
info
10
20
30
40 ๋ง์ง๋ง ๋ ธ๋ prevLoc.next = loc.next; list = prevLoc;
loc prevLoc
list
info
์ ์ผ ๋ ธ๋ list = null;
10
ํญ์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๊ตฌํ์์๋ ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ์ฒซ ๋ ธ๋์ ์ญ์ , ์ฒซ ๋ ธ๋์ ์ญ์ ์ ํน์ํ ๊ฒฝ์ฐ๋ก ๋ฆฌ์คํธ๊ฐ ๋ ธ๋์ ํ๋๋ฐ์ ์๋ ๊ฒฝ์ฐ, ์ค๊ฐ ๋ ธ๋์ ์ญ์ , ๋ง ์ง๋ง ๋ ธ๋์ ์ญ์ ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ์ค๊ฐ ๋ ธ๋์ ์ญ์ ๋ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋์ผํ์ง ๋ง ์ฒซ ๋ ธ๋์ ์ญ์ ๋๋ ๋ง์ง๋ง ๋ ธ๋์ ์ญ์ ์ ๋ํด์๋ ์ํ์ ์ ์งํ๊ธฐ ์ํ ์ถ๊ฐ ์์ ์ด ํ์ํ๋ค.
- 100 -
public boolean delete(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; ListNode loc = list.next; ListNode prevLoc = null; for(int i=0;i<size;i++){ int compResult = x.compareTo(loc.info); if(compResult==0){ // ์ญ์ ํ ๋ ธ๋๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ if(prevLoc==null){ // ์ฒซ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ if(loc == loc.next) list = null; // ์ฒซ ๋ ธ๋๊ฐ ์ ์ผ ๋ ธ๋์ธ ๊ฒฝ์ฐ else list.next = loc.next; if(loc == loc.next) ๋์ ์ } if(size==1)๋ฅผ ์ฌ์ฉํ ์ ์์ else{ prevLoc.next = loc.next; if(loc==list) list = prevLoc; // ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ } size--; return true; } else if(compResult<0) return false; else{ prevLoc = loc; loc = loc.next; } } // for return false; } // CircularSortedList::delete
์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๋ชจ๋ ์ ๊ทผํ๊ธฐ๊ฐ ์ฉ์ดํ๋ค๋ ์ํ ์ฐ๊ฒฐ ๊ตฌ์กฐ์ ํน์ฑ์ ์ด์ฉํ์ฌ ๋ณด๋ค ํจ์จ์ ์ผ๋ก delete ๋ฉ์๋๋ฅผ ๊ตฌํํ ์ ์๋ค. ์ฆ, ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋์ ๋น๊ตํ์ฌ ์ฒซ ๋ ธ๋๋ณด๋ค ์์ ๊ฒฝ์ฐ์ ์ฒซ ๋ ธ๋์ ํฐ ๊ฒฝ์ฐ์ ๋ํด์๋ ๋ฆฌ์คํธ ์ ์ฒด๋ฅผ ๊ฒ์ํ์ฌ ์ญ์ ํ ๋ ธ ๋๊ฐ ์๋์ง ์ฐพ๋ ๊ณผ์ ์ ์๋ตํ ์ ์๋ค.
์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๋ชจ๋ ์ ๊ทผํ๊ธฐ๊ฐ ์ฉ์ดํ๋ค๋ ์ํ ์ฐ๊ฒฐ ๊ตฌ์กฐ์ ํน์ฑ์ ์ด์ฉํ delete ๋ฉ์๋
public boolean delete(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; if(x.compareTo(list.next.info)<0||x.compareTo(list.info)>0){ return false; } // ๋๋จธ์ง ๋ถ๋ถ์ ๋์ผ } // CircularSortedList::delete
- 101 -
CircularSortedLinkedList์ insert loc prevLoc
list
info
info
info
10
20
40
๋น ๋ฆฌ์คํธ list = newNode; list.next = newNode; loc prevLoc
list
info ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ newNode.next = loc; prevLoc.next = newNode;
info
30
10
CircularSortedLinkedList์ insert prevLoc
loc
list
info
info
info
info
10
20
30
40
์ฒซ ๋ ธ๋ newNode.next = loc; list.next = newNode;
prevLoc loc
list
info
info
info
info
10
20
30
40
๋ง์ง๋ง ๋ ธ๋ newNode.next = loc; prevLoc.next = newNode; list = newNode;
์ฝ์ ๋ ์ญ์ ์ ๋ง์ฐฌ๊ฐ์ง๋ก ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ๋ฆฌ์คํธ ๋งจ ์์ ์ถ๊ฐํ๋ ๊ฒฝ์ฐ, ๋งจ ์์ ์ถ๊ฐ์ ํน์ํ ๊ฒฝ์ฐ๋ก ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ, ์ค๊ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ, ๋ฆฌ์ค ํธ ๋งจ ๋์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ๊ฐ ๊ฒฝ์ฐ์ ์ ์ฌ์ ์ด ์๋ ๊ฒฝ์ฐ์๋ ์ด๋ฅผ ํ์ฉ ํ์ฌ ๊ตฌํํ๋ ๊ฒ์ด ๋ฐ๋์งํ๋ค. ์๋ฅผ ๋ค์ด ์ค๊ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ์ ๋งจ ๋์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ ๋ชจ๋ ๋์ผํ๊ฒ newNode,next = loc; prevLoc.next = newNode;๋ ์คํ๋์ด์ผ ํ๋ค.
- 102 -
public void insert(Object item){ Comparable x = (Comparable)item; ListNode newNode = new ListNode(); newNode.info = item; newNode.next = null; ListNode loc = (list==null)? null: list.next; ListNode prevLoc = null; for(int i=0;i<size;i++){ // ์ฝ์ ํ ์์น ์ฐพ๊ธฐ if(x.compareTo(loc.info)<0) break; else{ prevLoc = loc; loc = loc.next; } } // for if(prevLoc==null){ // ๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ // ๋ฆฌ์คํธ๊ฐ ๋น์ด์๋ ๊ฒฝ์ฐ if(list==null){ list = newNode; newNode.next = newNode; } else{ newNode.next = loc; list.next = newNode; } } else{ newNode.next = loc; prevLoc.next = newNode; // ๋ฆฌ์คํธ์ ๋งจ ๋ง์ง๋ง์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ if(prevLoc == list) list = newNode; } size++; } // CircularSortedList::insert
์ ์ฌ๋ผ์ด๋์ ์๋ ์ฝ์ ์ฐ์ฐ์ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋์ผํ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ ๊ฒ์ด๋ค. ๋จผ์ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ์ ๋ค์, ์ฝ์ ํ ์์น์ ๋ฐ๋ผ ํ์ํ ๊ฐ ์ข ์ฐ๊ฒฐ์ ๋ณ๊ฒฝํ๋ ๋ฐฉ์์ด ๋ค. ๋ค์ ์ฌ๋ผ์ด๋์ ์๋ ์ฝ์ ์ฐ์ฐ์ ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํน์ฑ์ ํ์ฉํ๊ณ ์๋ค. ์ฆ, ์ ์์๋ฅผ ์ถ๊ฐํ ๋ ๊ทธ ์์๋ฅผ ๋ฆฌ์คํธ์ ์ฒซ ์์์ ๋ง์ง๋ง ์์์ ๋น๊ตํ์ฌ ์ฒซ ์์๋ณด๋ค ์๊ฑฐ ๋ ๋ง์ง๋ง ์์๋ณด๋ค ํด ๊ฒฝ์ฐ์๋ ์ด๊ฒ์ ๋จผ์ ์ฒ๋ฆฌํ์ฌ ์ค๋ค. ๋ ๊ฒฝ์ฐ๋ ์ ๋ ฌ๋ ์ํ ์ฐ๊ฒฐ ๊ตฌ์กฐ์ ํน์ฑ ์ ๊ฐ์ ์์น์ ์ฝ์ ๋๋ ํํ๊ฐ ๋๋ค. ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ public void insert(Object item){ ๋ชจ๋ ์ ๊ทผํ๊ธฐ๊ฐ ์ฉ์ดํ๋ค๋ Comparable x = (Comparable)item; ์ํ ์ฐ๊ฒฐ ๊ตฌ์กฐ์ ํน์ฑ์ ListNode newNode = new ListNode(); ์ด์ฉํ insert ๋ฉ์๋ newNode.info = item; newNode.next = null; size++; if(list==null){ list = newNode; newNode.next = newNode; return; } // ๋ฆฌ์คํธ๊ฐ ๋น์ด ์๋ ๊ฒฝ์ฐ if(x.compareTo(list.next.info)<0||x.compareTo(list.info)>0){ newNode.next = list.next; list.next = newNode; if(x.compareTo(list.info)>0) list = newNode; // ๋งจ ๋์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ return; } // ์ฝ์ ํ๊ณ ์ ํ๋ ๋ ธ๋๊ฐ ์ฒซ ๋ ธ๋๋ณด๋ค ์๊ฑฐ๋ ๋ง์ง๋ง ๋ ธ๋๋ณด๋ค ํฐ ๊ฒฝ์ฐ // ์ฒซ ๋ ธ๋์ ๋น๊ตํ ํ์ ์์ ListNode loc = list.next.next; ListNode prevLoc = list.next; for(int i=0;i<size;i++){ if(x.compareTo(loc.info)<0){ newNode.next = loc; prevLoc.next = newNode; return; } else{ prevLoc = loc; loc = loc.next; } } // for } // CircularSortedList::insert
- 103 -
CircularSortedLinkedList์ ์ฅ๋จ์ ์ฐ์ฐ ์ธก๋ฉด์์๋ SortedLinkedList์ ๋นํด ํฅ์๋ ๊ฒ์ด ์๋ค. ๊ทธ๋ฌ๋ CircularSortedLinkedList๋ ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ ธ๋์ ๋ํ ์ ๊ทผ์ด ์ฉ์ดํ๋ค. ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ ๊ฒ์ ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ณด๋ค ์ฐ์ํ๋ค. ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ์ถ ๋ฆฌ์คํธ์ ์ ์ฅ๋ ๊ฐ๋ค ์ฌ์ด์ ์๋ ๊ฐ์ธ์ง ๋น๊ตํ๋ ๊ฒ ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐ์ํด์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ํ๋ ๋ ์ ์งํ๋ ๊ฒ์? good alternative
์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฅ์ ์ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋น๊ตํ์ฌ ๋ณด์. ์ฐ์ฐ์ ์ฑ๋ฅ ์ธก ๋ฉด์์ ๋ณด๋ฉด ํฅ์๋ ๊ฒ์ด ๊ฑฐ์ ์๋ค. ๊ทธ๋ฌ๋ ์ํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ์ฒซ ๋ ธ๋๋ฟ๋ง ์๋๋ผ ๋ง์ง๋ง ๋ ธ๋์ ๋ํ ์ ๊ทผ์ด ์ฉ์ดํ๋ฏ๋ก ๋ค์๊ณผ ๊ฐ์ ์๋น์ค๋ ๊ธฐ์กด ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ณด๋ค ์ฐ์ํ๋ค. ์ฒซ์งธ, ๊ฐ์ฅ ํฐ ๊ฐ์ ์ถ์ถ ๋์งธ, ๋ฆฌ์คํธ์ ์ ์ฅ๋ ๊ฐ๋ค ์ฌ์ด์ ์๋ ๊ฐ์ธ์ง ์ ํ์๊ฐ ์๋ ๊ฒฝ์ฐ ์ ์งธ, ์ ๋ ฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ฐ์ํด์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ ๋ง์ง๋ง ์๋น์ค์ ๊ฒฝ์ฐ์๋ ์ฝ์ ์ฐ์ฐ์ด ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํน์ฑ์ ํ์ฉํ๊ณ ์์ด์ผ ํ๋ค. ์ด๋ฐ ์ธก๋ฉด์์ ๋ณด์์ ๋ ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ํ ๋ ๋ ์ ์งํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํด ๋ณผ ์ ์๋ค. ์คํ๋ ค ์ด ๋ฐฉ๋ฒ์ด ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋นํด ์ฐ ์ํ ์ ์๋ค.
- 104 -
8.3. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ(doubly linked list)๋ ์ฒซ ๋ ธ๋์ ๋ง์ง๋ง ๋ฆฌ์คํธ ๋ ธ๋๋ฅผ ์ ์ธํ๊ณ ๋ ๋ชจ๋ ํ์ ์์๋ฟ๋ง ์๋๋ผ ์ ํ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ฅผ ์ถ๊ฐ๋ก ๊ฐ์ง๊ณ ์๋ ๋ฆฌ์คํธ list
info
info
info
10
20
30
์ด๋ค ๋ ธ๋์์ ์ถ๋ฐํด๋ ์ ์ฒด ๋ฆฌ์คํธ๋ฅผ ๋ฐฉ๋ฌธํ ์ ์๋ค. ์ญ์์ผ๋ก ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธํ ์ ์๋ค. ์๋ค. ๋ ธ๋์ ๊ตฌ์ฑ: back, info, next protected class DLListNode{ public Object info; 3N+1 public DLListNode back; public DLListNode next; }
์ด์ ๊น์ง์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ์ ๊ฐ ๋ ธ๋๋ ํ ์ชฝ ๋ฐฉํฅ์ ์ฐ๊ฒฐ๋ง์ ์ ์งํ๊ณ ์์ ๋ค. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ์ด์ ๋ฌ๋ฆฌ ์์ชฝ ๋ฐฉํฅ์ ์ฐ๊ฒฐ์ ํ ๋ ธ๋์ ๋ชจ๋ ์ ์งํ๋ค. ๋ฐ๋ผ์ ํ ๋ ธ๋์ 3๊ฐ์ ์ฐธ์กฐ๋ฅผ ์ ์งํด์ผ ํ๋ฏ๋ก ๋ ธ๋ ๋น ์ฐจ์งํ๋ ๊ณต๊ฐ์ด ๋ง๋ค. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ ํ์ฌ ์์นํ ๋ ธ๋๋ก๋ถํฐ ์ด์ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์๋ฃ๊ตฌ์กฐ์ฒ๋ผ ํ์ ์์๋ค์ ์ ๊ทผํ ์ ์์ ๋ฟ๋ง ์๋๋ผ ์ ํ ์์๋ค๋ ์ ๊ทผํ ์ ์๋ค. ์ด ๊ธฐ๋ฅ ๋๋ฌธ์ ๊ธฐ์กด ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ฃ๊ตฌ์กฐ์ ๋ฌ๋ฆฌ ์ญ์์ผ๋ก ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธํ ์ ์๋ค๋ ์ฅ์ ์ ์ง๋๊ณ ์๋ค.
List Class Hierarchy List
ArrayList
UnsortedArrayList
LinkedList
SortedArrayList
UnsortedLinkedList
SortedLinkedList
DoubleLinkedList
UnsortedDoubleLinkedList
SortedDoubleLinkedList
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ ธ๋ ์์ฒด๊ฐ ์ผ๋ฐ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋ค๋ฅด๋ฏ๋ก LinkedList ํด๋์ค์ ์์ ๊ด ๊ณ๋ฅผ ๊ฐ์ง ์ ์๋ค. ๋ฐ๋ผ์ DoubleLinkedList๋ผ๋ ์ถ์ ํด๋์ค๋ฅผ ๋ง๋ค์ด List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋๋ก ํ๊ณ , ์ด์ค ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ด์ค ๋น์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ DoubleLinkedList๋ฅผ ์์๋ฐ์ ๊ตฌํํ๋๋ก ํ๋ค.
- 105 -
public abstract class DoubleLinkedList implements List{ protected class ListNode{ public Object info; public ListNode back; public ListNode next; } protected class ListIterator{ โฆ } protected ListNode list = null; protected int size = 0; public DoubleLinkedList() {} public abstract boolean search(Object item) throws ListUnderflowException; public abstract void insert(Object item); public abstract boolean delete(Object item) throws ListUnderflowException; public abstract Object retrieve(Object item) throws ListUnderflowException; public boolean isFull(){ return false; } public boolean isEmpty(){ return (list == null); } public void clear{ list = null; } public int size(){ return size; } public Iterator iterator() { return new ListIterator(list); } } // DoubleLinkedList class
DoubleLinkedList์์ ๋ ธ๋๋ฅผ ๋ํ๋ด๋ ํด๋์ค์ ์ด๋ฆ์ ListNode์ด๊ณ , ๋ฐ๋ณต์ ํด๋์ค์ ์ด ๋ฆ์ ListIterator์ด๋ค. ์ฆ, LinkedList๊ฐ ์ฌ์ฉํ๋ ์ด๋ฆ๊ณผ ๋์ผํ ์ด๋ฆ์ ์ฌ์ฉํ๋ค. ํ์ง๋ง ๋ด ๋ถ ํด๋์ค์ ์ด๋ฆ์ด๋ฏ๋ก ์ด๋ ๊ฒ ๊ฐ์ ์ด๋ฆ์ ์ฌ์ฉํ์ฌ๋ ๋ฌธ์ ๊ฐ ๋์ง ์๋๋ค. protected class ListIterator{ public ListNode cursor; public int traverseCount = 0; public ListIterator(ListNode node){ cursor = node; } // ListIterator(ListNode) public boolean hasBack(){ return (traverseCount>0); } public boolean hasNext(){ return (traverseCount<size); } public Object back(){ Object tmp = cursor.info; cursor = cursor.back; traverseCount--; return tmp; } // back public Object next(){ Object tmp = cursor.info; cursor = cursor.next; traverseCount++; return tmp; } // next public void remove(){ throw new UnsupportedOperationException(); } // remove }
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๋ฐ๋ณต์ ํด๋์ค์๋ ๊ธฐ์กด ์ฐ๊ฒฐ ๋ฆฌ์คํธ์๋ ์๋ back๊ณผ hasBack ๋ฉ์ ๋๊ฐ ์ถ๊ฐ๋ก ๊ตฌํ๋์ด์ผ ํ๋ค. ์ฆ, ์ฃผ์ด์ง ๋ ธ๋๋ก๋ถํฐ ๊ทธ๊ฒ์ ์ ํ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ ์ ์๋ ๋ฉ์๋๋ฅผ ์ ๊ณตํด์ฃผ์ด์ผ ํ๋ค.
- 106 -
SortedDoubleLinkedList์ Insert prevLoc
list
2
3
1
loc
prevLoc
loc
info
info
info
10
20
3
4
30
1
1 2
2
info
info
info
5
25
50
newNode.next = loc; loc.back = newNode; list = newNode;
newNode.back = prevLoc; newNode.next = loc; prevLoc.next = newNode; loc.back = newNode;
newNode.back = prevLoc; prevLoc.next = newNode;
์ด์ค ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฝ์ ์ฐ์ฐ์ ์ผ๋ฐ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฝ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ์ ์ฌ๋ผ์ด๋์์ ์ด ์ค ๋ฆฌ์คํธ๊ฐ ๋น ๊ฒฝ์ฐ์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ ๋ฅผ ์ ์ธํ ๋๋จธ์ง ์ธ ๊ฐ์ง ๊ฒฝ์ฐ์ ๋ํด ์ฐ๊ฒฐ์ ๋ณ๊ฒฝํ๋ ๋ฐฉ๋ฒ์ ์ค๋ช ํ๊ณ ์๋ค. public void insert(Object item){ Comparable x = (Comparable)item; ListNode newNode = new ListNode(); newNode.info = item; newNode.back = null; newNode.next = null; ListNode loc = list; ListNode prevLoc = null; for(int i=0;i<size;i++){ // ์ฝ์ ํ ์์น๋ฅผ ์ฐพ๋๋ค. if(x.compareTo(loc.info)<0) break; else{ prevLoc = loc; loc = loc.next; } } // for if(prevLoc==null){ // ๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ list = newNode; newNode.next = loc; if(list!=null) loc.back = newNode; // ๋น ๋ฆฌ์คํธ๊ฐ ์๋ ๊ฒฝ์ฐ } else{ newNode.back = prevLoc; newNode.next = loc; prevLoc.next = newNode; if(loc!=null) loc.back = newNode; // ๋งจ ๋ง์ง๋ง์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ๊ฐ ์๋๋ฉด } size++; } // SortedDoubleLinkedList::insert
if(prevLoc==null)์ด ์ฐธ์ด๋ฉด ์ ์์๋ฅผ ๋ฆฌ์คํธ์ ์ฒซ ๋ ธ๋๋ก ์ฝ์ ํ๋ ๊ฒฝ์ฐ์ด๋ค. ์ด ๊ฒฝ์ฐ๋ ๋ค ์ ๋ฆฌ์คํธ๊ฐ ๋น ๊ฒฝ์ฐ์ ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ๋ก ๋๋์ด์ง๋ค. ๋ฐ๋๋ก ์กฐ๊ฑด์ด ๊ฑฐ์ง์ด๋ฉด ์ ์์๋ฅผ ๋ฆฌ์คํธ ์ค๊ฐ ๋๋ ๋์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ์ด๋ค. ๋ฆฌ์คํธ ์ค๊ฐ์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ์๋ ์ ์์๊ฐ ์ ํ ๋ฐ ํ์ ์์๋ฅผ ๋ชจ๋ ๊ฐ์ง๊ฒ ๋์ง๋ง ๋ฆฌ์คํธ ๋ง์ง๋ง์ ์ฝ์ ๋๋ ๊ฒฝ์ฐ์๋ ์ ํ์์๋ง ๊ฐ ์ง๊ฒ ๋๋ค.
- 107 -
SortedDoubleLinkedList์ delete prevLoc
loc
1 info
list
info
info
2 10
prevLoc
20
30
info
info
info
10
20
30
์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ prevLoc.next = loc.next; loc.next.back = prevLoc;
loc
1 list
๋ฆฌ์คํธ์ ์ฒซ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ loc.next.back = null; list = loc.next;
SortedDoubleLinkedList์ delete
list
prevLoc
list
prevLoc
loc
info
info
info
10
20
30
๋ฆฌ์คํธ์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ prevLoc.next = null;
loc
info
๋ฆฌ์คํธ์ ์๋ ์ ์ผ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ list = null;
10
์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ญ์ ๋ ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. ๋ฆฌ์คํธ์ ์กด์ฌํ๋ ์ ์ผ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ์ ๋ฆฌ์คํธ์ ๋งจ ์ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ๋ฅผ ๊ฐ์ด ๊ณ ๋ คํ ์ ์๋ค. ์ด ๋ ์ ์ผํ ์ฐจ์ด์ ์ ํ๋๋ list๊ฐ ์ฒซ ์์์ ํ์ ์์๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝ๋์ด์ผ ํ์ง๋ง ๋ค ๋ฅธ ํ๋๋ list ๊ฐ์ด null์ด ๋์ด์ผ ํ๋ค. ๋ฆฌ์คํธ ์ค๊ฐ์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ์ ๋ฆฌ์ค ํธ ๋์ ์๋ ์์๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ๋ ๊ฐ์ด ๊ณ ๋ คํ ์ ์๋ค. ๋ ๊ฒฝ์ฐ์ ์ ์ผํ ์ฐจ์ด์ ์ ๋ฆฌ ์ค ๋์ ์๋ ์์๋ ํ์ ๋ ธ๋๊ฐ ์์ผ๋ฏ๋ก ๊ทธ๊ฒ์ ์ ํ ๋ ธ๋ ์ ๋ณด๋ง ๋ณ๊ฒฝํ๋ฉด ๋๋ค.
- 108 -
public boolean delete(Object item) throws ListUnderflowException{ if(isEmpty()) throw new ListUnderflowException("โฆ"); Comparable x = (Comparable)item; ListNode loc = list; List prevLoc = null; for(int i=0;i<size;i++){ int compResult = x.compareTo(loc.info); if(compResult==0){ // ์ญ์ ํ ๋ ธ๋๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ if(prevLoc==null){ // ์ฒซ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ๊ฒฝ์ฐ if(loc.next==null) list = null; // ์ญ์ ํ ๋ ธ๋๊ฐ ์ ์ผ ๋ ธ๋์ธ ๊ฒฝ์ฐ else{ loc.next.back = null; list = loc.next; } } else{ prevLoc.next = loc.next; if(loc.next != null) loc.next.back = prevLoc; // ๋ง์ง๋ง ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ } return true; } else if(compResult<0) return false; else{ prevLoc = loc; loc = loc.next; } } // for return false; }
8.4. ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๊ตฌํ
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๊ตฌํ
list
์์ธ
info
next
0
David
2
1
null
5
2
John
4
3
Peter
6
4
Mary
3
5
null
END
6
Robert
END
0
free
1
class ArrayLinkedList{ public static final int DEF_MAX_CAPACITY = 50; public static final int END = -1; private class ListNode{ public Object info; public int next; } private int list = END; private ListNode[] nodes; private int size = 0; private int free = 0; โฆ }
size
5
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ์์ ์ฐ๊ฒฐ์ ๋ฐฐ์ด์ ์์ธ์ ๋ณด๊ฐ ๋๋ค. ๋ฐ๋ผ์ null ๋์ ์ -1์ ์ด์ฉํ์ฌ ๋ฆฌ์คํธ์ ๋์ ๋ํ๋ธ๋ค.
์ด ์ฌ๋ผ์ด๋์์ ๋ณด์ฌ ์ฃผ๊ณ ์๋ฏ์ด ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ ์๋ ์๋ค. ์ผ๋ฐ ์ ์ผ๋ก ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์์๋ ์ ์์๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค ๋์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ๋ณดํ๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์๋ ๋ฏธ๋ฆฌ ํ์ํ ๋งํผ์ ์ถฉ๋ถํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ๋ณดํ ๋ค์์ ์ด ๊ณต๊ฐ์ ์ฌ์ฉ์๊ฐ ์์คํ ์ ๋์ ํ์ฌ ์ง์ ๊ด๋ฆฌํ๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์์ ๋ฐฐ์ด์ ๊ฐ ํญ์ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๋ ธ๋๋ฅผ ๋ํ๋ธ๋ค. ๋ฐ๋ผ์ ํฌ๊ฒ ๋ ๊ฐ์ง ์ฐจ์ด์ ์ด ์๋ค. ์ฒซ ์งธ, ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฝ์ ์ฐ์ฐ์ ๋ ์ด์ ์ฌ์ฉํ ํญ์ด ์์ด ์ฒ๋ฆฌํ ์ ์๋ ๊ฒฝ์ฐ๊ฐ ์๋ค. ๋์งธ, ๊ฐ ๋ ธ๋์ ์ฐ๊ฒฐ ์ ๋ณด๋ ๊ธฐ์กด๊ณผ ๋ฌ๋ฆฌ ์ฃผ์ ์ ๋ณด๊ฐ ์๋๋ผ ๋ฐฐ์ด์ ์์ธ ์ ๋ณด๊ฐ ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ฒซ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ์ ๋ณด ์ญ์ ๋ฐฐ์ด์ ์์ธ ์ ๋ณด๋ก ๋ํ๋ธ๋ค. ๋ํ ์ผ๋ฐ์ ์ธ ์ฐ๊ฒฐ๊ตฌ์กฐ์์ ๋ง์ง๋ง ๋ ธ๋์์ ๋ํ๋ด๊ธฐ ์ํด ๊ทธ ๋ ธ๋์ ์ฐ๊ฒฐ ๊ฐ์ null ๊ฐ์ผ๋ก ์ฌ์ฉํ๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๊ตฌํ์์๋ null ๊ฐ ๋์ ์ -1์ด๋ผ๋ ๊ฐ์ ์ฌ์ฉํ๋ค. ์ด๊ฒ์ -1์ ์ ํจํ ์์ธ ์ ๋ณด๊ฐ ๋ ์ ์๋ ๊ฐ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
- 109 -
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๊ตฌํ โ ๊ณ์ info
info
info
info
info
David
John
Mary
Peter
Robert
free
null
null
list
info
info
info
info
David
John
Peter
Robert
null
null
null
list
free
Mary์ ์ญ์
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๊ตฌํ์ ๋ด๋ถ์ ์ผ๋ก ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ์ ์งํ๋ค. ์ฆ, ํ๋ก๊ทธ๋๋จธ๊ฐ ์ค์ค๋ก ๋น ๊ณต๊ฐ์ ๊ด๋ฆฌํด์ผ ํ๋ค.
๋ณด๋ค ์์ธํ๊ฒ ๊ตฌํ ์๋ฆฌ๋ฅผ ์ดํด๋ณด๋ฉด ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ ๋ด๋ถ์ ์ผ๋ก ๋ ๊ฐ์ ๋ฆฌ์คํธ ๋ฅผ ์ ์งํ๋ค. ํ๋๋ ์์๋ค์ด ์ ์ฅ๋์ด ์๋ ์ ํจํ ๋ ธ๋๋ค์ ์ฐ๊ฒฐํด ๋์ ๋ฆฌ์คํธ์ด๊ณ , ๋ค ๋ฅธ ํ๋๋ ์์๋ค์ด ์ ์ฅ๋์ด ์์ง ์์ ๋น ๋ ธ๋๋ฅผ ์ฐ๊ฒฐํด ๋์ ๋ฆฌ์คํธ์ด๋ค. ๋ง์ฝ ์ ์์ ๋ฅผ ์ถ๊ฐํด์ผ ํ๋ฉด ๋น ๋ ธ๋๋ค์ ๋ฆฌ์คํธ์์ ํ๋์ ๋ ธ๋๋ฅผ ์ ํํ์ฌ ์ด ๋ ธ๋์ ์ ์์๋ฅผ ๋ ์ ํ๊ณ ์ด ๋ ธ๋๋ฅผ ์ ํจํ ๋ ธ๋๋ค์ ๋ฆฌ์คํธ์ ํฌํจํ๋ค. ๋ฐ๋๋ก ๊ธฐ์กด ์์๋ฅผ ์ญ์ ํด์ผ ํ๋ฉด ๊ทธ ๋ ธ๋๋ฅผ ์ ํจํ ๋ ธ๋๋ค์ ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ๊ณ ๋น ๋ ธ๋๋ค์ ๋ฆฌ์คํธ๋ก ์ฎ๊ธด๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ์ ๊ตฌํ โ ๊ณ์ ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ ๊ตฌํ์ ์ฅ์ ๋งค๋ฒ ์ฝ์ ํ ๋๋ง๋ค ๊ณต๊ฐ ํ ๋น์ด ์ด๋ฃจ์ด์ง์ง ์๋๋ค. ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์ ์ ๊ณตํ์ง ์๋ ํ๋ก๊ทธ๋๋ฐ ํ๊ฒฝ์์๋ ์ด ๋ฐฉ๋ฒ์ด ์ ์ผํ ๋์์ด๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ๊ตฌ์กฐ ๊ตฌํ์ ๋จ์ ์ผ๋ฐ์ ์ธ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์๊ณผ ๋ฌ๋ฆฌ ์ฝ์ ์ฐ์ฐ์ ๊ฒฝ์ฐ ๋ฆฌ์คํธ๊ฐ ๊ฝ ์ฐฌ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค. 0 2
David
1
2
5
4
John
3
4 6
Peter
5 3
Mary
6 -1
-1
Robert
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ์ผ๋ฐ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ๋งค๋ฒ ์ฝ์ ํ ๋๋ง๋ค ๊ณต๊ฐ ํ ๋น์ด ์ด ๋ฃจ์ด์ง์ง ์๋๋ค๋ ์ฅ์ ์ ์ง๋๊ณ ์๋ค. ํ์ง๋ง ๋ฐฐ์ด์ ๋ณธ์ง์ ์ธ ํน์ฑ ๋๋ฌธ์ ์ฝ์ ์ฐ์ฐ์ ์ ๊ณต๊ฐ์ด ๋ถ์กฑํ ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํด์ผ ํ๋ค.
- 110 -
ArrayLinkedList์ ์์ฑ์ public ArrayLinkedList(int capacity){ if(capacity<0) setup(DEF_LIST_CAPACITY); else setup(capacity); } // ArrayLinkedList(int) public void setup(int capacity){ nodes = new ListNode[capacity]; // ๋น ๋ ธ๋๋ค์ ๋ฆฌ์คํธ ์์ฑ for(int i=0;i<capacity;i++){ nodes[i] = new ListNode(); nodes[i].info = null; ๋ฏธ๋ฆฌ ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ง๋ ๋ค. nodes[i].next = i+1; } // for ์๋ก์ด item์ ์ฝ์ ํ ๋์๋ nodes[capacity-1].next = END; ์ ๋ ธ๋๋ฅผ ๋ง๋ค์ง ์๊ณ ๋ฐฐ์ด์ } // ArrayLinkedList::setup(int) ๋ง๋ค์ด ๋์ ๋ ธ๋์ item์ ์ฝ์ ํ๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฆฌ์คํธ๋ฅผ ์ฒ์ ์์ฑํ ๋ ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฏธ๋ฆฌ ๋ง๋ ๋ค. ๋ํ ์ ์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ๋ด๋ถ์ ์ผ๋ก ๋ ๊ฐ์ ๋ฆฌ์คํธ๋ฅผ ์ ์งํด์ผ ํ๋ฏ๋ก, ์ฒ์ ์์ฑํ ๋์๋ ๋ฐฐ์ด์ ๋ชจ๋ ํญ๋ค์ ์ฐ๊ฒฐํ์ฌ ๋น ๋ ธ๋๋ค์ ๋ฆฌ์คํธ๋ฅผ ๋ง๋ค์ด์ผ ํ๋ค.
SortedArrayLinkedList์ insert ์์ธ
info
next
์์ธ
info
next
0
null
1
0
john
END
1
null
2
1
null
2
2
null
3
2
null
3
3
null
4
3
null
4
4
null
5
4
null
5
5
null
6
5
null
6
6
null
END
6
null
END
list
-1
์กฐ๊ฑด: ๋ฆฌ์คํธ๊ฐ ๋น ๊ฒฝ์ฐ list == END
int tmp = nodes[free].next; nodes[free].info = item; nodes[free].next = END; list = free; free = tmp;
insert(john);
free
0
size
0
list
0
free
1
size
1
๋ฐฐ์ด์ ์ด์ฉํ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฝ์ ์ ๊ธฐ์กด ์ ๋ ฌ ๋ฆฌ์คํธ์์ ๋ค์๊ณผ ๊ฐ์ ํน์ฑ์ ์ ์ธํ๊ณ ๋ ์ฐจ์ด๊ฐ ์๋ค. ์ฒซ์งธ, ์ ์์๋ฅผ ์ถ๊ฐํ๊ธฐ ์ํด new๋ฅผ ์ฌ์ฉํ์ฌ ๋ ธ๋๋ฅผ ๋ง๋ค์ง ์ ๊ณ , ๋น ๋ ธ๋๋ค์ ๋ฆฌ์คํธ๋ก๋ถํฐ ํ๋์ ๋ ธ๋๋ฅผ ๋ฐ๋๋ค. ๋์งธ, ํ๋ก๊ทธ๋๋ฐ ํ ๋ ์ฌ์ฉํ๋ ํ ๊ธฐ ๋ฐฉ์์ด ๋ค๋ฅด๋ค. ๊ธฐ์กด์๋ loc.info = item๊ณผ ๊ฐ์ ํํ๋ก ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ง๋ง ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์๋ nodes[loc].info = item์ ๊ฐ์ด ๋ฐฐ์ด ์ ํ์์ด ํฌํจ๋ ํํ์ ํํ์์ ์ฌ ์ฉํ๊ฒ ๋๋ค.
- 111 -
SortedArrayLinkedList์ insert ์์ธ
info
next
์์ธ
0
john
END
0
john
1
1
null
2
1
Robert
END
2
null
3
2
null
3
info
์กฐ๊ฑด: ๋ฆฌ์คํธ ๋งจ ๋์ ์ฝ์ loc == END
next
int tmp = nodes[free].next; nodes[free].info = item; nodes[free].next = END; nodes[prevLoc].next = free; free = tmp;
insert(Robert); 3
null
4
3
null
4
4
null
5
4
null
5
5
null
6
5
null
6
6
null
END
6
null
END
list
0
free
1
size
1
list
0
free
2
size
2
์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฝ์ ์ ์ฐ์ ์ฝ์ ํ ์์น๋ฅผ ์ฐพ์์ผ ํ๋ค. ์์น๋ฅผ ์ฐพ์ผ๋ฉด ๋น ๋ฆฌ์คํธ์ ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๊ณ ์์ ์ด ๋ ธ๋์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ณ ์ด ๋ ธ๋๋ฅผ ๊ฒฐ์ ๋ ์์น์ ์ฝ์ ํ๋ค.
SortedArrayLinkedList์ insert ์์ธ
info
next
์์ธ
info
next
0
john
1
0
john
2
1
Robert
END
1
Robert
END
2
null
3
2
mary
1
3
null
4
3
null
4
4
null
5
4
null
5
5
null
6
5
null
6
6
null
END
6
null
END
์กฐ๊ฑด: ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ
int tmp = nodes[free].next; nodes[free].info = item; nodes[free].next = loc; nodes[prevLoc].next = free; free = tmp;
insert(mary);
list
0
free
2
size
2
list
0
- 112 -
free
3
size
3
SortedArrayLinkedList์ insert ์์ธ
info
next
์์ธ
info
์กฐ๊ฑด: ๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ prevLoc == END
next
0
john
2
0
john
2
1
Robert
END
1
Robert
END
2
mary
1
2
mary
1
int tmp = nodes[free].next; nodes[free].info = item; nodes[free].next; = loc; list = free; free = tmp;
insert(Bob); 3
null
4
3
Bob
0
4
null
5
4
null
5
5
null
6
5
null
6
6
null
END
6
null
END
list
0
free
3
size
3
list
3
free
4
size
4
SortedArrayLinkedList์ delete ์์ธ
info
next
์์ธ
info
next
0
John
2
0
John
1
1
Robert
END
1
Robert
END
2
Mary
1
2
null
4
3
Bob
0
3
Bob
0
4
null
5
4
null
5
5
null
6
5
null
6
6
null
END
6
null
END
์กฐ๊ฑด: ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ
nodes[prevLoc].next = nodes[loc].next; nodes[loc].info = null; nodes[loc].next; = free; free = loc;
delete(Mary);
list
3
free
4
size
4
list
3
free
2
size
3
๋ฆฌ์คํธ ์ค๊ฐ์ ์๋ Mary๊ฐ ์ญ์ ๋๋ ๊ฒฝ์ฐ ์ด ๋ ธ๋๋ ๋น ๋ฆฌ์คํธ๋ก ์ฎ๊ฒจ์ ธ์ผ ํ๋ค. ๋ฆฌ์คํธ์ ํน์ฑ ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ๋งจ ์์ ์ฝ์ ํ๋ ๊ฒ์ด ๊ฐ์ฅ ํจ์จ์ ์ด๋ฏ๋ก ์ญ์ ๋๋ ๋ ธ ๋๋ ๋น ๋ฆฌ์คํธ์ ์ฒซ ๋ ธ๋๊ฐ ๋๋ค.
- 113 -
์ 9์ฅ ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ ์ด ์ฅ์์๋ ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ๋ํด ์ดํด๋ณธ๋ค.
9.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ: ํ๋ก๊ทธ๋๋ฐ ๋ฌธ์ ๋ฅผ ์์ ๋ฌธ์ ๋ก ๋ถํดํ์ฌ ํด๊ฒฐํ๋ ๋งค์ฐ ๊ฐ๋ ฅํ๊ณ ์ ์ฉํ ๋ฌธ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ด๋ค. ์ด ๋ ์์ ๋ฌธ์ ๋ ์ ๋ฌธ์ ์ ๋์ผํ ์ข ๋ฅ์ด๋ค. ๋ฐ๋ณต(iteration) ๋์ ์ ์ฌ์ฉํ ์ ์๋ ๋ฐฉ๋ฒ factorial, ์กฐํฉ, ํ๋ ธ์ด ํ์ ๋ฐฐ์ด๋ก ๊ตฌํ๋ ์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ด์ง ๊ฒ์ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ญ์ ์ถ๋ ฅ ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฝ์
9.2. ์ฌ๊ท ๊ธฐ์ด
์ฌ๊ท(recursion) ์ฌ๊ท ํธ์ถ: ํธ์ถ ํธ์ถํ๋ ๋ฉ์๋์ ํธ์ถ๋ฐ๋ ๋ฉ์๋๊ฐ ๊ฐ์ ๋ฉ์๋ ํธ์ถ ์ง์ ์ฌ๊ท(direct recursion): ์๊ธฐ ์์ ์ ๋ฐ๋ก ํธ์ถํ๋ ๋ฉ์๋ ์ฌ๊ท ๊ฐ์ ์ฌ๊ท(indirect recursion): ๋ ์ด์์ ๋ฉ์๋ ํธ์ถ์ด ์ต์ด์ ์ฌ๊ท ํธ์ถ ๋ฉ์๋์ผ๋ก ๋๋์ ์ค๋ ๊ฒฝ์ฐ ์ฌ๊ท์ ์: factorial if n = 0 โง1, n! = โจ โฉ n ร ( n โ 1) ร " ร 1 if n > 0
์8.1) 4!=4ยฑ3ยฑ2ยฑ1=24 ์ factorial์ ์ ์๋ฅผ ๋ค์ ํํํ๋ฉด if n = 0 โง1, n! = โจ โฉ n ร ( n โ 1)! if n > 0
base case: ์ฌ๊ท๊ฐ ์๋ ๊ฒฝ์ฐ general case
์ด์ ๊ฐ์ด ์์ ์ ์์ ๋ฒ์ ์ผ๋ก ์์ ์ ์ ์ํ๋ ์ ์๋ฅผ ์ฌ๊ท ์ ์(recursive definition)๋ผ ํ๋ค. ์ ์
์ฌ๊ท ํธ์ถ(recursive call)์ด๋ ํธ์ถํ๋ ๋ฉ์๋์ ํธ์ถ ๋ฐ๋ ๋ฉ์๋๊ฐ ๊ฐ์ ๋ฉ์๋ ํธ์ถ์ ๋งํ๋ค. ์ฌ๊ท ํธ์ถ์ ํฌ๊ฒ ์ง์ ์ฌ๊ท์ ๊ฐ์ ์ฌ๊ท๋ก ๋๋ ์ ์๋ค. ์ง์ ์ฌ๊ท๋ ์๊ธฐ ์์ ์ ๋ฐ๋ก ํธ์ถํ๋ ๋ฉ์๋๋ฅผ ๋งํ๋ฉฐ, ๊ฐ์ ์ฌ๊ท๋ ๋ ์ด์์ ๋ฉ์๋ ํธ์ถ์ด ์ต์ด์ ํธ์ถ ๋ฉ ์๋๋ก ๋๋์์ค๋ ๊ฒฝ์ฐ๋ฅผ ๋งํ๋ค. ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ์ค๋ช ํ ๋ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ์์
- 115 -
๋ ๊ณ์น์ ๊ตฌํ๋ ๋ฌธ์ ์ด๋ค. ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ํ๊ธฐ ์ํด์๋ ๋จผ์ ํด๊ฒฐํ๊ณ ์ ํ๋ ๋ฌธ์ ๋ฅผ ์ฌ๊ท ์ ์๋ก ํํํด์ผ ํ๋ค. ์ฌ๊ท ์ ์๋ ์์ ์ ์์ ๋ฒ์ (์ ๋ฌธ์ ์ ํํ๊ฐ ์ผ์นํด์ผ ํจ)์ผ๋ก ์์ ์ ์ ์ํ๋ ์ ์๋ฅผ ๋งํ๋ค. ์ด ๋ ์์ ์ ์์ ๋ฒ์ ์ผ๋ก ์ ์ํ๋ ๋ถ๋ถ๊ณผ ๊ทธ ๋ ์ง ์์ ๋ถ๋ถ์ผ๋ก ๋๋์ด ์ง๋ค. ์ ์๋ฅผ ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ๋ผ ํ๊ณ , ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ๋ฅผ ๊ธฐ์ ๊ฒฝ์ฐ๋ผ ํ๋ค. ์ฌ๊ท ์ ์์๋ ๋ฐ๋์ ๊ธฐ์ ๊ฒฝ์ฐ๊ฐ ์์ด์ผ ํ๋ฉฐ, ์ผ๋ฐ ๊ฒฝ์ฐ๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์ ์ฉํ๋ฉด ๊ฒฐ๊ตญ ๊ธฐ์ ๊ฒฝ์ฐ์ ๋๋ฌํด์ผ ํ๋ค.
์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ
factorial(4)
public static int factorial(int n){ if(n==0) return 1; else return (n * factorial(n-1)); }
4
recursive ๋ฐฉ๋ฒ ๋ณดํต ์ ํ๋ฌธ(if, switch)์ผ๋ก ๊ตฌํ ํจ์ ํธ์ถ์ด ๋ง์ด ์ด๋ฃจ์ด์ง๋ค.
3 n=4
24
2 n=3
6
public static int factorial(int n){ int val = 1; for(int i=2; i<=n; i++) val = val * i; return val; }
1 n=2
2
0 n=1
1
n=0 1
non-recursive ๋ฐฉ๋ฒ ๋ณดํต ๋ฐ๋ณต๋ฌธ(for, while)์ผ๋ก ๊ตฌํ
์ด๋ค ๋ณต์กํ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด์ผ ํ๋ ๊ฒฝ์ฐ ๋ณดํต ๋ฌธ์ ๋ฅผ ๋ณด๋ค ๊ฐ๋จํ ์์ ๋ฌธ์ ๋ก ๋ถํ ํ์ฌ ํด ๊ฒฐํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง๋ค. ์ด๋ฐ ํํ์ ๋ฌธ์ ํด๊ฒฐ๋ฒ์ ๋ถํ ์ ๋ณต๋ฒ(divide-and-conquer)์ด๋ผ ํ๋ค. ๋ฌธ์ ๋ฅผ ๋ถํ ํ์์ ๋ ์์ ๋ฌธ์ ๊ฐ ์ ๋ฌธ์ ์ ๋์ผํ ํํ์ด๋ฉด ์ฌ๊ท ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ ํด๊ฒฐ ํ ์ ์๋ค. ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ๋ณดํต ์ ํ๋ฌธ์ ์ฌ์ฉํ์ฌ ๊ตฌํ๋๋ฉฐ, ์กฐ๊ฑด์ ๋ฐ๋ผ ์ฌ๊ท ํธ์ถ ์ ํ๊ฑฐ๋ ๊ธฐ์ ๊ฒฝ์ฐ๋ฅผ ์คํํ๊ฒ ๋๋ค. ๋ณดํต ์ฌ๊ท ๋ฐฉ์์ผ๋ก ํ๋ก๊ทธ๋๋ฐ๋์ด ์๋ ๊ฒ์ ๋ฐ๋ณต ๋ฌธ์ ์ฌ์ฉํ์ฌ ํด๊ฒฐํ ์๋ ์๋ค. ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋น๊ตํ์์ ๋ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ ๋ฐฉ์์ด ํจ์จ์ฑ ์ธก๋ฉด์์๋ ๋ณดํต ์ฐ์ํ๋ค. ์ด๊ฒ์ ์ฌ๊ท ๋ฐฉ์์์๋ ํจ์ ํธ์ถ์ด ๋ฐ๋ณธ์ ์ผ๋ก ๋ง์ด ์ผ์ด๋๊ธฐ ๋๋ฌธ์ด๋ค. ํ์ง๋ง ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ์ฌ ์ฝ๊ฒ ํด๊ฒฐํ์ง ๋ชปํ๋ ๋ฌธ์ ๋ฅผ ์ฌ๊ท ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ๋งค์ฐ ํธ๋ฆฌํ๊ฒ ํด๊ฒฐํ ์๋ ์๋ค. ๋ณดํต ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์์๋ ๊ธฐ์ ๊ฒฝ์ฐ์ ๋๋ฌ ํ ๋๊น์ง ๊ณ์ ํจ์ ํธ์ถ๋ง ์ผ์ด๋๋ฉฐ, ๊ธฐ์ ๊ฒฝ์ฐ์์ ์ต์ด ํธ์ถ๊น์ง ๋๋์์ค๋ ๊ณผ์ ์์ ์ค์ ํ์ํ ๊ณ์ฐ์ด ์ํ๋๋ค.
- 116 -
๋ฌธ์ ์ ๋ํ ์ฌ๊ท์ ํด๊ฒฐ์ฑ ์ด๋ค ๋ฌธ์ ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ๊ณ ์ ํ ๋ ๊ณ ๋ คํด์ผ ํ๋ ๋ค ๊ฐ์ง ์ฌํญ ๋ฌธ์ ๋ฅผ ๊ฐ์ ์ข ๋ฅ์ ์์ ๋ฌธ์ ๋ก ์ฌ๊ท ์ ์๋ฅผ ํ ์ ์๋๊ฐ? ๊ฐ ์ฌ๊ทํธ์ถ ๋ ๋ฌธ์ ์ ํฌ๊ธฐ๋ฅผ ์ด๋ป๊ฒ ์ค์ด๋๊ฐ? base case ์ญํ ์ ํ๋ ๋ฌธ์ ์ ์ธ์คํด์ค๋ ๋ฌด์์ธ๊ฐ? ๊ฐ ์ฌ๊ทํธ์ถ์ด ๊ฒฐ๊ตญ์๋ base case์ ๋๋ฌํ ์ ์๋๊ฐ?
์ด๋ค ๋ฌธ์ ๋ฅผ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ๊ณ ์ ํ ๋์๋ ๋ค์ ๋ค ๊ฐ์ง ์ฌํญ์ ์ฐ์ ๊ณ ๋ คํด์ผ ํ๋ค. ์ฒซ์งธ, ์ฌ๊ท์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด์๋ ๋ฌธ์ ๋ฅผ ๊ฐ์ ์ข ๋ฅ์ ์์ ๋ฌธ์ ๋ก ์ฌ๊ท ์ ์๋ฅผ ํ ์ ์์ด์ผ ํ๋ค. ๋์งธ, ๊ฐ ์ฌ๊ท ํธ์ถํ ๋ ๋ฌธ์ ์ ํฌ๊ธฐ๊ฐ ์ด๋ป๊ฒ ์ถ์๋๋์ง ๊ฒํ ํด์ผ ํ๋ค. ์ ์งธ, ๊ธฐ์ ๊ฒฝ์ฐ๊ฐ ๋๋ ๋ฌธ์ ์ ์ธ์คํด์ค๋ฅผ ๋ช ํํ๊ฒ ์ ์ํด์ผ ํ๋ค. ๊ธฐ์ ๊ฒฝ์ฐ๋ ํ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์๋๋ผ ์ฌ๋ฌ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ๋ชจ๋ ๊ธฐ์ ์ญํ ์ ํ ์๋ ์๋ค. ๋ท์งธ, ๊ฐ ์ฌ๊ทํธ์ถ ์ด ๊ฒฐ๊ตญ์๋ ๊ธฐ์ ๊ฒฝ์ฐ์ ๋๋ฌํ๋์ง ์ดํด๋ณด์์ผ ํ๋ค. ์ด ๋ถ๋ถ์ ๋ค์ ์ฌ๋ผ์ด๋์ ์๋ ๊ฒ ์ฆ๊ณผ๋ ๊ด๋ จ๋์ด ์๋ค.
์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ๊ฒ์ฆ ์ธ ๊ฐ์ง ์ง๋ฌธ basebase-case question: question ๋ฉ์๋๋ฅผ ์ข ๋ฃํ ์ ์๋ ๋น์ฌ๊ท์ ์ธ ๋ฐฉ๋ฒ์ด ์๋? base-case๊ฐ ์ ๋๋ก ๊ตฌํ๋์ด ์๋? n=0์ผ ๋๊ฐ base-case์ด๋ฉฐ, ์ด ๋ 1์ ๋ฐํํ๋ค. smallersmaller-case question: question ์ฌ๊ท ํธ์ถ์ด ์ ๋ฌธ์ ์ ์์ ๋ฒ์ ์ ํธ์ถํ๊ณ ์๋๊ฐ? ๊ฒฐ๊ตญ์๋ base-case๊น์ง ๋๋ฌํ๋? ร ์๋๋ฉด ๋ฌดํ ์ฌ๊ท ์ฌ๊ทํธ์ถ์์ ์ธ์๋ n-1์ ์ฌ์ฉํ๊ณ ์๋ค. ์ผ๋ จ์ ์ฌ๊ท ํธ์ถ์ ์ธ์์ ๊ฐ์ ํ๋์ฉ ๊ฐ์ํ๋ฏ๋ก ๊ฒฐ๊ตญ์๋ n์ด 0์ด๋๋ค. generalgeneral-case question: question ์ ์ฒด์ ์ผ๋ก ์ ๋๋ก ๊ตฌํ๋์ด ์๋? factorial(n-1)์ด (n-1)!์ ๋ฐํํด์ฃผ๋ฉด ์ ์ฒด์ ์ผ๋ก n!์ ๋ฐํํ๋ค.
์ฌ๊ท์ ์ผ๋ก ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํ์์ ๋ ์ ๋๋ก ์์ฑ๋์๋์ง ๊ฒ์ฆํ๊ธฐ ์ํด์๋ ๋ค์ ์ธ ๊ฐ ์ง ์ฌํญ์ ํ์ธํด์ผ ํ๋ค. ์ฒซ์งธ, ๊ธฐ์ ๊ฒฝ์ฐ๋ฅผ ์ ๋๋ก ๊ตฌํํ๊ณ ์๋์ง ํ์ธํด์ผ ํ๋ค. ๊ธฐ์ ๊ฒฝ์ฐ๊ฐ ์ ๋๋ก ๊ตฌํ๋์ด ์์ง ์์ผ๋ฉด ๋ฐ๋ชฉ๋ฌธ์ด ๋ฌดํ ๋ฃจํ์ ๋น ์ง ์ ์๋ฏ์ด ๋ฌดํ์ ์ผ๋ก ์ฌ ๊ท ํธ์ถ์ด ์ด๋ฃจ์ด์ง ์ ์๋ค. ๋์งธ, ๊ฐ ์ฌ๊ทํธ์ถ์ด ์ ๋ฌธ์ ์ ์์ ๋ฒ์ ์ ํธ์ถํ๊ณ ์๋์ง ํ์ธํด์ผ ํ๋ฉฐ, ์ด๋ฅผ ํตํด ๊ฒฐ๊ตญ์๋ ๊ธฐ์ ๊ฒฝ์ฐ์ ๋๋ฌํ๋์ง ํ์ธํด์ผ ํ๋ค. ์ ์งธ, ์ ์ฒด์ ์ผ ๋ก ์ํ๋ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋์ง ๊ฒ์ฆํด์ผ ํ๋ค.
- 117 -
9.3. ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ์
search์ ์ฌ๊ท ๋ฒ์ UnsortedList์ search base case (1) element[startPosition]์ ์ฐพ๊ณ ์ ํ๋ ๊ฒ์ด ์์ผ๋ฉด true๋ฅผ ๋ฐํํ๋ค. (2) startPosition==size-1์ด๊ณ element[startPosition]์ ์ฐพ๊ณ ์ ํ๋ ๊ฒ์ด ์์ผ๋ฉด false๋ฅผ ๋ฐํํ๋ค. general case: ๋จ์ ๋ถ๋ถ(startPosition์์ ๋๊น์ง)์ ๊ฒ์ํ๋ค. โฆ
โฆ
โฆ
๊ฒ์ํด์ผ ํ ๋ถ๋ถ
์ด๋ฏธ ๊ฒ์ํ ๋ถ๋ถ
startPosition
search์ ์ฌ๊ท ๋ฒ์ โ ๊ณ์ public boolean search(Object item) throws ListUnderflowException { if(isEmpty()) return new ListUnderflowException(โโฆโ); return search(item, 0); } private boolean search(Object item, int startPosition){ if(item.equals(element[startPosition])) return true; else if(startPosition==(size-1)) return false; ์ฌ์ฉ์๋ ๊ธฐ์กด์ฒ๋ผ search(Object item) else return search(item, startPosition+1); ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค. } public boolean search(Object item) throws ListUnderflowException { if(isEmpty()) return new ListUnderflowException(โโฆโ); for(int i=0; i<size; i++) if(item.equals(element[i])) return true; return false; } โฆ
โฆ
โฆ
1 2 3
๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ ๊ตฌํ์์ ๊ฒ์ ์ฐ์ฐ์ ์ฌ๊ท์ ์ผ๋ก ์์ฑํ ์ ์๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ๋ ๊ฐ ์ฌ๊ท ํธ์ถ์์ ๋ฌธ์ ์ ํฌ๊ธฐ๊ฐ ํ๋๋ง ์ถ์๋๋ฏ๋ก ์ฐพ๊ณ ์ ํ๋ ๊ฒ์ด ๋ฐฐ์ด์ ์์ผ ๋ฉด ์ด n๋ฒ ์ฌ๊ทํธ์ถ์ด ์ผ์ด๋๋ค. ๋ฐ๋ผ์ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ ์ ์์ง๋ง ์ด ์๋ ์ฌ๊ท๋ณด๋ค๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ํด๊ฒฐํ๋ ๊ฒ์ด ๋ณด๋ค ํจ๊ณผ์ ์ด๋ค.
- 118 -
์กฐํฉ(Combination) ์์ด(permutation): n๊ฐ ์ค r๊ฐ๋ฅผ ๋น๋ณต์์ถ์ถํ์ฌ ์ด๋ค ์์๋ก ์์ด ๋์ดํ๋ ๊ฒฝ์ฐ์ ์ n
Pr = n ร ( n โ 1) ร " ร ( n โ r + 1)
์กฐํฉ(combination): ์์์ ์๊ด์์ด n๊ฐ์ ์์์์ r๊ฐ๋ฅผ ๋น๋ณต์์ถ ์กฐํฉ n! ์ถํ๋ ๊ฒฝ์ฐ์ ์ n Pr n
์กฐํฉ์ ์ฌ๊ท์ ์ ์
n
Cr =
r!
=
r !( n โ r ) !
โงn โช n C r = โจ1 โช C + C โฉ n โ1 r โ1 n โ1 r
if r = 1 if n = r if n > r > 1
( n โ 1)! ( n โ 1)! + ( r โ 1)!( n โ r ) ! r ! ( n โ r โ 1) ! โ ( n โ 1)! 1 โ ( n โ 1)! n โ n! โ1 = + = = ( r โ 1)!( n โ r โ 1) ! โโ r n โ r โโ ( r โ 1)!( n โ r โ 1) ! โโ r ( n โ r ) โโ r ! ( n โ r ) !
Cr =
n โ1
C r โ 1 + n โ1 C r =
์กฐํฉ โ ๊ณ์ public static int combination(int n, int r){ if(r==1) return n; else if(n==r) return 1; else return (combination(n-1,r-1)+combination(n-1,r)); }
C(2,1) 2
combination(4,3)
C(3,2) C(2,2) 3
1
C(3,3) 1
ํ๋ฅ ๊ณผ ํต๊ณ์์ ๋ง์ด ์ฌ์ฉ๋๋ ์์ด๊ณผ ์กฐํฉ์ ๊ณ์ฐ๋ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ ์ ์๋ค. ํ์ง๋ง ์กฐํฉ์ ๊ฒฝ์ฐ๋ ๋ค์ ๋ค์ ์ธ๊ธํ์ง๋ง ๊ฐ์ ๊ฐ์ ์ฌ๋ฌ ๋ฒ ๋ฐ๋ณตํด์ ๊ณ์ฐํ๊ธฐ ๋๋ฌธ์ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๋ ๊ฒ์ ๋งค์ฐ ๋นํจ์จ์ ์ด๋ค. ์กฐํฉ์ ์ด์ ์ ์ดํด๋ณธ ๊ณ์น๊ณผ ๋ฌ๋ฆฌ ๋ ๊ฐ์ง ๊ธฐ์ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ์ด์ฒ๋ผ ๋์ผํ ๊ณ์ฐ์ ๋ฐ๋ณต์ ์ผ๋ก ํ๋ ์ฌ๊ท์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ๊ฒ์ ์ฐ์ฐ์ ์ฌ๊ท ๋ฒ์ ์ฒ๋ผ ๋ฐ๋ณต๋ฌธ์์ ๋ฐ๋ณตํ๋ ํ์๋งํผ ์ฌ๊ท ํธ์ถ์ด ์ผ์ด๋๋ ๊ฒฝ์ฐ๋ ์ฌ๊ท ๋ฒ ์ ์ผ๋ก ๊ตฌํํ๋ ๊ฒ์ ๋นํจ์จ์ ์ด๋ค.
- 119 -
ํ๋ ธ์ด ํ์
begin peg
aux peg
end peg
peg 1
peg 2
peg 3
์ ์ฝ (1) ํ๋ฒ์ ํ๋์ ๋ง๋ง ์์ง์ผ ์ ์๋ค. (2) ์์ ๋ง ์์ ํฐ ๋ง์ ์ฌ๋ ค ๋์ ์ ์๋ค. ํํธ
ํ๋ ธ์ด ํ์๋ ์ฌ๊ท ํ๋ก๊ทธ๋๋ฐ์ ์ค๋ช ํ ๋ ๋ง์ด ์๊ฐ๋๋ ๋ฌธ์ ์ด๋ค. ํ๋ ธ์ด ํ์๋ ์ธ ๊ฐ ์ ๋ง๋๊ธฐ์ n๊ฐ์ ๋ง์ผ๋ก ๊ตฌ์ฑ๋์ด ์๋ค. ํฌ๊ธฐ๊ฐ ํฐ ์์๋ถํฐ ์์ฌ ์๋ ๋ง๋ค์ ๋ณด์กฐ ๋ง๋ ๊ธฐ๋ฅผ ์ด์ฉํ์ฌ ๋ชจ๋ ๋ชฉํ ๋ง๋๊ธฐ๋ก ์ด๋ํ๋ ๋ฌธ์ ์ด๋ค. ์ด ๋ ํ๋ฒ์ ํ๋์ ๋ง๋ง ์์ง์ผ ์ ์์ผ๋ฉฐ, ์์ ๋ง ์์ ํฐ ๋ง์ ์ฌ๋ ค๋์ ์ ์๋ค๋ ์ ์ฝ์ด ์๋ค.
ํ๋ ธ์ด ํ์ โ ๊ณ์ aux peg
begin peg
end peg
begin peg
aux peg
end peg
ํ๋ ธ์ด ํ์ ๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ์ด ํด๊ฒฐํ ์ ์๋ค. ์ฒซ์งธ, n-1๊ฐ์ ๋ง์ ๋ชฉํ ๋ง๋๊ธฐ๋ฅผ ๋ณด์กฐ ๋ง๋๊ธฐ๋ก ํ์ฉํ์ฌ ๋ณด์กฐ ๋ง๋๊ธฐ๋ก ์ด๋ํ๋ค. ๋์งธ, ๊ฐ์ฅ ํฐ ๋ง์ ๋ชฉํ ๋ง๋๊ธฐ๋ก ์ฎ๊ธด๋ค. ์ ์งธ, ๋ณด์กฐ๋ง๋๊ธฐ์ ์๋ n-1๊ฐ์ ๋ง์ ์์ ๋ง๋๊ธฐ๋ฅผ ๋ณด์กฐ ๋ง๋๊ธฐ๋ก ์ด์ฉํ์ฌ ๋ชฉํ ๋ง๋๊ธฐ๋ก ์ฎ๊ธด๋ค.
- 120 -
ํ๋ ธ์ด ํ์ โ ๊ณ์ ํ๋ ธ์ด ํ์ ์๊ณ ๋ฆฌ์ฆ ๋จ๊ณ 1. n-1๊ฐ์ ๋ง์ peg 1(์์ peg)์์ peg 2(๋ณด์กฐ peg)๋ก ์ฎ๊ฒจ๋ผ. ๋จ๊ณ 2. n๋ฒ์งธ ๋ง์ peg 3(๋ชฉ์ peg)์ผ๋ก ์ฎ๊ฒจ๋ผ. ๋จ๊ณ 3. peg 2(๋ณด์กฐ peg)์ ์๋ n-1๊ฐ์ ๋ง์ peg 3(๋ชฉ์ peg) ์ผ๋ก ์ฎ๊ฒจ๋ผ. public static void doTowers(int numRings, int begPeg, int auxPeg, int endPeg){ if(numRings>0){ doTower(numRings-1, begPeg, endPeg, auxPeg); system.out.println(โMove ring from peg โ+ begPeg + โ to peg โ + endPeg); doTower(numRings-1, auxPeg, begPeg, endPeg); } }
์ ํ๋ก๊ทธ๋จ์ ์ํํ๋ฉด n๊ฐ์ ๋ง์ผ๋ก ๊ตฌ์ฑ๋ ํ๋ ธ์ด ํ์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ์ถ๋ ฅํ ์ฌ ์ค๋ค.
์ด์ง ๊ฒ์
public boolean search(Object item){ if(isEmpty()) return new ListUnderflowException(โโฆโ); Comparable x = (Comparable)item; return search(x, 0, size-1); } private boolean search(Comparable item, int first, int last){ if(first>last) return false; else{ int mid = (first+last)/2; int comp = item.compareTo(element[mid]); if(comp==0) return true; else if(comp<0) return search(item, first, mid-1); else return search(item, mid+1,last); } }
Base case (1) first>last ร false๋ฅผ ๋ฐํ (2) item.compareTo(element[mid])==0 ร true๋ฅผ ๋ฐํ General case (1) item.compareTo(element[mid])<0 ร search(first,mid-1) (2) item.compareTo(element[mid])>0 ร search(mid+1,last)
์ด ์ ์ฒ์์ ์ ํ ๊ฒ์์ ์ฌ๊ท ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ ์๋ฅผ ์ดํด๋ณธ ๋ฐ ์๋ค. ๊ทธ ๋ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ์ ํ ๊ฒ์์ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ ์ ์์ผ๋ ์ฑ๋ฅ ์ธก๋ฉด์์ ๋งค์ฐ ๋นํจ์จ์ ์ด์๋ค. ์ข ๋ ์ ํํ๊ฒ ํํํ๋ฉด ์ต์ ์ ๊ฒฝ์ฐ n๋ฒ์ ์ฌ๊ท ํธ์ถ์ด ํ์ํ์๋ค. ์ด์ง ๊ฒ์์ ์ฌ๊ท ๋ฐฉ๋ฒ์ ๊ตฌํํ๋ฉด ์ต์ ์ ๊ฒฝ์ฐ log2n๋ฒ์ ์ฌ๊ท ํธ์ถ์ด ํ์ํ๋ฏ๋ก ์ด์ ๊ฐ์ ๊ฒฝ์ฐ์๋ ์ฌ๊ท ํธ์ถ์ ๋ฐ๋ฅธ ์ค๋ฒํค๋(ํจ์ ํธ์ถ ๋น์ฉ)๊ฐ ๋ฌธ์ ๊ฐ ๋์ง ์๋๋ค.
- 121 -
์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฌ๊ท ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ญ์์ผ๋ก ์ถ๋ ฅ list
A
B
2
C
D
E
1 ์ด๊ฒ์ ์ถ๋ ฅ: E,D,C,B, A
์ด ๋ถ๋ถ์ ์ญ์์ผ๋ก ์ถ๋ ฅ: E,D,C,B
public void PrintReverse() { revPrint(list); } private void revPrint(ListNode node){ if(node != null){ revPrint(node.next); System.out.println(โ โ + node.info); } }
์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ ฌ ๋ฆฌ์คํธ์ ์ ์ฅ๋์ด ์๋ ์์๋ค์ ์ญ์์ผ๋ก ์ถ๋ ฅํ๊ณ ์ถ๋ค. ์ด ๋ฌธ์ ๋ ์ฌ๊ท ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ง ์์ ๊ฒฝ์ฐ์๋ ์คํ์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ์๊ฐํด ๋ณผ ์ ์๋ค. ์คํ ์ LIFO ๊ตฌ์กฐ์ด๋ฏ๋ก ์ด ํน์ฑ์ ์ฌ์ฉํ๋ฉด ์ฝ๊ฒ ์ญ์์ผ๋ก ์ถ๋ ฅํ๋ ๋ฉ์๋๋ฅผ ์์ฑํ ์ ์๋ค. ๋จผ์ ๋ฆฌ์คํธ์ ๊ฐ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ฉด์ ๋ฐฉ๋ฌธํ๋ ์์๋๋ก ์คํ์ ์์๋ค์ pushํ๋ค. ๊ทธ ๋ค ์์ ๋ฆฌ์คํธ์ ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ์์ผ๋ฉด ์คํ์์ ์ฐจ๋ก๋๋ก popํ์ฌ ์ถ๋ ฅํ๋ฉด ์ญ์์ผ๋ก ์ถ๋ ฅ๋๋ค. ์ฌ๊ท์ ์ผ๋ก ์ด ๋ฌธ์ ๋ฅผ ๊ณ ๋ คํ๋ฉด ๋ฌธ์ ๋ฅผ ๋ค์๊ณผ ๊ฐ์ด ๋ค์ ์์ ํ ์ ์๋ค. ์ฒซ ๋ ธ๋๋ฅผ ์ ์ธํ ๋๋จธ์ง ๋ ธ๋๋ค์ ์ญ์์ผ๋ก ์ถ๋ ฅํ๋ค. ์ฒซ ๋ ธ๋๋ฅผ ์ถ๋ ฅํ๋ค. ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์ ์ ๋ฌธ์ ์ ์์ ๋ฒ์ ์ด๋ฏ๋ก ์ ์์ ์ ์ด์ฉํ์ฌ ์ฝ๊ฒ ์ญ์์ผ๋ก ์ถ๋ ฅํ๋ ์ฌ ๊ท ๋ฐฉ์์ ํ๋ก๊ทธ๋จ์ ์์ฑํ ์ ์๋ค. ์ด์ฒ๋ผ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๊ธฐ๋ ์ฌ์ฐ๋ ๋ฐ๋ณต ๋ฐฉ์์ผ ๋ก ๊ตฌํํ๋ ๊ฒ์ด ์ด๋ ค์ด ๋ฌธ์ ๋ ์๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฌ๊ท โ ๊ณ์ private ListNode insert(ListNode subList, Comparable item){ if(subList==null || item.compareTo(subList.info)<0){ ListNode newNode = new ListNode(); newNode.info = item; newNode.next = subList; ์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ฝ์ return NewNode; } Base Case: else{ (1) ๋ถ๋ถ ๋ฆฌ์คํธ๊ฐ ๋น์ด์์ผ๋ฉด subList.next = insert(subList.next, item); ๋น ๋ฆฌ์คํธ์ ์ฝ์ return subList; (2) ์ฝ์ ํ๊ณ ์ ํ๋ ์์๊ฐ } ๋ถ๋ถ ๋ฆฌ์คํธ์ ์ฒซ ์์๋ณด๋ค } ์์ผ๋ฉด ๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ public void insert(Object item){ General Case: if(item==null) insert(sublist.next, item) return new NullPointerException(โโฆโ); Comparable x = (Comparable)item; list = insert(list, x); }
- 122 -
์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ฌ๊ท โ ๊ณ์ list
6
11
2
20
11
1
insert(list,15)
15
20
15
20
15
20
1 6
6
11
20 11
insert(subList.next,15) 2 11
list
20
6
insert(subList.next,15) 3 20
15
11
20
์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ฝ์ ๋ฌธ์ ๋ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ ์ ์๋ค. ํ์ง๋ง ์ด ์๋ ์ ํ ๊ฒ์๊ณผ ๋ง ์ฐฌ๊ฐ์ง๋ก ์ต์ ์ ๊ฒฝ์ฐ n๋ฒ์ ์ฌ๊ท ํธ์ถ์ด ํ์ํ๋ฏ๋ก ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๊ธฐ์ ์ ํฉํ ์๋ ์๋๋ค. ํ์ง๋ง ์ฝ์ ๋ฌธ์ ๋ฅผ ์ด์ฒ๋ผ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๋ฉด ๋ชจ๋ ๊ฒฝ์ฐ๋ฅผ ํ ๊ฐ์ง ๊ฒฝ์ฐ(๋ฆฌ์คํธ ๋งจ ์์ ์ฝ์ )๋ก ๋ฐ๊พธ์ด ํ๋ก๊ทธ๋๋ฐํ ์ ์๋ค. ์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ฝ ์ ์ ํฌ๊ฒ ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๊ณ ๋ คํ์ฌ ํ๋ก๊ทธ๋๋ฐํด์ผ ํ๋๋ฐ, ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๋ฉด ํญ์ ๋งจ ์์ ์ฝ์ ํ๋ ๊ฒฝ์ฐ๋ก ๋ฐ๊พธ์ด ํ๋ก๊ทธ๋๋ฐํ ์ ์๋ค.
9.4. ์ฌ๊ท์ ๋์ ์๋ฆฌ
์ฌ๊ท์ ๋์ ์๋ฆฌ public static int factorial(int n){ if(n==2) return 2; else return (n * factorial(n-1)); } factorial(3)/ call factorial(2)
public static void main(String[] args){ int result = factorial(4); System.out.println(โ4! = โ+result); }
parameter
2
Return Address 1000 return 2
factorial(4)/ call factorial(3)
Return Value
?
parameter
3
2
Return Address 1000 return 3*2 call
return Return Value main/ call factorial(4)
runtime stack
?
parameter
4
Return Address
100
Return Value
?
6
return 4*6 24
์๋ฐ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ C/C++ ์ธ์ด์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ด๋ค ๋ฉ์๋ ๋๋ ํจ์๊ฐ ์คํ๋๋ฉด ๊ทธ ํจ์๋ฅผ ์ํ ์์ ๊ณต๊ฐ์ด ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋๋ค. ์ด ๊ณต๊ฐ์ ์คํ ํ๋ ์(stack frame) ๋๋
activation record๋ผ ํ๋ค. ์ด ๊ณต๊ฐ์๋ ๋ณต๊ท ์ฃผ์(return address), ๋ฐํ๋ ๊ฐ, ๋งค๊ฐ ๋ณ์, ์ง ์ญ ๋ณ์ ๋ฑ์ด ์ ์ฅ๋๋ค. ์ด ๊ณต๊ฐ์ ์คํ ํ๋ ์์ด๋ผ๊ณ ๋ถ๋ฆฌ๋ ์ด์ ๋ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋ฉ์๋๊ฐ ์ข ๋ฃ๋์ง ์๊ณ ๋ ๋ค๋ฅธ ๋ฉ์๋๊ฐ ํธ์ถ๋ ๋ ์ ๋ฉ์๋์ ์์ ๊ณต๊ฐ์ด ๊ธฐ์กด ์์ ๊ณต๊ฐ ์์
- 123 -
์์ฌ์ง๋ ํํ๊ฐ ๋๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ์์ ์ฒ๋ผ ์ฌ๊ท ๋ฐฉ์์ ๊ณ์น ๋ฉ์๋๊ฐ ํธ์ถ๋๋ฉด ๊ณ์น ๋ฉ ์๋๋ฅผ ์ํ ์์ ๊ณต๊ฐ์ด ํ ๋น๋๋ค. ์ด ๋ ์ด ๋ฉ์๋์์ ๋ค์ ์ฌ๊ท ํธ์ถ์ด ์ด๋ฃจ์ด์ง๋ฉด ๊ธฐ ์กด ์์ ๊ณต๊ฐ์ ์คํ์ push๋๊ณ ๋ ๋ค๋ฅธ ์์ ๊ณต๊ฐ์ด ํ ๋น๋์ด ์ฌ์ฉ๋๋ค. ์ด๋ ๊ฒ ํ์ฌ ๊ธฐ ์ ๊ฒฝ์ฐ์ ๋๋ฌ๋์ด ํ์ฌ ๋ฉ์๋๊ฐ ์ข ๋ฃ๋๋ฉด ์คํ์์ ์์ ๊ณต๊ฐ์ ์ฐจ๋ก๋๋ก ํ๋์ฉ ๊ฐ์ง๊ณ ์ค๋ฉด์ ์ฒ๋ฆฌ๋๋ค.
9.5. ๊ธฐํ ์ด๋ค ๋ฌธ์ ๊ฐ ์ฌ๊ท์ ์ผ๋ก ์ ์๋๋ฉด ๋ณดํต ์ฌ๊ท ๋ฐฉ์์ผ๋ก ๊ตฌํํ์ฌ ์ฝ๊ฒ ํด๊ฒฐํ ์ ์๋ค. ํ์ง ๋ง ์ด๋ ๊ฒ ๊ตฌํ๋ ๊ฒฐ๊ณผ๊ฐ ํจ์จ์ฑ ์ธก๋ฉด์์๋ ๋ง์กฑ์ค๋ฝ์ง ์์ ์ ์๋ค. ์ด ๋์๋ ์ฌ๊ท๋ฅผ ์ ๊ฑฐํ์ฌ ํจ์จ์ฑ์ ์ ๊ณ ํ ์ ์๋ค. ๋ํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๊ฐ ์ฌ๊ท ํธ์ถ์ ์ง์ํ์ง ์์ผ๋ฉด ์ด ๋ฐฉ๋ฒ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ์ข์ ์๋จ์ด ๋ ์ ์๋ค.
์ฌ๊ท์ ์ ๊ฑฐ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ๊ตฌํ๋ ๋ฉ์๋๋ฅผ ์ฌ๊ท ํธ์ถ์ ์ฌ์ฉํ์ง ์๋๋ก ๋ฐ๊พธ๋ ๋ฐฉ๋ฒ ๋ฐฉ๋ฒ 1. ๋ฐ๋ณต๋ฌธ ์ฌ์ฉ ๋ชจ๋ ๊ฒฝ์ฐ์ ๋ฐ๋ณต๋ฌธ์ ๋ฐ๊ฟ ์ ์๋ ๊ฒ์ ์๋๋ค. ๊ผฌ๋ฆฌ ์ฌ๊ท(tail recursion)์ด๋ฉด ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋ค. ์ฌ๊ท ๋ฐฉ๋ฒ 2. ์คํ ์ฌ์ฉ ๋ฆฌ์คํธ์ ์ญ์ ์ถ๋ ฅ: ๋ฆฌ์คํธ์ ๊ฐ ๋ ธ๋๋ฅผ ์ฐจ๋ก๋๋ก ๋ฐฉ๋ฌธํ๋ฉด์ ๋ ธ๋์ ์์ ๊ฐ์ ์คํ์ pushํ ๋ค์์ ์คํ์์ ํ๋์ฉ pop ํ์ฌ ์ถ๋ ฅํ๋ฉด ์ญ์์ผ๋ก ์ถ๋ ฅํ ์ ์๋ค.
์ฌ๊ท ๋ฐฉ์์ผ๋ก ์์ฑ๋ ๋ฉ์๋๋ฅผ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ง ์๋๋ก ๋ฐ๊พธ๋ ๋ฐฉ๋ฒ์ ํฌ๊ฒ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ ์ด ์๋ค. ์ฒซ์งธ, ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋๋ก ๋ฐ๊พธ๋ ๊ฒ์ด๋ค. ๋์งธ, ์คํ์ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ์ ์๋ ๊ผฌ๋ฆฌ ์ฌ๊ท ํํ๊ฐ ์๋๋ฉด ์ฝ๊ฒ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ฐ๊ฟ ์ ์๋ค๋ ๋ฌธ์ ๊ฐ ์๊ณ , ํ์๋ ์คํ์ ์ง ์ ์ ์ผ๋ก ๊ตฌํํด์ผ ํ๊ธฐ ๋๋ฌธ์ ํจ์จ์ฑ์ด ํฌ๊ฒ ์ ๊ณ ๋์ง ์์ ์๋ ์๋ค.
- 124 -
์ฌ๊ท ร ๋ฐ๋ณต ๊ผฌ๋ฆฌ ์ฌ๊ท: ๋ฉ์๋ ๋ด์ ๋ชจ๋ ์ฌ๊ท ํธ์ถ์ด ๋ฉ์๋์ ๋ง์ง๋ง ๋ฌธ์ฅ์ธ ๊ฒฝ์ฐ base case๊ฐ ๋๋ฉด ๋ฐ๋ณต์ด ์ข ๋ฃ๋๋๋ก ๋ฐ๋ณต๋ฌธ์ ๊ตฌ์ฑํ์ฌ ์ฝ๊ฒ ์ฌ๊ท๋ฅผ ์ ๊ฑฐํ ์ ์์ ์ด ๋ ๋ฃจํ ๋ณ์๋ ์ฌ๊ท ํธ์ถ์์ ๊ฐ์ด ๋ณํ๋ ์ธ์ ๊ผฌ๋ฆฌ ์ฌ๊ท๊ฐ ์๋๋ฉด ์ฝ๊ฒ ๋ฐ๊ฟ ์ ์๋ค. boolean search(Comparable item){ int loc = 0; boolean found = false; while(loc<size && !found){ if(item.compareTo(element[loc])==0) found = true; else loc++; } return found; }
boolean search(Comparable item, int start){ if(item.compareTo(element[start])==0) return true; else if(start==size-1) return false; else return search(item, start+1); }
์ฌ๊ท ๋ฐฉ์์ผ๋ก ์์ฑ๋ ๋ชจ๋ ๋ฉ์๋๋ฅผ ๋ฐ๋ณต๋ฌธ์ผ๋ก ์ฌ์ฉํ๋๋ก ๋ฐ๊ฟ ์ ์๋ค. ์ฌ๊ท ๋ฐฉ์์ผ๋ก ์์ฑ๋ ๋ฉ์๋ ์ค์ ์ฌ๊ท ํธ์ถ์ด ๋ชจ๋ ๋ฉ์๋์ ๋ง์ง๋ง ๋ฌธ์ฅ์ด๋ฉด ์ด๋ฐ ์ฌ๊ท๋ฅผ ๊ผฌ๋ฆฌ ์ฌ๊ท
(tail recursion)๋ผ ํ๋ค. ๋ฉ์๋์ ๋ง์ง๋ง ๋ฌธ์ฅ์ด๋ผ๋ ๊ฒ์ ๋ฌผ๋ฆฌ์ ์ผ๋ก ๊ทธ ๋ฉ์๋์ ๋ง์ง๋ง ๋ฌธ์ฅ์ด๋ผ๋ ๊ฒ์ด ์๋๋ผ, ๊ทธ ๋ฌธ์ฅ ์ดํ์ ๋ ์ด์ ์ถ๊ฐ๋ก ์ํํด์ผ ํ๋ ๋ฌธ์ฅ์ด ์๋ ๊ฒฝ์ฐ ๋ฅผ ๋งํ๋ค. ๊ผฌ๋ฆฌ ์ฌ๊ท์ธ ๊ฒฝ์ฐ์๋ ๊ธฐ์ ๊ฒฝ์ฐ์ ๋ฐ๋ณต์ด ์ข ๋ฃ๋๋๋ก ๋ฐ๋ณต๋ฌธ์ ๊ตฌ์ฑํ์ฌ ์ฝ๊ฒ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ๋ ๋ฒ์ ์ผ๋ก ๋ฐ๊ฟ ์ ์๋ค. ์ด ๋ ์ฌ๊ท ํธ์ถ์์ ๊ฐ์ด ๋ณํ๋ ์ธ์๋ฅผ ๋ฐ๋ณต ๋ฌธ์ ์ ์ด ๋ณ์๋ก ์ฌ์ฉํ๋ค.
์ฌ๊ท์ ์ฌ์ฉ ์ฌ๋ถ ๋ ๊ฐ์ง ์ธก๋ฉด: ๋ช ํ์ฑ, ํจ์จ์ฑ ๋ช ํ์ฑ: ์ฌ๊ท๊ฐ ๋ณดํต ์๊ณ ๋ฆฌ์ฆ์ ์ดํดํ๊ธฐ๊ฐ ๋ ์ฝ๋ค. ์8.2) ์ญ์์ผ๋ก ์ ๋ ฌ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์ถ๋ ฅ ํจ์จ์ฑ: ์ฌ๊ท๊ฐ ๋น์ฐํ ๊ณต๊ฐ๊ณผ ์๊ฐ ์ธก๋ฉด์์ ๋ชจ๋ ๋์๋ค. ์ ๋์ ์ธ ๊ฒ์ ์๋: ๋ฌธ์ , ์ปดํจํฐ, ์ปดํ์ผ๋ฌ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๋ค. ์8.3) factorial(n): n+1๊ฐ์ stack frame์ด ํ์ ร O(n) ๋ฌธ์ ๊ฐ ๋ณธ์ง์ ์ผ๋ก ์ฌ๊ท์ ๋ง์ง ์์ ์ ์๋ค. ร ์กฐํฉ: ๊ฐ์ ๊ณ์ฐ์ด ๋ฌด์ํ ๋ฐ๋ณต ร O(2N) C(5,3) C(4,3)
C(4,2) C(3,1)
C(3,2) C(2,1)
C(3,2)
C(2,2)
C(2,1)
C(3,3)
C(2,2)
์ด๋ค ๋ฌธ์ ๊ฐ ์ฃผ์ด์ก์ ๋ ์ด ๋ฌธ์ ๋ฅผ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ ๊ฒ์ธ์ง ์๋๋ฉด ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ง ์์ ๊ฒ์ธ์ง ๊ฒฐ์ ํ๊ธฐ ์ํด์๋ ๋ช ํ์ฑ๊ณผ ํจ์จ์ฑ ๋ ๊ฐ์ง ์ธก๋ฉด์ ๊ณ ๋ คํด์ผ ํ๋ค. ์์ ์ธ๊ธ ํ ๋ฐ์ ๊ฐ์ด ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ง ์๋ ๊ฒ์ด ์ฑ๋ฅ๋ฉด์ ์ ์ข๋ค. ํ์ง๋ง ์ด๊ฒ์ด ์ ๋์ ์ธ ๊ฒ์ ์๋๋ค. ์ด๋ค ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ์ฌ๊ท๋ฅผ ํจ๊ณผ์ ์ผ๋ก ์ฒ๋ฆฌํ๋๋ก ์ค๊ณ๋ ์ธ์ด๋ ์๋ค. ํ์ง๋ง ์ฌ๊ท ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ์์ ๋ ์กฐํฉ๊ณผ ๊ฐ์ด ๊ฐ์ ๊ณ์ฐ ์ ๋ฌด์ํ ๋ฐ๋ณต๋๋ ๊ฒฝ์ฐ๋ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ํด๊ฒฐํ ์ ์์ง๋ง ์ฌ๊ท์ ๋ง์ง ์๋ ๋ฌธ์ ์ด๋ค.
- 125 -
๋ช ํ์ฑ ์ธก๋ฉด์์๋ ํ๋ก๊ทธ๋๋จธ๋ง๋ค ๋ค๋ฅผ ์ ์์ง๋ง ๋ณดํต ์ฌ๊ท์ ์ผ๋ก ์์ฑ๋ ๋ฉ์๋๊ฐ ๋ณด๋ค ๋จ์ํ๊ณ ์ดํดํ๊ธฐ ์ฝ๋ค. ํนํ ํ๋ก๊ทธ๋จ ๋ฌธ์ฅ ์ ์ธก๋ฉด์์๋ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ๊ตฌํํ์์ ๊ฒฝ ์ฐ๊ฐ ๋๋ถ๋ถ ์ ๋ค. ๋ฐ๋ผ์ ์ด๋ค ๋ฌธ์ ๊ฐ ์ฃผ์ด์ง๋ฉด ์ฐ์ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐ ๊ฐ๋ฅํ์ง ์ดํด๋ณธ๋ค. ํด๊ฒฐํ ์ ์๋ ๊ฒฝ์ฐ์๋ ์ฌ๊ท์ ์ผ๋ก ํด๊ฒฐํ์ฌ๋ ์ฑ๋ฅ์ ํฐ ์ํฅ์ด ์๋์ง ์ดํด๋ณธ๋ค. ๋ง์ฝ ์ฌ๊ท์ ์ผ๋ก ๊ตฌํํ๋ ๊ฒ์ด ์ฑ๋ฅ์ ๋์ ์ํฅ์ ์ฃผ๋ฉด ์์ ์ดํด๋ณธ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ์ฌ๊ท๋ฅผ ์ฌ์ฉํ์ง ์๋ ๋ฒ์ ์ผ๋ก ๋ฐ๊พธ์ด ์ฌ์ฉํ๋ค.
- 126 -
์ 10์ฅ ์ด์ง ๊ฒ์ ํธ๋ฆฌ ์ด ์ฅ์์๋ ํธ๋ฆฌ ํํ์ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ์ดํด๋ณธ๋ค. ํนํ ํธ๋ฆฌ ํํ์ ์๋ฃ๊ตฌ์กฐ ์ค ์ด์ง ๊ฒ์ ํธ๋ฆฌ(binary search tree)์ ๋ํด ์ง์ค์ ์ผ๋ก ์ดํด๋ณธ๋ค.
10.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ํธ๋ฆฌ ๊ฐ์ ์ด์ง ํธ๋ฆฌ ๊ฐ์ ์ํ ๋ฐฉ๋ฒ ์ด์ง ๊ฒ์ ํธ๋ฆฌ ADT ๊ฒ์ ์ฝ์ ์ญ์ ์ํ ์ด์ง ํธ๋ฆฌ ๊ท ํ ๋ง์ถ๊ธฐ
10.2. ํธ๋ฆฌ
ํธ๋ฆฌ ๊ตฌ์กฐ ์ ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ์ฑ๋ฅ ์ธก๋ฉด์์๋ ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ ๊ตฌํ์ ๋นํด ์ฐ์ํ์ง ๋ชปํ์ง๋ง ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์๋ ์ฐ์ํ๋ค. ์ ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋ ๋ค๋ฅธ ๋จ์ ์ ์์ ์ ๊ทผ์ ํ ์ ์์ผ๋ฏ๋ก ์ ๋ ฌ๋ ๋ฆฌ์คํธ์์๋ ์ด์ง ๊ฒ์์ ํ ์ ์๋ค๋ ๊ฒ์ด๋ค. ์ ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ํ๋์ ๋ ธ๋๋ ์ค์ง ํ๋์ ๋ค๋ฅธ ๋ ธ๋๋ง ๊ฐ๋ฆฌํฌ ์ ์๋ค. ํธ๋ฆฌ(tree)๋ ํธ๋ฆฌ ๋ฃจํธ(root)๋ผ๊ณ ํ๋ ์ ์ผํ ์์ ๋ ธ๋๋ฅผ ๋ฃจํธ ๋ ธ๋ ๊ฐ์ง๋ฉฐ, ๊ฐ ๋ ธ๋๋ ์ฌ๋ฌ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ์ ์๋ ๊ตฌ์กฐ๋ก์, ๊ตฌ์กฐ ๋ฃจํธ์์ ๊ฐ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก๊ฐ ์ ์ผํ ๊ตฌ์กฐ๋ฅผ ๊ตฌ์กฐ ๋งํ๋ค. ํธ๋ฆฌ๋ ์ฌ๊ท ๊ตฌ์กฐ(recursive structure)์ด๋ค. ๊ตฌ์กฐ ๊ฐ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ทธ ๋ ธ๋๊ฐ ๋ฃจํธ๊ฐ ๋๋ ๋ถ๋ถํธ๋ฆฌ(subtree)๋ฅผ ๋ถ๋ถํธ๋ฆฌ ๋ง๋ค ์ ์๋ค.
7์ฅ์์ ์ดํด๋ณธ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋ฆฌ์คํธ๋ 5์ฅ์์ ์ดํด๋ณธ ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ์ ๋นํด ๊ณต๊ฐ ํ์ฉ ์ธก๋ฉด์์๋ ์ฐ์ํ์ง๋ง ์ฑ๋ฅ ์ธก๋ฉด์์๋ ์คํ๋ ค ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ๊ฐ ๋ ์ฐ์ ํ๋ค. ํนํ ์ ๋ ฌ ๋ฆฌ์คํธ์ ๊ฒฝ์ฐ์๋ ๋ฐฐ์ด์ ์์ ์ ๊ทผ์ด ๊ฐ๋ฅํ๋ฏ๋ก ์ด์ง ๊ฒ์์ ํ ์ ์
- 127 -
์ง๋ง ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๊ฒฝ์ฐ์๋ ์ ๋ ฌ๋์ด ์์์๋ ๋ถ๊ตฌํ๊ณ ์ด์ง ๊ฒ์์ ํ ์ ์๋ค. ์ด๋ฐ ๋จ์ ์ ํด๊ฒฐํ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ํธ๋ฆฌ(tree) ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค. ํธ๋ฆฌ๋ ๋ฃจํธ(root)๋ผ๊ณ ํ๋ ์ ์ผํ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ฉฐ, ๊ฐ ๋ ธ๋๋ ์ฌ๋ฌ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง ์ ์๊ณ , ๋ฃจํธ์ ์ ๊ฐ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก(path)๊ฐ ์ ์ผํด์ผ ํ๋ ๊ตฌ์กฐ์ด๋ค. ๋ ธ๋ A์์ ๋ ธ๋ B๊น์ง์ ๊ฒฝ๋ก๋ ๋ ธ๋ A์ ๋ ธ๋ B๋ฅผ ์ฐ๊ฒฐํ๋ ๊ฐ์ ๋ค์ ์ํด ์ธ์ ํ ์ผ๋ จ์ ๋ ธ๋๋ค์ ์งํฉ์ ๋งํ๋ค. ํธ๋ฆฌ ์ ์ ์์ ์ํ๋ฉด 7์ฅ์์ ์ดํด๋ณธ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ ํ ๋ฆฌ์คํธ๋ ์์ ๋ ธ๋๋ฅผ ์ต๋ ํ๋ ๋ง ๊ฐ์ง๋ ์ผ์ข ์ ํธ๋ฆฌ์ด๋ค. ํธ๋ฆฌ ๊ตฌ์กฐ๋ ์ฌ๊ท ๊ตฌ์กฐ๋ผ ํ๋ค. ์ด๊ฒ์ ํธ๋ฆฌ์ ์๋ ๊ฐ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ทธ ๋ ธ๋๊ฐ ๋ฃจํธ๊ฐ ๋๋ ํธ๋ฆฌ๋ฅผ ๋ง๋ค ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ์ด๋ฐ ํธ๋ฆฌ๋ฅผ ์ ํธ๋ฆฌ์ ๋ถ ๋ถ ํธ๋ฆฌ(subtree)๋ผ ํ๋ค.
ํธ๋ฆฌ ๊ตฌ์กฐ โ ๊ณ์ root (๋ฃจํธ ๋ ธ๋) internal node, intermediate node (์ค๊ฐ ๋ ธ๋, ๋ด๋ถ ๋ ธ๋)
ํธ๋ฆฌ๊ฐ ์๋ ร ๊ทธ๋ํ
subtree (๋ถ๋ถ ํธ๋ฆฌ)
leaf node (๋จ๋ง ๋ ธ๋)
๋ฃจํธ: ๋ถ๋ชจ๊ฐ ์๋ ๋ ธ๋ ๋จ๋ง: ์์์ด ์๋ ๋ ธ๋
๋ฃจํธ์์ ๊ฐ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก๊ฐ ์ ์ผํด์ผ ํ๋ค. ์ฆ, ๋ถ๋ชจ๊ฐ ํ๋์ด์ด์ผ ํ๋ค.
ํธ๋ฆฌ ์ฉ์ด ๋ฃจํธ ๋ ธ๋(root node): ๋ถ๋ชจ๊ฐ ์๋ ์ ์ผํ ๋ ธ๋ ๋จ๋ง ๋ ธ๋(leaf node): ์์์ด ์๋ ๋ ธ๋ ์ค๊ฐ ๋ ธ๋(internal node): ๋จ๋ง ๋ ธ๋๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋ ํ์ ๋ ธ๋(sibling node): ๋ถ๋ชจ๊ฐ ๊ฐ์ ๋ ธ๋ ์กฐ์ ๋ ธ๋(ancestor node): ๋ ธ๋์์ ๋ฃจํธ ๋ ธ๋๊น์ง ๊ฒฝ๋ก ์์ ์๋ ๋ชจ๋ ๋ ธ๋ ํ์ ๋ ธ๋(descendant node): ๋ ธ๋์์ ๋จ๋ง ๋ ธ๋๊น์ง ๊ฒฝ๋ก ์์ ์๋ ๋ชจ๋ ๋ ธ๋ ๋ ธ๋์ ๋ ๋ฒจ: ๋ฃจํธ ๋ ธ๋๋ก๋ถํฐ์ ๊ฑฐ๋ฆฌ ๋ฃจํธ ๋ ธ๋๋ 0 ๋ ๋ฒจ์ ์์นํ๋ฉฐ, ๋ฃจํธ๋ก๋ถํฐ ๊ฐ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ ๊ทธ ๋ ธ๋์ ๋ ๋ฒจ์ด ๋๋ค. ํธ๋ฆฌ์ ๋์ด: ํธ๋ฆฌ์ ๋ฃจํธ๋ก๋ถํฐ ๊ฐ์ฅ ๋จผ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก์ ๊ธธ์ด
ํธ๋ฆฌ ๊ตฌ์กฐ๋ ์์ ์ค๋ช ํ ๋ฐ์ ๊ฐ์ด ์ ์ผํ ์์ ๋ ธ๋์ธ ๋ฃจํธ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค. ์ด ๋ ธ๋๋ง ์ ์ผํ๊ฒ ๋ถ๋ชจ ๋ ธ๋๊ฐ ์๋ค. ๋ํ ์์์ด ์๋ ๋ ธ๋๋ฅผ ๋จ๋ง ๋ ธ๋(leaf node)๋ผ ํ๋ฉฐ, ๋จ๋ง ๋ ธ ๋๋ฅผ ์ ์ธํ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ค๊ฐ ๋ ธ๋ ๋๋ ๋ด๋ถ ๋ ธ๋๋ผ ํ๋ค. ํธ๋ฆฌ ๊ตฌ์กฐ๊ฐ ๋๊ธฐ ์ํด์๋ ๋ฃจ ํธ์์ ๊ฐ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก๊ฐ ์ ์ผํด์ผ ํ๋ค. ์ด๊ฒ์ ๋ค์ ๋งํ๋ฉด ๊ฐ ๋ ธ๋๋ ์ค์ง ํ๋์
- 128 -
๋ถ๋ชจ ๋ ธ๋๋ฅผ ๊ฐ์ ธ์ผ ํ๋ค. ๋ถ๋ชจ๊ฐ ๊ฐ์ ๋ ธ๋๋ค์ ํ์ ๋ ธ๋(sibling node)๋ผ ํ๋ค. ๋ ธ๋์์ ๋ฃจํธ๋ ธ๋๊น์ง ๊ฒฝ๋ก ์์ ์๋ ๋ชจ๋ ๋ ธ๋๋ ๋ ธ๋์ ์กฐ์ ๋ ธ๋(ancestor node)๊ฐ ๋๋ฉฐ, ๊ฑฐ๊พธ๋ก ํ ๋ ธ๋๋ถํฐ ๋จ๋ง ๋ ธ๋๊น์ง ๊ฒฝ๋ก ์์ ์๋ ๋ชจ๋ ๋ ธ๋๋ ๊ทธ ๋ ธ๋์ ํ์ ๋ ธ๋(descendant
node)๊ฐ ๋๋ค. ํธ๋ฆฌ์ ๋ ๋ฒจ(level)์ด๋ ๋ฃจํธ ๋ ธ๋๋ถํฐ์ ๊ฑฐ๋ฆฌ๋ฅผ ๋งํ๋ค. ๋ฃจํธ ๋ ธ๋๋ ๋ ๋ฒจ 0 ์ ์์นํ๋ฉฐ ๋ฃจํธ ๋ ธ๋์ ๋ฐ๋ก ์์ ๋ ธ๋๋ค์ ๋ ๋ฒจ 1์ ์์นํ๋ค๊ณ ๋งํ๋ค. ํธ๋ฆฌ์ ๋ ธ๋ ์ค ๊ฐ์ฅ ๋ ๋ฒจ์ด ๋์ ์์น์ ์๋ ๋ ธ๋์ ์ํด ํธ๋ฆฌ์ ๋์ด(height)๊ฐ ๊ฒฐ์ ๋๋ค.
์ด์ง ํธ๋ฆฌ ์ด์ง ํธ๋ฆฌ(binary tree): ํธ๋ฆฌ ๊ฐ ๋ ธ๋๊ฐ ์ต๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ง์ ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ ๊ฐ ๋ ๋ฒจ l์ ์์ ์ ์๋ ์ต๋ ๋ ธ๋์ ์: 2l ๋์ด๊ฐ h์ธ ํธ๋ฆฌ์ ์์ ์ ์๋ ์ต๋ ๋ ธ๋์ ์: 2h+1-1 20 + 21 +"+ 2h =
2h+1 โ 1 h+1 = 2 โ1 2 โ1
root
level 0
A
level 1 B
C
level 2 D
E
F
level 3 G height(depth): 3
N๊ฐ์ ๋ ธ๋๋ก ๋ง๋ค ์ ์๋ ํธ๋ฆฌ์ ์ต์ ๋์ด: โฃโข log 2 N โฆโฅ 2h โค N < 2h+1 (๋ ธ๋์ ์๊ฐ 2 ์ผ ๋ ํธ๋ฆฌ์ ๋์ด๋ h) 2h โ 1 < 2h < 2h+1 โ 1 h
h โค log2 N < h + 1
H
I
J leaf
G๋ B์ ์์ ๋ ธ๋ C๋ I์ ์กฐ์ ๋ ธ๋ G๋ D์ ์ผ์ชฝ ์์(left child) H๋ D์ ์ค๋ฅธ์ชฝ ์์(right child) G์ H๋ ํ์ ๋ ธ๋(sibling)
ํธ๋ฆฌ ์ค์ ๊ฐ ๋ ธ๋์ ์์ ์๊ฐ ์ต๋ 2์ธ ํธ๋ฆฌ๋ฅผ ์ด์ง ํธ๋ฆฌ(binary tree)๋ผ ํ๋ค. ๋ฐ๋ผ์ ์ด ์ง ํธ๋ฆฌ์ ๊ฐ ๋ ๋ฒจ ๎ฐ ์ ์์ ์ ์๋ ์ต๋ ๋ ธ๋์ ์๋ ๎ต๎ฐ ์ด๋ค. ๋ํ ๋์ด๊ฐ ๎ฌ ์ธ ํธ๋ฆฌ์ ์ ๎ฝ ๎ด ๎ฌ ๎ฌ๎๎ด ๎ ๎ด ์ด๋ค. ๎ ๊ฐ์ ๋ ธ๋๋ฅผ ๋ง๋ค ์ ์ ์ ์๋ ์ต๋์ ๋ ธ๋์ ์๋ ๎ต ๎ ๎ต ๎ ๎๎๎ ๎ ๎ต ๎ ๎ต
์๋ ์ต๋์ ๋์ด๋ ๎ -1์ด๋ค. ๋ฐ๋๋ก ๎ ๊ฐ์ ๋ ธ๋๋ก ๋ง๋ค ์ ์๋ ํธ๋ฆฌ์ ์ต์ ๋์ด๋
๎ฐ๎ณ๎ซ๎ต๎ ์ด๋ค. ์ด๊ฒ์ ๎ ์ ๋ฒ์๋ฅผ ์ผ๋ฐํํ์ฌ ๎ต๎ฌ โฆ ๎ ๎ ๎ต๎ฌ ๎ ๎ด ๋ก ์๊ฐํ ์ ์์ผ๋ฉฐ, ํธ๋ฆฌ์ ๋์ด๋ฅผ ์ต์ํํ๊ธฐ ์ํด์๋ ๊ฐ ๋ ๋ฒจ์ ์๋ ๋ ธ๋์ ์๊ฐ ์ต๋๊ฐ ๋์ด์ผ ํ๋ค๋ ๊ฒ์ ๊ณ ๋ ค ํ๋ฉด ์ฝ๊ฒ ์ดํดํ ์ ์๋ค.
- 129 -
์ด์ง ํธ๋ฆฌ์ ์ข ๋ฅ
ํฌํ ์ด์ง ํธ๋ฆฌ(full binary tree):
์์ ์ด์ง ํธ๋ฆฌ(complete binary tree):
๋ชจ๋ ๋จ๋ง ๋ ธ๋๊ฐ ๊ฐ์ ๋ ๋ฒจ์ ์์ผ๋ฉฐ, ๋ชจ๋ ์ค๊ฐ ๋ ธ๋๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ ๊ฒฝ์ฐ
๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ๋ฉด ํฌํ ์ด์ง ํธ๋ฆฌ ์ด๋ฉฐ, ์ดคํ์ ๋ ๋ฒจ์ ๋จ๋ง ๋ ธ๋๋ค์ ์ผ์ชฝ์ ์๋ถํฐ ์ฑ์์ง ํํ๋ก ๋์ด ์๋ ๊ฒฝ์ฐ
๋จ๋ง ๋ ธ๋์ ์๊ฐ n์ด๋ฉด ์ ์ฒด ๋ ธ๋์ ์๋ N=2n-1์ด๋ค.
์์ ์ด์ง ํธ๋ฆฌ์์ ์ค๊ฐ ๋ ธ๋์ ์์ ์๊ฐ 2์ผ ๋ ๋จ๋ง ๋ ธ๋์ ์๊ฐ n์ด๋ฉด ์ ์ฒด ๋ ธ๋์ ์๋ N=2n-1์ด๋ค.
์ด์ง ํธ๋ฆฌ์์ ๋ชจ๋ ๋จ๋ง ๋ ธ๋๋ ๊ฐ์ ๋ ๋ฒจ์ ์๊ณ ๋ชจ๋ ์ค๊ฐ ๋ ธ๋๋ ๋ ๊ฐ์ ์์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ ํธ๋ฆฌ๋ฅผ ํฌํ ์ด์ง ํธ๋ฆฌ(full binary tree)๋ผ ํ๋ค. ๋ํ ๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ๋ฉด ํฌํ ์ด์ง ํธ๋ฆฌ์ด๋ฉฐ, ์ตํ์ ๋ ๋ฒจ์ ๋จ๋ง ๋ ธ๋๋ค์ ์ผ์ชฝ์์๋ถํฐ ์ฑ์์ง ํํ๋ก ๋์ด ์๋ ํธ๋ฆฌ ๋ฅผ ์์ ์ด์ง ํธ๋ฆฌ(complete binary tree)๋ผ ํ๋ค.
10.3. ์ด์ง ๊ฒ์ ํธ๋ฆฌ
์ด์ง ๊ฒ์ ํธ๋ฆฌ ์ด์ง ๊ฒ์ ํธ๋ฆฌ(binary search tree)๋ ํธ๋ฆฌ ๊ฐ ๋ ธ๋์ ํค ๊ฐ์ด ์ผ์ชฝ ์์ ๋ ธ๋๋ค์ ํค ๊ฐ๋ณด๋ค๋ ํญ์ ํฌ๊ณ , ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ค์ ํค ๊ฐ๋ณด๋ค๋ ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๋งํ๋ค. 60
45 (์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ) left subtree
63
41
40
55
43
62
(์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ) right subtree
65
50
์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ๋ ธ๋์ ํค ๊ฐ<๋ฃจํธ ๋ ธ๋์ ํค ๊ฐ<์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ๋ ธ๋์ ํค ๊ฐ
์ด์ง ๊ฒ์ ํธ๋ฆฌ(binary search tree)๋ ๊ฐ ๋ ธ๋์ ํค ๊ฐ์ด ์ผ์ชฝ ์์ ๋ ธ๋๋ค์ ํค ๊ฐ๋ณด๋ค๋ ํญ์ ํฌ๊ณ , ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ค์ ํค ๊ฐ๋ณด๋ค๋ ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๋งํ๋ค.
- 130 -
์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ์ 60
height: 9 ํธํฅ ์ด์ง ํธ๋ฆฌ (skewed binary tree)
40
50
41 45
63
40
55
43 45
41
55
62
65
45
62 50
40
43
50
43 height: 3
60
65
60
height: 4 41
55
63 62 63 65
์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ ์์์ ๋ฐ๋ผ ๋ค์ํ ๋ชจ์ต์ ์ทจํ ์ ์๋ค. ์ ์ฌ๋ผ์ด๋์ ๋ ๊ฐ์ ์ข ๋ฅ์ ๋ ธ๋๋ค๋ก ๊ตฌ์ฑํ ์ธ ๊ฐ์ง ๋ค๋ฅธ ๋ชจ์ต์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ์ฌ ๊ธฐ์ ์ ์ ์๋ฏ์ด ์ต์ ์ ๊ฒฝ์ฐ์๋ ํ์ชฝ ๋ฐฉํฅ์ผ๋ก ํธํฅ๋ ์ ์์ผ๋ฉฐ, ์ด ๊ฒฝ์ฐ์๋ ๊ธฐ์กด ์ฐ ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ๋ฆฌ์คํธ์ ์ฐจ์ด๊ฐ ์ ํ ์๋ค.
์ด์ง ํธ๋ฆฌ ์ํ ์ํ(traversing): ํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ ๊ฒ ์ํ ํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ํํ ๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๋ฐฉ๋ฒ ์ ์(preorder) ์ํ: ๋ฃจํธ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ ร ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ์ ์ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ร ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ์ค์(inorder) ์ํ: ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ร ๋ฃจํธ ์ค์ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ ร ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ํ์(postorder) ์ํ: ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ร ํ์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธ ร ๋ฃจํธ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธ ์ด๋ค ์ํ ๋ฐฉ๋ฒ์ ๋ฃจํธ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ ์์์ ์ํด ๊ตฌ๋ถ๋๋ฉฐ, ๊ตฌ๋ถ ์ ์ธ ๊ฐ์ง ์ํ ๋ฐฉ๋ฒ์ ๊ณตํต์ ์ผ๋ก ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๋ ํญ์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๋ณด๋ค ๋จผ์ ๋ฐฉ๋ฌธํ๋ค. ์ค์ ์ํ ๋ฐฉ๋ฒ์ผ๋ก ์ํํ๋ฉด ์์ ๊ฐ๋ถํฐ ์์๋๋ก ๋ฐฉ๋ฌธํ๊ฒ ๋๋ค.
์ํ(traverse)๋ ๊ตฌ์กฐ์ ์๋ ๋ชจ๋ ์์๋ฅผ ์ต์ ํ๋ฒ์ฉ ๋ฐฉ๋ฌธํ๋ ๊ฒ์ ๋งํ๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ ์์ ๋ฆฌ์คํธ์์๋ ์ฒซ ๋ ธ๋๋ถํฐ ๋ฆฌ์คํธ์ ์๋ ๋ชจ๋ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ ๋๊น์ง ๋ ธ๋์ ์ฐ๊ฒฐ์ ๋ฐ๋ผ๊ฐ๋ฉด์ ๋ ธ๋๋ค์ ๋ฐฉ๋ฌธํ๋ค. ์ด์ง ํธ๋ฆฌ์์ ์ํ๋ ํ ๋ ธ๋์์ ๋ฐฉ๋ฌธํ ์ ์๋ ๋ค์ ๋ ธ ๋๊ฐ ์ต๋ ๋ ๊ฐ ์์ผ๋ฏ๋ก ๋ค์ํ๊ฒ ์ํ๋ฅผ ํ ์ ์๋ค. ํธ๋ฆฌ๋ฅผ ์ํํ ๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ ๋๋ ๋ฐฉ๋ฒ์๋ ์ ์(preorder), ์ค์(inorder), ํ์(postorder) ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์๋ค. ์ด๋ค์ ๋ฃจํธ๋ฅผ ๋ฐฉ๋ฌธํ๋ ์์์ ์ํด ๊ตฌ๋ถ๋๋ฉฐ, ํญ์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ๋ฅผ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ๋ณด๋ค ๋จผ์ ๋ฐฉ๋ฌธํ๋ค. ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ ์ค ์ค์ ๋ฐฉ๋ฒ์ผ๋ก ์ํํ๋ฉด ์์ ๊ฐ๋ถํฐ ์์๋๋ก ๋ฐฉ๋ฌธํ๊ฒ ๋๋ค.
- 131 -
์ด์ง ํธ๋ฆฌ ์ํ์ ์ 60
45
41
Preorder: 60 45 41 55 63 65 Inorder: 41 45 55 60 63 65 Postorder: 41 55 45 65 63 60
63
55
65
50
40
Preorder: 50 40 45 43 47 55 52 62 60 65 Inorder: 40 43 45 47 50 52 55 60 62 65 Postorder: 43 47 45 40 52 60 65 62 55 50
55
45
43
52
47
62
60
65
BST Interface Import java.util.Iterator; public interface BST{ int INORDER = 1; int PREORDER = 2; int POSTORDER = 3; boolean isEmpty(); boolean isFull(); void clear(); int numOfNodes(); boolean search(Object item); Object retrieve(Object item); void insert(Object item); boolean delete(Object item); Iterator iterator(int type); }
์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ์ค๋ณต ์์์ ์ถ๊ฐ๋ฅผ ํ์ฉํ์ง ์๋๋ค. ์ฐธ์กฐ ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ค.
์ํ ๋ฐฉ๋ฒ
์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ์ธํฐํ์ด์ค๋ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ์ธํฐํ์ด์ค์ ์ ์์์ ์ ์ ์๋ฏ์ด ๊ธฐ์กด ๋ฆฌ์คํธ ์ธํฐํ์ด์ค์ ํฐ ์ฐจ์ด๊ฐ ์๋ค. ๋ค๋ง size ๋ฉ์๋ ๋์ ์ numOfNodes๋ผ๋ ๋ฉ์ ๋๋ฅผ ์ฌ์ฉํ๊ณ ์๊ณ , ์ธ ์ข ๋ฅ์ ์ํ ๋ฐฉ๋ฒ์ ๋ํ๋ด๊ธฐ ์ํ ์์ ๊ฐ๋ค์ด ์ถ๊ฐ๋ก ์ ์๋์ด ์๋ค.
- 132 -
public class BinarySearchTree implements BST{ protected class BSTNode{ public Object info; public BSTNode left; public BSTNode right; } protected class TreeIterator implements Iterator{ LinkedQueue traverseQueue; public TreeIterator(int type){โฆ} public boolean hasNext(){โฆ} public Object next(){โฆ} public void remove(){โฆ} private void preOrder(BSTNode node){โฆ} node.left private void inOrder(BSTNode node){โฆ} private void postOrder(BSTNode node){โฆ} } protected BSTNode root = null; protected int numOfNodes = 0; public BinarySearchTree(){} public boolean isEmpty(){ return (root==null); } public boolean isFull(){ return false; } void clear() { โฆ } public int numOfNodes(){ return numOfNodes; } public boolean search(Object item){โฆ} public Object retrieve(Object item){โฆ} public void insert(Object item){โฆ} public boolean delete(Object item){โฆ} public Iterator iterator(int type){ return new TreeIterator(type); } }
node.right node.info
ํธ๋ฆฌ์ ๊ฐ ๋ ธ๋๋ฅผ ๋ํ๋ด๊ธฐ ์ํด BSTNode๋ผ๋ ๋ด๋ถ ํด๋์ค๋ฅผ ์ฌ์ฉํ๋ค. BSTNode ํด๋์ค ๋ 7์ฅ์์ ์ฌ์ฉํ ListNode์ ๋ฌ๋ฆฌ ๋ ๊ฐ์ง ์ฐ๊ฒฐ์ ๋ํ๋ด๋ ๋ฉค๋ฒ๋ณ์๊ฐ ํ์ํ๋ค. left๋ ๋ ธ๋์ ์ผ์ชฝ ์์์ ๊ฐ๋ฆฌํค๋ ๋ฉค๋ฒ๋ณ์์ด๊ณ , right๋ ๋ ธ๋์ ์ค๋ฅธ์ชฝ ์์์ ๊ฐ๋ฆฌํค๋ ๋ฉค๋ฒ ๋ณ์์ด๋ค. TreeIterator๋ ์ํํ ๋ ์ฌ์ฉํ ์ ์๋ ๋ฐ๋ณต์ ํด๋์ค์ด๋ค.
NumOfNodes ์ฌ๊ท์ ๋ฐฉ๋ฒ์ผ๋ก public int size(){ return size(root); } private int size(BSTNode node){ if(node == null) return 0; // leaf node else return(size(node.left)+size(node.right)+1); }
Tip. ํธ๋ฆฌ๋ ์ฌ๊ท์ ๊ตฌ์กฐ์ด๋ฏ๋ก ์ฌ๊ท์ ๋ฐฉ๋ฒ์ผ๋ก ๊ตฌํํ๋ ๊ฒ์ด ์ฝ๋ค.
ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ๊ฐ์๋ ์ฝ์ ํ ๋๋ง๋ค ์ฆ๊ฐํ๊ณ ์ญ์ ๋ ๋๋ง๋ค ๊ฐ์ํ๋ numOfNodes ๋ผ๋ ๋ฉค๋ฒ๋ณ์๋ฅผ ํตํด ์ธ์ ๋ ์ง ์ ์ ์๋ค. ํ์ง๋ง ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ทธ๋๋ง๋ค ๊ณ์ฐํ ์๋ ์๋ค. ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ๊ฐ์๋ฅผ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ๊ตฌํํ๋ฉด ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค. ์ด ๋ฉ์๋ ์์ ์ฌ๊ท ํธ์ถ์ ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ๊ฐ์๋งํผ ํธ์ถ๋๋ฏ๋ก ํจ์จ์ ์ด์ง ๋ชปํ๋ค. ํ์ง๋ง ํธ ๋ฆฌ๋ ๊ทธ ์์ฒด๊ฐ ์ฌ๊ท ๊ตฌ์กฐ์ด๋ฏ๋ก ํจ์จ์ฑ์ ๊ณ ๋ คํ์ง ์์ผ๋ฉด ํ์ํ ๋๋ถ๋ถ์ ์ฐ์ฐ์ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ์ฝ๊ฒ ๊ตฌํํ ์ ์๋ค.
- 133 -
NumOfNodes ๋น์ฌ๊ท์ ๋ฐฉ๋ฒ์ผ๋ก E F C
C
E
F
A
count = 0; A ํธ๋ฆฌ๊ฐ empty๊ฐ ์๋๋ฉด ๋ค์์ ์คํ์ ์คํ ํ๋ ์์ฑ ๋ฃจํธ ๋ ธ๋๋ฅผ ์คํ์ push ์คํ์ด empty๊ฐ ์๋๋ฉด ๋ค์์ ๋ฐ๋ณต ํ์ฌ ๋ ธ๋๋ฅผ ์คํ top์ ์๋ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋๋ก ํจ ์คํ์์ ๋ ธ๋๋ฅผ ํ๋ popํ ๋ค์์ count๋ฅผ 1 ์ฆ๊ฐ ๋ง์ฝ ํ์ฌ ๋ ธ๋๊ฐ ์ผ์ชฝ ์์์ด ์์ผ๋ฉด ๊ทธ ์์์ ์คํ์ push ๋ง์ฝ ํ์ฌ ๋ ธ๋๊ฐ ์ค๋ฅธ์ชฝ ์์์ด ์์ผ๋ฉด ๊ทธ ์์์ ์คํ์ push return count;
์ฌ๊ท ๋ฐฉ์์ ์ฌ์ฉํ์ง ์๊ณ ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ณ์ฐํ์ฌ ๋ณด์. ์ฌ๊ท ๋ฐฉ์์ ๊ตฌํ์ ๋ณด๋ฉด ์ฌ๊ท ํธ์ถ์ด ๊ฐ์ ๋ฌธ์ฅ์์ ๋ ๋ฒ ์ด๋ฃจ์ด์ง๋ฏ๋ก ๊ผฌ๋ฆฌ ์ฌ๊ท๊ฐ ์๋๋ค. ๋ฐ๋ผ์ ์ฝ๊ฒ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉ ํ์ฌ ํด๊ฒฐํ๊ธฐ๊ฐ ์ด๋ ต๋ค. ๋์ ์ ์คํ์ ์ง์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ์ฌ๊ท๋ฅผ ์ ๊ฑฐํ๋ ๋ฐฉ๋ฒ์ ๊ณ ๋ คํ๋ ๊ฒ์ด ์ ์ ํ๋ค. ๋น์ฌ๊ท์ ๋ฐฉ๋ฒ์ผ๋ก ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ์ ๊ณ ๋ฆฌ์ฆ์ ์ ์ฌ๋ผ์ด๋์ ๊ฐ๋ค.
search ์ฌ๊ท ๋ฐฉ๋ฒ์ผ๋ก private boolean search(Comparable item, BSTNode node){ if(node == null) return false; int comp = item.compareTo(node.info); if(comp<0) return search(item, node.left); else if(comp>0) return search(item, node.right); else return true; } public boolean search(Object item){ if(isEmpty()) throw new TreeUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); Comparable x = (Comparable)item; return search(x, root); }
60
45
63
41
55
62
65
์ ํ์ ์ธ ์ด์ง ๊ฒ์ 40
43
50
์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ๊ฒ์์ ์ ํ์ ์ผ๋ก ์ด์ง ๊ฒ์์ ํ๊ฒ ๋๋ค. ๋จผ์ ๋ฃจํธ์ ๋น๊ตํ ๋ค์์ ๋ฃจํธ๋ณด๋ค ์ฐพ๊ณ ์ ํ๋ ์์๊ฐ ์์ผ๋ฉด ๋ฃจํธ์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ๋ก ์ด๋ํ๊ฒ ๋๋ค. ๋ฐ๋ผ์ ํ๋ฒ ๋น๊ตํ ๋๋ง๋ค ํ์ชฝ ์๋ธํธ๋ฆฌ๋ ํ๋ณด์์ ์ ์ธ๋๋ค. ํธ๋ฆฌ๊ฐ ์์ ์ด์ง ํธ๋ฆฌ์ด๊ณ , ํธ๋ฆฌ์ ๎ ๊ฐ์ ๋ ธ๋๊ฐ ์๋ค๋ฉด ์ด ํธ๋ฆฌ์์ ์ฌ๊ท ํธ์ถ์ ์ต๋ ํธ๋ฆฌ์ ๋์ด์ธ ๋ฐ๋ผ์ ์ด ๊ฒฝ์ฐ์๋ ์ฌ๊ท ๋ฐฉ์์ผ๋ก ๊ตฌํํ์ฌ๋ ๋ฌธ์ ๊ฐ ์๋ค.
- 134 -
๎ฐ๎ณ๎ซ๎ต๎ ๋ฒ ์ด๋ฃจ์ด์ง๋ค.
search ๋ฐ๋ณต ๋ฐฉ๋ฒ์ผ๋ก found = false; ํธ๋ฆฌ๊ฐ ๋น์ด ์์ผ๋ฉด return false; moreToSearch = true; node = root; found๊ฐ true์ด๊ฑฐ๋ moreToSearch๊ฐ false์ผ ๋๊น์ง ๋ค์์ ๋ฐ๋ณต node์ item์ ๋น๊ต ๊ฐ์ผ๋ฉด return true; item์ด node๋ณด๋ค ์์ผ๋ฉด node = node.left; item์ด node๋ณด๋ค ํฌ๋ฉด node = node.right; moreToSearch = (node != null) return found
๊ฒ์์ ์ฌ๊ท ๊ตฌํ์ ๊ผฌ๋ฆฌ์ฌ๊ท์ด๋ฏ๋ก ์ด ๊ฒฝ์ฐ์๋ ์ฝ๊ฒ ๋ฐ๋ณต๋ฌธ์ ์ด์ฉํ์ฌ ์ฌ๊ท๋ฅผ ์ ๊ฑฐํ ์ ์๋ค.
insert 1 insert(5)
2 insert(9)
5
5 insert(8)
9 3 insert(7)
4
insert(3)
5
7
3
3
9
7
6
7
9
3 12
9
4
7
12
5 9
7
5
7
insert(12)
8 3
insert(4)
5
5
9
8
insert(6)
5
5
6 3
8
6
8
9
12
7
8
ํญ์ ๋จ๋ง๋ ธ๋๋ก ์ถ๊ฐ๋๋ค. ์ฝ์ ๋๋ ์์๊ฐ ํธ๋ฆฌ์ ๋ชจ์ต์ ๊ฒฐ์ ํ๋ค.
์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ ๋ ธ๋๋ ํญ์ ๋จ๋ง๋ ธ๋๋ก ์ถ๊ฐ๋๋ฉฐ, ์ด ์ถ๊ฐ๊ฐ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ํน ์ฑ์ ์ ์งํด์ผ ํ๋ค. ๋ฐ๋ผ์ ์ถ๊ฐํ ๋ ธ๋์ ํค ๊ฐ์ ํธ๋ฆฌ์์ ๊ฒ์ํ๋ฏ์ด ๊ธฐ์กด ํค ๊ฐ๋ค๊ณผ ๋น๊ตํ์ฌ ์ฝ์ ์์น๋ฅผ ์ฐพ์ ์ถ๊ฐํ๊ฒ ๋๋ค. ์ด๋ฐ ๋ฐฉ์์ผ๋ก ์ถ๊ฐ๋๊ธฐ ๋๋ฌธ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ ์ ๋ชจ์ต์ ํค ๊ฐ๋ค์ด ์ฝ์ ๋๋ ์์์ ์ํด ๊ฒฐ์ ๋๋ค.
- 135 -
insert public void insert(Object item){ if(item==null) throw new NullPointerException(โโฆโ); Comparable x = (Comparable)item; root = insert(x, root); } private BSTNode insert(Comparable item, BSTNode node){ if(node == null){ BSTNode newNode = new BSTNode(); newNode.info = item; newNode.left = null; newNode.right = null; numOfNodes++; return newNode; } int comp = item.compareTo(node.info); if(comp<0) node.left = insert(item, node.left); else if(comp>0) node.right = insert(item, node.right); else node.info = item; return node; }
delete delete(8)
delete(2)
5
3
9
4
3
12
7
6
5
5
2
9
4
8
7
5
9
4
12
3
6
12
7
6
4
9
3
8
12
7
6
๋จ๋ง ๋ ธ๋์ ์ญ์
์์์ด ํ๋์ธ ๋ ธ๋์ ์ญ์
๋ฐ๋ก ์ญ์
๋จ์ ์์๊ณผ ๋ ธ๋๋ฅผ ๊ต์ฒด
8
์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ๋ ธ๋์ ์ญ์ ๋ ์ถ๊ฐ๋ณด๋ค ๋ณต์กํ๋ค. ์ถ๊ฐ๋ ํญ์ ๋จ๋ง๋ ธ๋์์ ์ด๋ฃจ์ด์ง ์ง๋ง ์ญ์ ๋ ๋จ๋ง๋ ธ๋๋ฟ๋ง ์๋๋ผ ์ค๊ฐ๋ ธ๋๋ ์ญ์ ๋ ์ ์๋ค. ๋ฐ๋ผ์ ์ญ์ ๋ ํฌ๊ฒ ์ธ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด ๊ณ ๋ คํ ์ ์๋ค. ์ฒซ์งธ, ๋จ๋ง๋ ธ๋์ ์ญ์ ๋์งธ, ์์์ด ํ๋ ์๋ ์ค๊ฐ๋ ธ๋์ ์ญ์ ์ ์งธ, ์์์ด ๋์ธ ์ค๊ฐ๋ ธ๋์ ์ญ์ ๋จ๋ง๋ ธ๋์ ์ญ์ ๋ ๊ทธ ๋ ธ๋๋ฅผ ์ญ์ ํ๋ฉด ๊ทธ๊ฒ์ผ๋ก ์ญ์ ๊ฐ ์๋ฃ๋๋ค. ํ๋ก๊ทธ๋จ ์ธก๋ฉด์์ ๋ณด๋ฉด ์ญ์ ํ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋์ ์ฐ๊ฒฐ ์ค ์ญ์ ํ ๋ ธ๋์ ๋ํ ์ฐ๊ฒฐ ๊ฐ์ null ๊ฐ์ผ๋ก ๋ฐ๊พธ๋ฉด ๋ ๋ค. ์์์ด ํ๋ ์๋ ์ค๊ฐ๋ ธ๋์ ์ญ์ ๋ ๊ทธ๊ฒ์ ๋ถ๋ชจ ๋ ธ๋์ ์ฐ๊ฒฐ ์ค ์์ ์ ๋ํ ์ฐ๊ฒฐ์ ์์ ์ ์์ ๋ ธ๋์ ๋ํ ์ฐ๊ฒฐ๋ก ๋ฐ๊พธ๋ฉด ๋๋ค.
- 136 -
delete โ ๊ณ์ delete(9) 5
3
9
4
์๊ณ ๋ฆฌ์ฆ
5
3
12
7
4
8
6
์ญ์ ํ ๋ ธ๋๋ฅผ ์ฐพ๋๋ค. ์ญ์ ํ ๋ ธ๋๊ฐ ๋จ๋ง๋ ธ๋์ด๋ฉด ๋ ธ๋ ์ญ์ ์ญ์ ํ ๋ ธ๋๊ฐ ๋จ๋ง๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๊ฐ ์์ผ๋ฉด ์ผ์ชฝ ์์ ๋ ธ๋๋ฅผ ํ ๋จ๊ณ ์๋ก ์ผ์ชฝ ์์ ๋ ธ๋๊ฐ ์์ผ๋ฉด ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ฅผ ํ ๋จ๊ณ ์๋ก ์์์ด ๋ ๋ค ์์ผ๋ฉด predecessor๋ฅผ ์ฐพ์ ์ด๊ฒ์ ์ญ์ ํ ๋ ธ๋์ ๊ฐ๊ณผ ๋ฐ๊ฟ predecessor ๋ ธ๋๋ฅผ ์ญ์
8
12
7
6
์์์ด ๋์ธ ๋ ธ๋์ ์ญ์
์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ ์ค ๊ฐ์ฅ ํฐ ๋ ธ๋(predecessor)์ ๊ต์ฒด - ์ด ๋ ธ๋๋ ํญ์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ๋ชจ๋ ๋ ธ๋๋ณด๋ค๋ ํฌ๊ณ , ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ๋ชจ๋ ๋ ธ๋๋ณด๋ค๋ ์์ ๋ ธ๋์ด๋ค. ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ๊ฐ์ฅ ์์ ๋ ธ๋์ ๊ต์ฒด ๊ฐ๋ฅ
์์์ด ๋ ๋ค ์๋ ์ค๊ฐ ๋ ธ๋์ ์ญ์ ๋ ๊ทธ๊ฒ์ ๋ฐ๋ก ์ญ์ ํ ์ ์๋ค. ์ด๊ฒ์ ์ญ์ ํ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋์ ์ฐ๊ฒฐ์ ์ญ์ ํ ๋ ธ๋์ ํ์ชฝ ์์๋ง ๊ฐ๋ฆฌํค๋๋ก ๋ณ๊ฒฝํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ ธ๋ ๊ฐ ์ญ์ ๋์ด๋ ํธ๋ฆฌ๋ ์ฌ์ ํ ์ด์ง ํธ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ ์งํด์ผ ํ๋ค. ์ด๊ฒ์ ํ๊ธฐ ์ํ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ญ์ ํ ๋ ธ๋๋ฅผ ํธ๋ฆฌ์ ์๋ ๋ค๋ฅธ ๊ฐ์ผ๋ก ๋์ฒดํ๋ ๊ฒ์ด๋ค. ์ด์ง ํธ๋ฆฌ์ ๊ตฌ์กฐ๋ฅผ ์ ์ง ํ๋ฉด์ ์ญ์ ํ ๋ ธ๋๋ฅผ ๋์ฒดํ ์ ์๋ ๊ฐ์ ์ ํํ๊ฒ ๋ ๊ฐ ์กด์ฌํ๋ค. ํ๋๋ ์ญ์ ํ ๋ ธ๋ ์ ์๋ ํค ๊ฐ๋ณด๋ค๋ ์์ง๋ง ๊ฐ์ฅ ํฐ ๊ฐ์ด๊ณ , ๋ค๋ฅธ ํ๋๋ ์ญ์ ํ ๋ ธ๋์ ์๋ ํค ๊ฐ๋ณด๋ค๋ ํฌ์ง๋ง ๊ฐ์ฅ ์์ ๊ฐ์ด๋ค. ์ ์๋ ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ด๊ณ , ํ์๋ ๋ ธ๋ ์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์์ ๊ฐ์ฅ ์์ ๊ฐ์ด๋ค. ์ด ์ฅ์์๋ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ผ๋ก ๋์ฒดํ์ฌ ์ญ์ ๋ฅผ ์ํํ๋ค. ์ด ๋ ๋์ฒดํจ์ผ๋ก์จ ์ญ์ ๊ฐ ์๋ฃ๋๋ ๊ฒ์ ์๋๊ณ , ๋์ฒดํ ํ์ ๋์ฒด์ ์ฌ์ฉ๋ ๋ ธ๋๋ฅผ ์ค์ ๋ก ํธ๋ฆฌ์์ ์ญ์ ํด์ผ ํ๋ค. ์ด ๋ ์ฃผ๋ชฉํด์ผ ํ๋ ๊ฒ์ ๋์ฒด์ ์ฌ์ฉ๋ ๋ ธ๋๋ ๋จ๋ง๋ ธ๋์ด๊ฑฐ๋ ์์์ด ํ๋ ๋ฐ์ ์๋ ์ค๊ฐ ๋ ธ๋์ด๋ค. ๊ทธ ์ด์ ๋ ๋ง์ฝ ์์ ์ด ๋ ๋ค ์๋ ์ค๊ฐ ๋ ธ๋์ด๋ฉด ๊ทธ๊ฒ์ ์ค๋ฅธ์ชฝ ์์์ด ๋ ํฐ ๊ฐ์ด ๋๊ธฐ ๋๋ฌธ์ด๋ค.
delete โ ๊ณ์ 5
5
3
12
4
3
7
15
9
6
8
5
13
9
4
17
3
7
15
9
6
13
8
- 137 -
9
4
17
7
6
15
8
13
17
public boolean delete(Object item){ if(isEmpty()) throw new TreeUnderflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); Comparable x = (Comparable)item; deleteSuccessful = false; root = delete(x, root); if(deleteSuccessful){ numOfNodes--; return true; } else return false; } private BSTNode delete(Comparable item, BSTNode node){ if(node == null) return node; int comp = item.compareTo(node.info); if(comp<0) node.left = delete(item, node.left); else if(comp>0) node.right = delete(item, node.right); else{ deleteSuccessful = true; node = deleteNode(node); } return node; }
private BSTNode deleteNode(BSTNode node){ if(node.left==null&&node.right==null) return null; // ๋จ๋ง๋ ธ๋ else if(node.right==null) return node.left; // ์ค๋ฅธ์ชฝ ์์์ด ์๋ ๋ ธ๋ else if(node.left==null) return node.right; // ์ผ์ชฝ ์์์ด ์๋ ๋ ธ๋ else{ // ์์์ด ๋ชจ๋ ์๋ ๋ ธ๋ Object predecessor = getPredecessor(node.left); node.info = predecessor; node.left = delete((Comparable)predecessor, node.left); return node; } } private getPredecessor(BSTNode node){ โฆ } 10
5
12
8
3
7
- 138 -
8
5
3
12
7
Traverse ์ธ ๊ฐ์ง ์ํ ๋ฐฉ๋ฒ์ ์ ๊ณตํ๋ ๋ฐ๋ณต์ ํด๋์ค ์ฌ์ฉ ์ง์ ๋ ๋ฐฉ๋ฒ์ผ๋ก ๋ฏธ๋ฆฌ ์ํํ์ฌ ์ํํ ์์๋ก ํ์ ๋ ธ๋์ ์์๋ฅผ ์ถ๊ฐํจ
protected class TreeIterator implements Iterator{ LinkedQueue traverseQueue; public TreeIterator(int type){ traverseQueue = new LinkedQueue(); switch(type){ case INORDER: inOrder(root); return; case PREORDER: preOrder(root); return; case POSTORDER: postOrder(root); return; } // switch } public boolean hasNext() { return !traverseQueue.isEmpty(); } public Object next(){ return traverseQueue.deq(); } public void remove(){ return new UnsupportedOperationException(โโฆโ); } private void preOrder(BSTNode node){ โฆ } private void inOrder(BSTNode node){ if(node!=null){ if(node.left!=null) inOrder(node.left); traverseQueue.enq(node.info); if(node.right!=null) inOrder(node.right); } } private void postOrder(BSTNode node){ โฆ } }
์ํ๋ ์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด ํฌ๊ฒ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ฐ๋ณต์ ํด ๋์ค๋ ์ด๋ค ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ ๋ชจ๋ ์ ๊ณตํ๋๋ก ๊ตฌํํ๋ค. ์ํ๋ฅผ ๊ตฌํํ๋ ๊ธฐ๋ณธ์ ์ธ ์๋ฆฌ๋ ๋ค์๊ณผ ๊ฐ๋ค. ๋จผ์ ์ง์ ๋ ๋ฐฉ๋ฒ์ผ๋ก ๋ฏธ๋ฆฌ ์ํ๋ฅผ ํ๋ค. ์ด ๋ ์ํํ ์์๋๋ก ๋ ธ๋์ ์์ ๋ค์ ํ์ ์ฝ์ ํ๋ค. ์ฌ์ฉ์๊ฐ ์ํ๋ฅผ ์์ํ๋ฉด ํธ๋ฆฌ๋ฅผ ์ํํ๋ฉด์ ๋ ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ ๊ฒ์ด ์๋๋ผ ์ด ํ์ ์ฝ์ ๋ ์์๋๋ก ํ๋ฅผ ํตํด ์ํ๋ฅผ ํ๋ค.
๋น๊ต BST*
๋ฐฐ์ด ๋ฆฌ์คํธ
O(1)
O(N)
O(1)
search
O(log2N)
O(log2N)
O(N)
retrieve Find process Total
O(log2N) O(1) O(log2N)
O(log2N) O(1) O(log2N)
O(N) O(1) O(N)
insert Find process Total
O(log2N) O(1) O(log2N)
O(log2N) O(N) O(N)
O(N) O(1) O(N)
delete Find process Total
O(log2N) O(log2N) O(log2N)
O(log2N) O(N) O(N)
O(N) O(1) O(N)
constructor
์ฐ๊ฒฐ ๋ฆฌ์คํธ
*. ๊ท ํ ํธ๋ฆฌ์ผ ๊ฒฝ์ฐ์๋ง O(log2N)
์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ๊ธฐ์กด ๋ฐฐ์ด์ ์ด์ฉํ ๋ฆฌ์คํธ๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋ฆฌ์คํธ์ ๋ฌ๋ฆฌ ๋ชจ๋ ์ฐ ์ฐ์ ์๊ฐ๋ณต์ก๋๊ฐ ์ง์์๊ฐ์ด๋ค. ํ์ง๋ง ์ฌ๊ธฐ์ ์ฃผ์ํด์ผ ํ๋ ๊ฒ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๊ฐ ๊ท ํ ํธ๋ฆฌ์ผ ๊ฒฝ์ฐ์๋ง ์ง์์๊ฐ์ด๊ณ , ์ต์ ์ ๊ฒฝ์ฐ์๋ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ๋ฆฌ์คํธ์ ๋์ผํ ์ ์๋ค. ๊ท ํ ํธ๋ฆฌ๋ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ฐจ๊ฐ ์ต๋ ํ๋์ธ ํธ ๋ฆฌ๋ฅผ ๋งํ๋ค.
- 139 -
ํธ๋ฆฌ์ ๊ท ํ ๋ง์ถ๊ธฐ ๊ธฐ๋ณธ์ ์ธ ์๊ฐ ๋จ๊ณ 1. ํธ๋ฆฌ ์ ๋ณด๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ ๋ค์์ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ: inorder, preorder, postorder ๋จ๊ณ 2. ์ด ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ํธ๋ฆฌ๋ฅผ ์ฌ๊ตฌ์ฑ ์์ดํ ์ ์ถ๊ฐํ ๋๋ง๋ค ๊ท ํ์ ๋ง์ถ๊ธฐ ์ํด ํธ๋ฆฌ๋ฅผ ์ฌ๊ตฌ์ฑํ๋ ๊ฒ์ ๋นํจ์จ์ ์ด๋ค. ๊ทธ๋ฌ๋ฉด ์ธ์ ? ํธ๋ฆฌ์ ํ์ฌ ๋์ด์ ํ์ฌ ๋ ธ๋์ ์๋ก ๊ตฌ์ฑํ ์ ์๋ ์ต์ ์ ํธ๋ฆฌ์ ๋์ด์ ์ฐจ์ด๊ฐ ๋๋ฌด ํฌ๋ฉด ๊ธฐ์ค์ ์์ฉ์ ๋ฐ๋ผ ๊ฒฐ์
์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ๋ชจ๋ ์ฐ์ฐ์ ์๊ฐ๋ณต์ก๋๊ฐ ์ง์ ์๊ฐ์ด ๋ ์ ์์ง๋ง ํธ๋ฆฌ์ ๊ท ํ์ด ์ ์ง ๋๋ ๊ฒฝ์ฐ์๋ง ๊ทธ๋ ๋ค. ๊ทธ๋ฐ๋ฐ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ชจ์ต์ ๋ ธ๋๋ค์ด ์ถ๊ฐ๋ ์์์ ์ํด ๊ฒฐ์ ๋๋ฏ๋ก ์๊ฐ์ด ๊ฒฝ๊ณผ๋๋ฉด ๋งค์ฐ ํธํฅ๋ ์ด์ง ํธ๋ฆฌ๊ฐ ๋ ์ ์๋ค. ๋ฐ๋ผ์ ์ฑ๋ฅ์ ์ ์งํ๊ธฐ ์ ํด์๋ ํธ๋ฆฌ์ ๊ท ํ์ ์ข ์ข ๋ง์ถ์ด์ผ ํ๋ค. ํ์ง๋ง ํธ๋ฆฌ์ ๊ท ํ์ ๋ง์ถ๋ ๋น์ฉ์ด ๋งค์ฐ ๋น์ธ ๋ฏ๋ก ๋ ธ๋๋ฅผ ์ถ๊ฐํ ๋๋ง๋ค ๊ท ํ์ ๋ง์ถ ์๋ ์๋ค. ํธ๋ฆฌ์ ๊ท ํ์ ๋ง์ถ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ํธ๋ฆฌ๊ฐ ๊ท ํ ํธ๋ฆฌ๊ฐ ๋๋๋ก ์ฝ์ ์์๋ฅผ ๋ณ๊ฒฝํ์ฌ ๋น ํธ๋ฆฌ๋ถํฐ ๋ค์ ๋ชจ๋ ๋ ธ๋๋ค์ ํ๋์ฉ ์ถ๊ฐํ๋ ๊ฒ์ด๋ค.
ํธ๋ฆฌ์ ๊ท ํ ๋ง์ถ๊ธฐ โ ๊ณ์ 3
10
5
12
8
3
7
10
5
5
7
12
8
3
8
3
7
5
8
12
7
10
10
inorder: 3 5 7 8 10 12 12
preorder: 10 5 3 8 7 12 postorder: 3 7 8 5 12 10
inorder
preorder
postorder
ํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ด์ฉํ์ฌ ํธ๋ฆฌ๋ฅผ ๋ค์ ์ฌ๊ตฌ์ฑํ๊ธฐ ์ํด์๋ ๋จผ์ ํธ๋ฆฌ์ ์๋ ๋ชจ ๋ ๋ ธ๋๋ฅผ ์์๋ก ํ๋ ๋ฐฐ์ด์ ๊ฐ์ ๊ตฌ์กฐ์ ์ ์ฅ์ ํด์ผ ํ๋ค. ์์ ์ดํด๋ณธ ์ธ ๊ฐ์ง ์ํ๋ฐฉ ๋ฒ์ผ๋ก ์ํํ๋ฉด์ ๋ฐฐ์ด์ ์ ์ฅํ๊ฑฐ๋ ํ์ ์ ์ฅํ ํ์ ๊ทธ ์์๋๋ก ๋ค์ ํธ๋ฆฌ๋ฅผ ์ฌ๊ตฌ์ฑํ ๋ฉด ์ธ ๊ฐ์ง ์ํ ๋ฐฉ๋ฒ ๋ชจ๋ ๊ท ํ ํธ๋ฆฌ๋ฅผ ์์ฑํด์ฃผ์ง ๋ชปํ๋ค.
- 140 -
ํธ๋ฆฌ์ ๊ท ํ ๋ง์ถ๊ธฐ โ ๊ณ์ 7
8 10 5 5
3 8
3
12
5
10
12
7
7
10
8
3
12
๋ฐฉ๋ฒ: inorder์์ ์ค๊ฐ ๋ ธ๋๋ถํฐ ์ฝ์ 3 3
5 5
10 12
low=0, high=6, mid=3
7
8
7
low=0, high=2, mid=1
inorder: 3 5 7 8 10 12 3 7 10 12
low=4, high=5 ร high, low์์ผ๋ก ์ฝ์
ํธ๋ฆฌ๊ฐ ๊ท ํ ํธ๋ฆฌ๊ฐ ๋๊ธฐ ์ํด์ ํธ๋ฆฌ์ ์๋ ์ ์ฒด ๋ ธ๋๋ค ์ค์ ์ค๊ฐ ๊ฐ์ด ๋๋ ๋ ธ๋๊ฐ ํธ ๋ฆฌ์ ๋ฃจํธ๊ฐ ๋์ด์ผ ํ๋ค. ๋ํ ์ค๊ฐ ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ทธ ๊ฐ๋ณด๋ค ์์ ๊ฐ๋ค ์ค์์ ์ค๊ฐ ๊ฐ๊ณผ ๊ทธ ๊ฐ๋ณด๋ค ํฐ ๊ฐ๋ค ์ค์์ ์ค๊ฐ ๊ฐ์ด ๊ทธ ๋ค์ ๋ ๋ฒจ์ ์ถ๊ฐ๋์ด์ผ ํ๋ค.
ํธ๋ฆฌ์ ๊ท ํ ๋ง์ถ๊ธฐ โ ๊ณ์ public void BalanceTree(){ inorder๋ก Object ๋ฐฐ์ด nodes์ BST์ ๊ฐ ๋ ธ๋ ๊ฐ์ ์ฐจ๋ก๋ก ์ฝ์ BalanceTree(0,numOfNodes,nodes); } private void BalanceTree(int low, int high, Object[] nodes){ low==high์ด๋ฉด nodes[low]๋ฅผ ์ฝ์ (low+1)==high์ด๋ฉด nodes[high]์ nodes[low]๋ฅผ ๋ชจ๋ ์ฝ์ ์ ๋ ๊ฒฝ์ฐ๊ฐ ์๋๋ฉด mid = (low+high)/2 nodes[mid]๋ฅผ ์ฝ์ BalanceTree(low, mid-1, nodes); BalanceTree(mid+1, high, nodes); }
ํธ๋ฆฌ์ ๊ท ํ์ ๋ง์ถ๊ธฐ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ๋ค์๊ณผ ๊ฐ๋ค. ์ค์ ๋ฐฉ๋ฒ์ผ๋ก ํธ๋ฆฌ๋ฅผ ์ํํ๋ฉด์ ์ ํํ ์์๋๋ก ์์ ๋ฐฐ์ด์ 0๋ฒ์งธ ์์ธ๋ถํฐ ์ฐจ๋ก๋๋ก ์ ์ฅํ๋ค. ๊ทธ ๋ค์ ํธ๋ฆฌ๋ฅผ ๋น ํธ๋ฆฌ๋ก ๋ง๋ค๊ณ ์์ ๋ฐฐ์ด๋ก๋ถํฐ ํ๋์ฉ ์ ํํ์ฌ ํธ๋ฆฌ๋ฅผ ์ฌ๊ตฌ์ฑํ๋ค. ์ด ๋ ์ค๊ฐ๊ฐ์ ๊ฐ์ฅ ๋จผ์ ์ฝ ์ ํ๊ณ ์ค๊ฐ๊ฐ์ ๊ธฐ์ค์ผ๋ก ๋ฐฐ์ด์ ์ด๋ฑ๋ถํ์ฌ ๋ฐฐ์ด์ ํฌ๊ธฐ 1 ๋๋ 2๊ฐ ์๋ ์ด์ ๋ค์ ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ๋ค. ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 1์ด๋ฉด ํด๋น ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ฉด ๋๊ณ , ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ 2์ธ ๊ฒฝ ์ฐ์๋ ํฐ ๊ฐ๋ถํฐ ๋จผ์ ์ฝ์ ํ๋ค. ์ด๊ฒ์ ํธ๋ฆฌ๋ฅผ ์์ ์ด์ง ํธ๋ฆฌ๋ก ๋ง๋ค๊ธฐ ์ํจ์ด๋ค.
- 141 -
์ 11์ฅ ํ, AVL ํธ๋ฆฌ ์ด ์ฅ์์๋ ์ด์ง ํธ๋ฆฌ์ ํน์ํ ํํ์ธ ํ(heap)๊ณผ AVL ํธ๋ฆฌ์ ๋ํด ์ดํด๋ณธ๋ค.
11.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ์ด์ง ํธ๋ฆฌ ๊ตฌ์กฐ์ ์ ์ฉํ ์๋ฃ ๊ตฌ์กฐ ์ฐ์ ์์ ํ: ํ(heap) AVL ํธ๋ฆฌ: ๊ท ํ ํธ๋ฆฌ
11.2. ์ฐ์ ์์ ํ
์ฐ์ ์์ ํ ์ผ๋ฐ์ ์ผ๋ก ํ๋ FIFO ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค. ์ฐ์ ์์ ํ๋ ํ์ ๋ค์ด๊ฐ๋ ์์์ ์๊ด์์ด ์ด๋ค ์ฐ์ ์์์ ์ํด ๋๊ฐ๋ ์์๊ฐ ๊ฒฐ์ ๋๋ ํ๋ฅผ ๋งํ๋ค. ์ฐ์ ์์๋ ์์ฉ์ ๋ฐ๋ผ ๋ค๋ฅด๋ฉฐ, ๋ค์ด์ค๋ ์์๊ฐ ๋น ๋ฅผ ์๋ก ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ๊ฒฝ์ฐ์๋ FIFO ํ๋ ์ฐ์ ์์ ํ๋ก ๋ณผ ์ ์๋ค. ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ๋ ๋ฐฉ๋ฒ ๋น์ ๋ ฌ ๋ฆฌ์คํธ
์ ๋ ฌ ๋ฆฌ์คํธ
์ด์ง ๊ฒ์ ํธ๋ฆฌ
enq
O(1)
O(N)
O(log2N)*
deq
O(N)
O(1)
O(log2N)
๋ชจ๋ ์ต์ ์ ๊ฒฝ์ฐ ๋น์ฉ์ด๋ค. *. ํ๊ท ๋น์ฉ์ด๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ํ์ฌ ๋ชจ์ต์ ๋ฐ๋ผ ๋น์ฉ์ด ๋ค๋ฅผ ์ ์๋ค.
6์ฅ์์ ์ดํด๋ณธ ๋ฐ์ ๊ฐ์ด ์ผ๋ฐ์ ์ผ๋ก ํ๋ FIFO ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ค. ํ์ง๋ง ํ์ ์ฝ์ ๋ ์์ ์ ์ํด ๋น ์ ธ๋๊ฐ๋ ์์๋ฅผ ๊ฒฐ์ ํ์ง ์๊ณ , ์ด๋ค ์ฐ์ ์์์ ์ํด ๋๊ฐ๋ ์์๋ฅผ ๊ฒฐ์ ํ ์ ์๋ค. ์ด๋ฐ ํ๋ฅผ ์ฐ์ ์์ ํ(priority queue)๋ผ ํ๋ค. ์ฐ์ ์์ ํ์์ ์ฐ์ ์์๋ ์์ฉ์ ๋ฐ ๋ผ ๋ค์ํ๊ฒ ๊ฒฐ์ ๋ ์ ์์ผ๋ฉฐ, 6์ฅ์์ ๋ฐฐ์ด ์ผ๋ฐ ํ๋ ํ์ ์ฝ์ ๋ ์์์ ์ํด ์ฐ์ ์์
- 143 -
๊ฐ ๊ฒฐ์ ๋๋ ์ฐ์ ์์ ํ์ ํ ์ข ๋ฅ๋ก ๋ณผ ์๋ ์๋ค. ์ฐ์ ์์ ํ๋ ์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ค์ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ๋ ์ ์๋ค. ๊ฐ ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ์์ ๋ ๋น ์ฉ์ ๋น๊ตํ์ฌ ๋ณด์. ์ฐ์ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ ๊ฒฝ์ฐ์๋ enqueue๋ O(1)์ด์ง๋ง
dequeue๋ ํ์ฌ ํ์ ์ ์ฅ๋๋ ์๋ ๋ชจ๋ ์์๋ฅผ ์๋ก ๋น๊ตํ์ฌ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์์ผ ํ๋ฏ ๋ก O(๎ )์ด๋ค. ๋ฐ๋๋ก ์ ๋ ฌ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ ๊ฒฝ์ฐ์๋ enqueueํ ๋ ์ฐ์ ์์์ ๋ฐ๋ผ ์ ๋ ฌ ์ด ๋๋๋ก ์ ์ฅํด์ผ ํ๋ฏ๋ก O(๎ )์ด์ง๋ง dequeue์ ๋น์ฉ์ O(1)์ด๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ์ด ์ฉํ์ฌ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ๋ฉด enqueue์ dequeue ๋ชจ๋ ํ๊ท ์ ์ผ๋ก O(๎ฅ๎จ๎ ๎ต๎ )์ด๋ค. ํ์ง ๋ง ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ์ฝ์ ๋๋ ์์์ ์ํด ํธ๋ฆฌ์ ๋ชจ์ต์ด ๊ฒฐ์ ๋๋ฏ๋ก ์ต์ ์ ๊ฒฝ์ฐ์๋ ์ ํ ๋ฆฌ์คํธ์ ์ฐจ์ด๊ฐ ์์ ์ ์๋ค. ๋ค์ ์ ์์ ๋ฐฐ์ธ ํ์ ์ด๋ฐ ๋จ์ ์ด ์๋ ์ด์ง ํธ๋ฆฌ ํ ํ์ ์๋ฃ๊ตฌ์กฐ์ด๋ค.
11.3. ํ
ํ ํ(heap)์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ด์ฉํ์ฌ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ๋ ์๋ฃ๊ตฌ์กฐ๋ก์, ๋ค์ ๋ ๊ฐ์ง ํน์ฑ์ ๋ง์กฑํด์ผ ํ๋ค. ๋ชจ์ ํน์ฑ: ํน์ฑ ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํด์ผ ํ๋ค. ์์ ํน์ฑ: ํน์ฑ ๊ฐ ๋ ธ๋์ ๊ฐ์ ๊ทธ๊ฒ์ ์์ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ํฌ๊ฑฐ๋ ๊ฐ๋ค. ๋ฐ๋ผ์ ํญ์ ๋ฃจํธ ๋ ธ๋๊ฐ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ฐ์ง๊ฒ ๋๋ค. J
J heap
H
I
D
B
G
C
E
F
I
A
H
F
B
G
C
E
A
D
ํ(heap)์ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ ๋ ๋๋ฆฌ ์ฌ์ฉ๋๋ ์๋ฃ๊ตฌ์กฐ๋ก์ ๋ค์ ๋ ๊ฐ์ง ํน์ฑ์ ๋ง ์กฑํ๋ ์ด์ง ํธ๋ฆฌ ๊ตฌ์กฐ์ด๋ค. ์ฒซ์งธ, ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํด์ผ ํ๋ค. ๋์งธ, ๊ฐ ๋ ธ๋์ ๊ฐ์ ๊ทธ๊ฒ์ ์์ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ํฌ๊ฑฐ๋ ๊ฐ์์ผ ํ๋ค. ์ฒซ ๋ฒ์งธ ํน์ฑ์ ๋ชจ์ ํน์ฑ์ด๋ผ ํ๊ณ , ๋ ๋ฒ์งธ ํน์ฑ์ ์์ ํน์ฑ์ด๋ผ ํ๋ค. ์์ ํน์ฑ ๋๋ฌธ ์ ๋ฃจํธ ๋ ธ๋๊ฐ ํญ์ ๊ฐ์ฅ ํฐ ๊ฐ์ ๊ฐ์ง๊ฒ ๋๋ฉฐ, ๋ชจ์ ํน์ฑ ๋๋ฌธ์ ํธ๋ฆฌ์ ๋์ด๋ ํญ์ ์ต ์ ๋์ด๊ฐ ๋๋ค. ๋ํ ํ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ฌ๋ฆฌ ์ฝ์ ๋๋ ์์์ ์๊ด์์ด ํธ๋ฆฌ์ ๋ชจ์ต ์ ์ผ์ ํ๋ค. ๋ค๋ง, ๋ ธ๋๋ค์ ๊ฐ์ ์ฝ์ ๋๋ ์์์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๋ค.
- 144 -
ํ: dequeue ํ์์ dequeue๋ ํญ์ ๋ฃจํธ๋ฅผ ์ ๊ฑฐํ๊ฒ ๋๋ค. ์ฝ๊ฒ ์ ๊ฑฐํ ์ ์์ง๋ง ํ์ ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํด์ผ ํ๋ฏ๋ก ์์ ์ด์ง ํธ๋ฆฌ๊ฐ ๋๋๋ก ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ํ๋ค. ํธ๋ฆฌ๊ฐ ์์ ์ด์ง ํธ๋ฆฌ๊ฐ ์ ์ง๋๋๋ก ํ๊ธฐ ์ํด์๋ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ์๋ ๋จ๋ง ๋ ธ๋๋ค ์ค์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ ๋ ธ๋๋ฅผ ๋ฃจํธ๋ก ์ฎ๊ฒจ์ผ ํ๋ค. J
D
I
H
F
B
G
C
I
E
A
H
F
D
B
G
E
A
C
ํ: dequeue โ ๊ณ์ ์ด ๊ฒฝ์ฐ ๋ชจ์ ํน์ฑ์ ๋ง์กฑ๋์ง๋ง ์์ ํน์ฑ์ ๋ง์กฑํ์ง ๋ชปํ๋ค. ์์ ํน์ฑ์ด ๋ง์กฑ๋๋๋ก ์์ ๋ ธ๋ ๊ฐ๊ณผ ๊ต์ฒดํด์ผ ํ๋ฉฐ, ์ด๋ฐ ๊ต์ฒด๋ ํธ๋ฆฌ๊ฐ ์์ ํน์ฑ์ ๋ง์กฑํ ๋๊น์ง ๋ฐ๋ณต๋๋ค. ์ด๋ฐ ์ฌ์กฐ์ ์ reheapdown์ด๋ผ ํ๋ค. reheapdown D
I
I
F
B
H
G
C
E
G
A
F
B
H
D
E
A
C
ํ์ ํน์ฑ์ ๋ฃจํธ ๋ ธ๋์ ๊ฐ์ฅ ํฐ ๊ฐ์ด ์์นํ๊ฒ ๋๋ฏ๋ก dequeue๋ ๋ฃจํธ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ฉด ๋๋ค. ํ์ ๋ชจ์ ํน์ฑ๊ณผ ์์ ํน์ฑ์ ์ ์งํด์ผ ํ๋ฏ๋ก ๋ฃจํธ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ์ด ๋จ์ํ์ง ๋ ์๋ค. ์ฐ์ ๋ชจ์ ํน์ฑ์ ์ ์งํ๊ธฐ ์ํด์๋ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ์๋ ๋จ๋ง๋ ธ๋ ์ค์์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ ๋ ธ๋๋ฅผ ๋ฃจํธ ๋ ธ๋๋ก ์ฎ๊ธด๋ค. ์ด๋ ๊ฒ ์ฎ๊ธฐ๋ฉด ๋ชจ์ ํน์ฑ์ ์ ์ง๋์ง๋ง ์ ์ ํน์ฑ์ ๋ง์กฑ๋์ง ๋ชปํ๋ค. ์์ ํน์ฑ์ ๋ง์กฑ์ํค๊ธฐ ์ํด ์์ ๋ ธ๋๋ค๊ณผ ๊ฐ์ ๋น๊ตํ์ฌ ์ ์ ๋ ธ๋์ ์๋ฆฌ๋ฅผ ๋ฐ๊พผ๋ค. ์ด๋ฐ ๋ฐ๊ฟ์ ์์ ํน์ฑ์ด ๋ง์กฑ๋ ๋๊น์ง ๋ฐ๋ณต์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค. ์ด ๊ณผ์ ์ reheapdown์ด๋ผ ํ๋ค. ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ ๋จ๋ง๋ ธ๋๋ฅผ ๋ฃจํธ๋ก ์ฎ ๊ธฐ๋ ๋น์ฉ์ด ์์ ๋น์ฉ์ด๋ฉด ํ์ ๋์ด๋ ํญ์ ๎ฅ๎จ๎ ๎ต๎ ์ด๋ฏ๋ก ํ์์ dequeue์ ์๊ฐ๋ณต์ก๋ ๋ ๋ก๊ทธ ์๊ฐ์ด๋ค.
- 145 -
ํ: enqueue ํ์์ enqueue๋ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํ๊ธฐ ์ํด์๋ ํญ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์ถ๊ฐ๋์ด์ผ ํ๋ค. ์ด๋ ๊ฒ ์ถ๊ฐํ๋ฉด ๋ชจ์ ํน์ฑ์ ๋ง์กฑ๋๋ ์ฝ์ ๋๋ ๊ฐ์ ๋ฐ๋ผ ์์ ํน์ฑ์ ๋ง์กฑ๋์ง ์์ ์ ์๋ค. P
P
L
N
E
B
F
C
K
L
G
A
N
E
B
F
C
A
K
G
M
ํ: enqueue โ ๊ณ์ dequeue์ ๋น์ทํ๊ฒ ์์ ํน์ฑ์ ๋ง์กฑํ๋๋ก ๋ถ๋ชจ์ ๊ฐ์ ๊ต์ฒดํด์ผ ํ๋ค. ์ด๋ฐ ๊ต์ฒด๋ ํธ๋ฆฌ๊ฐ ์์ ํน์ฑ์ ๋ง์กฑํ ๋๊น์ง ๋ฐ๋ณต๋์ด์ผ ํ๋ฉฐ, ์ด๋ฐ ์ฌ์กฐ์ ์ reheapup์ด๋ผ ํ๋ค. reheapup
P
P
L
N
E
B
F
C
A
K
M
M
G
N
E
B
L
C
A
K
G
F
ํ์์ enqueue๋ ๋ชจ์ ์์ ํน์ฑ์ ๋ง์กฑํ๊ธฐ ์ํด ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋๋ก ์ ๋ฐ์ดํฐ๊ฐ ์ถ๊ฐ๋์ด์ผ ํ๋ค. ํ์ง๋ง dequeue์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ด๋ ๊ฒ ํจ์ผ๋ก์จ ๋ชจ์ ํน์ฑ์ ๋ง์กฑํ ์๋ ์์ง๋ง ์์ ํน์ฑ์ ๋ง์กฑํ์ง ๋ชปํ๋ค. ์ด๋ฅผ ์ํด ์ถ๊ฐ๋ ๋ ธ๋๋ฅผ ๋ถ๋ชจ ๋ ธ๋์ ๋น๊ตํ์ฌ ์ถ๊ฐ๋ ๋ ธ๋๊ฐ ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ํฌ๋ฉด ์๋ก ์๋ฆฌ๋ฅผ ๋ฐ๊พผ๋ค. ์ด๋ฐ ๋ฐ๊ฟ์ ์์ ํน์ฑ์ ๋ง์กฑ๋ ๋๊น์ง ๋ฐ๋ณต์ ์ผ๋ก ์ด๋ฃจ์ด์ง๋ค. ์ด ๊ณผ์ ์ reheapup์ด๋ผ ํ๋ค. ๋ฐ๋ผ์ ๋ง์ง๋ง ๋ ๋ฒจ ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋๋ก ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ ๋น์ฉ์ด ์์ ๋น์ฉ์ด๋ฉด enqueue์ ์๊ฐ๋ณต์ก๋ ์ญ์ ๋ก๊ทธ์๊ฐ์ด๋ค.
- 146 -
ํ์ ๊ตฌํ ํ์ ๊ตฌํํ ๋ ํธ๋ฆฌ์ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋๋ฅผ ์ฝ๊ฒ ์ ๊ทผํ ์ ์์ด์ผ ํ๋ฉฐ, ๋ ธ๋์์ ๊ทธ ๋ ธ๋์ ์์ ๋ ธ๋๋ฅผ ์ ๊ทผํ ์ ์์ ๋ฟ๋ง ์๋๋ผ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ ๊ทผํ ์ ์์ด์ผ ํ๋ค. ์ฐ๊ฒฐ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํํ๊ณ ์ ํ๋ฉด ๋ ธ๋๋ฅผ ๋ํ๋ด๋ ์ ๋ณด์ ๋ถ๋ชจ์ ๋ํ ์ฐ๊ฒฐ์ ์ถ๊ฐํด์ผ ํ๋ค. ํ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ํญ์ ์ ์งํ๋ฏ๋ก ์ด๋ ๊ฒ ์ฐ๊ฒฐ๊ตฌ์กฐ๋ก ๊ตฌํํ๋ ๊ฒ๋ณด๋ค ๋ฐฐ์ด๋ก ๊ตฌํํ๋ ๊ฒ์ด ํจ๊ณผ์ ์ด๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ๊ตฌํ์์๋ ๋ถ๋ชจ์ ์์์ ๋ํ ์ฐ๊ฒฐ์ ๋ช ๋ฐฑํ๊ฒ ์ ์งํ์ง ์๋๋ค. ๋์ ์ ๋ ธ๋๊ฐ ์ ์ฅ๋์ด ์๋ ๋ฐฐ์ด์ ์์ธ์ ์ด์ฉํ์ฌ ๋ถ๋ชจ์ ์์ ๋ ธ๋๊ฐ ์ ์ฅ๋์ด ์๋ ๋ฐฐ์ด์ ์์ธ์ ๊ณ์ฐํ ์ ์๋ค.
enqueue์ dequeue์ ์ค๋ช ์์ ์ ์ ์๋ฏ์ด ์ด๋ค ์ฐ์ฐ์ ์๊ฐ๋ณต์ก๋๊ฐ ๋ก๊ทธ์๊ฐ์ด ๋๊ธฐ ์ํด์๋ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋๋ก ์ ๋ ธ๋๋ฅผ ์ถ๊ฐํ๋ ๋น์ฉ์ด ๋ก๊ทธ์๊ฐ์ ๋์ง ์์์ผ ํ๋ค. ๋ํ reheapup์ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋ ธ๋์์ ๊ทธ๊ฒ์ ์์ ๋ ธ๋๋ฅผ ์ ๊ทผํ ์ ์์ ๋ฟ๋ง ์๋๋ผ ๋ ธ๋์์ ๊ทธ๊ฒ์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ ๊ทผํ ์ ์์ด์ผ ํ๋ค. ๋ฐ๋ผ์ 10์ฅ์์ ์ฌ์ฉ๋ ์ฐ๊ฒฐ๊ตฌ์กฐ ๋ฐฉ์์ ์ด์ง ํธ๋ฆฌ๋ ํ์ ๊ตฌํํ๊ธฐ์ ์ ํฉํ์ง ์๋ค. ๋ฌผ ๋ก ๋ ธ๋๋ฅผ ๋ํ๋ด๋ ์ ๋ณด์ ๋ถ๋ชจ์ ๋ํ ์ฐ๊ฒฐ์ ์ถ๊ฐํ๋ฉด ๋์ง๋ง ๋ ธ๋๊ฐ ์ฐจ์งํ๋ ๊ณต๊ฐ์ด ์ปค์ง๋ฉฐ ํธ๋ฆฌ๋ฅผ ์ ์งํ๋ ๋น์ฉ์ด ์ฆ๊ฐํ๋ค. ๊ทธ๋ฐ๋ฐ ํ์ ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํ๋ฏ๋ก ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๋ณด๋ค ํจ์จ์ ์ผ๋ก ๋ํ๋ผ ์ ์๋ค.
0
P
L
E
B
N
F
C
K
G
P
1
L
2
N
3
E
4
F
5
K
6
G
7
B
8
C
๋ถ๋ชจ์ ์์น: (index-1)/2 ์ผ์ชฝ ์์์ ์์น: (index*2)+1 ์ค๋ฅธ์ชฝ ์์์ ์์น: (index*2)+2
๋ฐฐ์ด์ ์ด์ฉํ ์ด์ง ํธ๋ฆฌ์ ํํ์ ํ ๋ ธ๋์์ ์์ ๋ ธ๋๋ค์ ๋ฌผ๋ก ๋ถ๋ชจ ๋ ธ๋๋ ์ฝ๊ฒ ์ ๊ทผํ ์ ์๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์์ ์ด์ง ํธ๋ฆฌ์ ํํ์ ์ค๊ฐ์ ์ฌ์ฉ๋์ง ์๋ ํญ์ด ์๋ค. ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง ๋ ธ๋์ ์์น๋ ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ์๋ฅผ ํตํด ์ป์ ์ ์๋ค.
๋ฐฐ์ด์ ์ด์ฉํ ์ด์ง ํธ๋ฆฌ๋ฅผ ํํํ ๋ ๋ฃจํธ ๋ ธ๋๋ ์์ธ์ด 0์ธ ํญ์ ์์นํ๋ฉฐ, ๊ทธ๊ฒ์ ์ผ์ชฝ ์์์ ์์ธ์ด 1์ธ ํญ์ ์์นํ๊ณ , ์ค๋ฅธ์ชฝ ์์์ ์์ธ์ด 2์ธ ํญ์ ์์นํ๋ค. ์ฆ, ํ ๋ ธ๋๊ฐ ์์ธ์ด i์ธ ํญ์ ์์นํ๋ฉด ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ์์ธ์ด (i-1)/2์ธ ํญ์ ์์นํ๋ฉฐ, ๊ทธ๊ฒ์ ์ผ์ชฝ ์์ ๋ ธ๋๋ ์์ธ์ด (i*2)+1์ธ ํญ์, ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋๋ ์์ธ์ด (i*2)+2์ธ ๋ ธ๋์ ์์นํ๋ค. ์ด๋ ๊ฒ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ์ด์ง ํธ๋ฆฌ๋ฅผ ํํํ๋ฉด ํ ๋ ธ๋์์ ์์ ๋ ธ๋๋ ๋ฌผ๋ก ๋ถ๋ชจ ๋ ธ๋๊น์ง ์ฝ
- 147 -
๊ฒ ์ ๊ทผํ ์ ์๋ค. ๋์ฑ์ด ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ํํํ๋ฉด ์ค๊ฐ์ ๋น ํญ๋ค์ด ์กด์ฌํ์ง ์๊ฒ ๋๋ค. ๋ํ ํธ๋ฆฌ์ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋์ ์์น๋ ํธ๋ฆฌ์ ์ ๋ ๋ ธ๋์ ์๋ฅผ ํตํด ์ฝ๊ฒ ์ ์ ์๋ค.
ํ์ ๊ตฌํ: PriorityQueue, Heap
public interface PriorityQueue{ boolean isEmpty(); boolean isFull(); void enq(Object item); Object deq(); }
public class Heap implements PriorityQueue{ private static final int MAX_HEAP_SIZE = 50; private Object[] elements; private int lastIndex = -1; public Heap(){ setup(MAX_HEAP_SIZE); } public Heap(int capacity){ if(capacity>0) setup(capacity); else setup(MAX_HEAP_SIZE); } private void setup(int capacity){ elements = new Object[capacity]; } public boolean isEmpty(){ return (lastIndex == -1); } public boolean isFull(){ return (lastIndex == elements.length-1); } โฆ }
Enqueue public void enq(Object item) throws QueueOverflowException{ if(isFull()) throw new QueueOverflowException(โโฆโ); if(item==null) throw new NullPointerException(โโฆโ); Comparable o = (Comparable)item; lastIndex++; reheapUp(o); } private void reheapUp(Comparable item){ int hole = lastIndex; int parent = (hole-1)/2; while((hole>0) && (item.compareTo(elements[parent])>0)){ elements[hole] = elements[parent]; hole = parent; parent = (hole-1)/2; } L elements[hole] = item; }
P
N
E
B
F
C
A
K
hole
G
M
item
enqueue๋ ์์ ์ค๋ช ํ ๋ฐ์ ๊ฐ์ด ์ฐ์ ๋ชจ์ ํน์ฑ์ ๋ง์กฑํ๊ธฐ ์ํด ์ ๋ ธ๋๋ฅผ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋๊ฐ ๋๋๋ก ์ถ๊ฐํด์ผ ํ๋ค. ๋ฐฐ์ด์ ์ด์ฉํ ์ด์ง ํธ๋ฆฌ ๊ตฌ ํ์์ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋์ ์์น๋ ํธ๋ฆฌ์ ์๋ ๋ ธ๋์ ๊ฐ์๋ฅผ ํตํด ์ ์ ์๋ค. ์ด ๊ตฌํ์์๋ lastIndex ๋ฉค๋ฒ๋ณ์๊ฐ ์ด ์ ๋ณด๋ฅผ ์ ์งํ๊ณ ์๋ค. ์ฐ์ ์ด ๊ฐ์ ํ๋ ์ฆ๊ฐ์ํค๊ณ , ์ด ์์น์ ๋น ๋ ธ๋๋ฅผ ์ฝ์ ํ๋ค. ๊ทธ ๋ค์์ reheapup ๊ณผ์ ์ ์ํํ์ฌ ์์ ํน ์ฑ์ด ๋ง์กฑ๋๋๋ก ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ํ๋ค. ๋ถ๋ชจ ๋ ธ๋์ ๋น๊ตํ์์ ๋ ๋ถ๋ชจ ๋ ธ๋๋ณด๋ค ์ถ๊ฐ ํ ๊ฐ์ด ์์ผ๋ฉด ๋น ๋ ธ๋์ ๊ฐ์ ์ถ๊ฐํ๋ ๊ฒ์ผ๋ก enqueue๊ฐ ์๋ฃ๋๋ค. ํ์ง๋ง ๋ถ๋ชจ ๋ ธ๋๋ณด ๋ค ์ถ๊ฐํ ๊ฐ์ด ํฌ๋ฉด ๋น ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋์ ๊ฐ์ ์ฎ๊ธฐ๊ณ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ๋น ๋ ธ๋๋ก ๋ง๋ ๋ค. ์ด ๊ณผ์ ์ ์์ ํน์ฑ์ด ๋ง์กฑ๋ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
- 148 -
Dequeue public Object deq() throws QueueUnderflowException{ if(isEmpty()) throw new QueueUnderflowException(โโฆโ); Comparable toMove = (Comparable)elements[lastIndex]; Object tmp = elements[0]; lastIndex--; reheapDown(toMove); return tmp; } private void reheapDown(Comparable item){ int hole = 0; int nextHole; nextHole = findNextHole(hole, item); while(nextHole != hole){ elements[hole] = elements[nextHole]; hole = nextHole; nextHole = findNextHole(hole, item); } elements[hole] = item; }
Dequeue
hole nextHole M
N
E
B
L
C
A
K
G
F
private int findNextHole(int hole, Comparable item){ int left = hole*2+1; int right = hole*2+2; Comparable leftChild = null; // hole์ด ์์์ด ์๋ ๊ฒฝ์ฐ if(left>lastIndex){ return hole; } // hole์ด ์ผ์ชฝ ์์๋ฐ์๋ ์๋ ๊ฒฝ์ฐ else if(left==lastIndex){ if(item.compareTo(elements[left])>0) return hole; else return left; } // hole์ด ์ผ์ชฝ, ์ค๋ฅธ์ชฝ ์์์ด ๋ชจ๋ ์๋ ๊ฒฝ์ฐ else{ leftChild = (Comparable)elements[left]; if(leftChild.compareTo(elements[right])>0){ if(item.compareTo(leftChild)>0) return hole; else return left; } else{ if(item.compareTo(elements[right])>0) return hole; else return right; } } }
dequeue๋ enqueue๋ณด๋ค ์กฐ๊ธ ๋ ๋ณต์กํ๋ค. ์ฐ์ lastIndex ์ ๋ณด๋ฅผ ์ด์ฉํ์ฌ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ๋ฒจ์ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ๋จ๋ง๋ ธ๋์ ๊ฐ์ ๋ฃจํธ ๋ ธ๋๋ก ์ฎ๊ธฐ๊ณ ์ด ๋ ธ๋๋ฅผ ์ญ์ ํ๋ค. ์ด ์ญ์ ๋ lastIndex ๊ฐ์ ํ๋ ๊ฐ์ํ๋ฉด ๋๋ค. ๊ทธ ๋ค์ ์์ ํน์ฑ์ด ๋ง์กฑ๋๋๋ก reheapdown์ ํด์ผ ํ๋ค. reheapup์ ํ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ต๋ ๋ฃจํธ๊น์ง ์ฌ๋ผ๊ฐ๋ฉด ๋์ง๋ง reheapdown์ ํ์ฌ ๋ ธ๋๊ฐ ๋ ๊ฐ์ ์์ ๋ ธ๋์ ๊ฐ์ง ์ ์์ผ๋ฏ๋ก ๊ฐ ์์๋ค๊ณผ ๋น๊ตํ์ฌ ์ด ์ค์ ๋ณด๋ค ํฐ ๊ฐ๊ณผ ๊ต์ฒด๋์ด์ผ ํ๋ค. ์ด๋ค ์์๊ณผ ๊ต์ฒดํ ์ง๋ findNextHole ๋ฉ์๋๋ฅผ ํตํด ๊ฒฐ์ ํ๋ค.
- 149 -
ํ VS. ๋ค๋ฅธ ์ฐ์ ์์ ํ ๊ตฌํ ์ด์ง ๊ฒ์ ํธ๋ฆฌ
ํ
์ ๋ ฌ๋ฆฌ์คํธ (์ฐ๊ฒฐ๊ตฌ์กฐ)
๊ท ํ
ํธํฅ
enq
O(log2N)
O(N)
O(log2N)
O(N)
deq
O(log2N)
O(1)
O(log2N)
O(N)
์ด์ง ๊ฒ์ ํธ๋ฆฌ๊ฐ ๊ท ํํธ๋ฆฌ์ผ ๊ฒฝ์ฐ์๋ ํ๊ณผ ์ฑ๋ฅ์ด ๊ฐ๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ์ฝ์ ๋๋ ์์์ ๋ฐ๋ผ ์ต์ ์ ๊ฒฝ์ฐ์๋ ํธํฅ ํธ๋ฆฌ๊ฐ ๋ ์ ์๋ค. ํ์ง๋ง ํ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ฌ๋ฆฌ ํญ์ ๋น์ฉ์ด ์ผ์ ํ๋ค.
ํ์ ์ด์ฉํ ์ฐ์ ์์ ํ๋ ์์๋ค์ด ํ์ ์ฝ์ ๋ ์์์ ์๊ด์์ด ํญ์ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ์ ์งํ๋ฏ๋ก enqueue์ dequeue ์ฐ์ฐ์ ์๊ฐ๋ณต์ก๋๋ ๋ก๊ทธ ์๊ฐ์ด๋ค.
11.4. AVL ํธ๋ฆฌ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ๋ ธ๋๋ค์ด ์ฝ์ ๋ ์์์ ์ํด ํธ๋ฆฌ์ ๋ชจ์ต์ด ๊ฒฐ์ ๋๋ฏ๋ก ๋งค์ฐ ํ์ชฝ ๋ฐฉํฅ ์ผ๋ก ํธํฅ๋ ์ ์๋ค. ์ด๊ฒ์ด ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๊ฐ์ฅ ํฐ ๋จ์ ์ด๋ค. ์ด ๋จ์ ์ ๊ทน๋ณตํ๊ธฐ ์ ํด ํธ๋ฆฌ์ ๊ท ํ์ ์ฃผ๊ธฐ์ ์ผ๋ก ๋ง์ถ ์ ์์ง๋ง ๊ท ํ์ ๋ง์ถ๋ ๋น์ฉ์ด ๋งค์ฐ ๋น์ธ๋ค. AVL ํธ ๋ฆฌ๋ ์ด๋ฐ ๋จ์ ์ ๊ทน๋ณตํ ์ ์๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ด๋ค.
AVL ํธ๋ฆฌ(๊ท ํํธ๋ฆฌ) AVL(AdelsonAVL(Adelson-Velskii and Landis) ํธ๋ฆฌ: ํธ๋ฆฌ ๊ฐ ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ฐจ์ด๊ฐ 1์ดํ์ธ ์ด์ง ๊ฒ์ ํธ๋ฆฌ ๊ท ํ์ ์ ๋ ดํ ๋น์ฉ์ผ๋ก ํญ์ ์ ์งํ ์ ์๋ค๋ฉด ๊ธฐ๋ณธ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ฌธ์ ์ ์ ํด์ํ ์ ์๋ค. ์ด์ง ํธ๋ฆฌ์ ํ ๋ ธ๋๊ฐ AVL ์ฑ์ง์ ๋ง์กฑํ๋์ง ๊ฒ์ฌํ๋ ๋ฐฉ๋ฒ ๊ฐ์ฅ ๊ธด ์ผ์ชฝ ๊ฒฝ๋ก์ ๊ธธ์ด์ ๊ฐ์ฅ ๊ธด ์ค๋ฅธ์ชฝ ๊ฒฝ๋ก์ ๊ธธ์ด๋ฅผ ๋น๊ต ๋ ๊ฒฝ๋ก์ ์ฐจ์ด๋ฅผ ๊ท ํ ์ธ์(balance factor)๋ผ ํ๋ค. ์ธ์ 2
60
45
1
63
60
45
0 41
55
61
41 non AVL Tree
AVL Tree
AVL ํธ๋ฆฌ๋ ๊ฐ ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด์ ์ฐจ์ด๊ฐ 1์ดํ์ธ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ๋งํ๋ฉฐ, ๋ฌ์์ ์ํ์ Adelson-Velskii์ Landis์ ์ํด ๊ณ ์๋์๋ค. ์ด์ง ํธ๋ฆฌ์ ํ ๋ ธ๋๊ฐ AVL ์ฑ์ง์ ๋ง์กฑํ๋์ง ๊ฒ์ฌํ๊ธฐ ์ํด์๋ ๊ทธ ๋ ธ๋์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋จ๋ง๋ ธ๋๊น์ง ๊ฐ์ฅ ๊ธด ๊ฒฝ๋ก์ ๊ธธ์ด์ ๊ทธ ๋ ธ๋์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๋จ๋ง๋ ธ๋๊น์ง ๊ฐ์ฅ ๊ธด
- 150 -
๊ฒฝ๋ก์ ๊ธธ์ด๋ฅผ ๋น๊ตํด์ผ ํ๋ค. ์ด ๋ ๊ฒฝ๋ก์ ์ฐจ์ด๋ฅผ ๊ท ํ์ธ์(balance factor)๋ผ ํ๋ฉฐ, ์ด ๊ฐ ์ด -1์์ 1 ์ฌ์ด์ ๊ฐ์ด์ด์ผ ํ๋ค. ๋ฐ๋ผ์ AVL ํธ๋ฆฌ์ ๋์ด๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ์ต์ ๋ ์ด์ ํญ์ ์ผ์นํ์ง๋ ์์ง๋ง ์ต์ ๋์ด์ ๊ฑฐ์ ๊ทผ์ ํ ๋์ด๋ก ์ ์ง๋๋ค.
AVL ํธ๋ฆฌ: ์ฝ์ ์ฝ์ ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ฝ์ ๊ณผ ๊ฐ๋ค. ๊ทธ๋ฌ๋ ์ฝ์ ์ด AVL ํธ๋ฆฌ์ ์ฑ์ง์ ๋ง์กฑํ์ง ๋ชปํ๋ฉด ํธ๋ฆฌ์ ๊ท ํ์ด ๊นจ์ง ์ ์๋ค. ํต์ฌ. ๋ฃจํธ์์ ์ฝ์ ๋ ์์น๊น์ง์ ๊ฒฝ๋ก์ ์๋ ๋ ธ๋๋ค๋ง ๊ท ํ ์ธ์๊ฐ ๋ณ๊ฒฝ๋ ์ ์๋ค. ์ด ๋ ธ๋๋ค์ ๋ถ๋ถ ํธ๋ฆฌ๋ง ๋ณ๊ฒฝ๋๋ค. ์ฌ๊ท ํ์ ์ฝ์ ๋ ์์น๋ถํฐ ๋ฃจํธ๊น์ง์ ๊ฒฝ๋ก๋ฅผ ๋ฐ๋ผ ์ฌ๋ผ๊ฐ๋ฉด์ ๊ท ํ ์ธ์๋ฅผ ๊ฐฑ์ ํ๋ค. ๊ฐฑ์ ํ๋ ๋์ค์ AVL ์ฑ์ง์ ์๋ฐฐํ๋ ๋ ธ๋๋ฅผ ๋ง๋๋ฉด ์ด ๋ ธ๋์ ๋ถ๋ถํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํ๋ค. ํ๋ฒ ์ฌ์กฐ์ ์ ํ๋ฉด ๊ทธ๊ฒ์ผ๋ก ํธ๋ฆฌ๋ ๋ค์ AVL ์ฑ์ง์ ๋ง์กฑํ๋ค. ์ด๊ฒ์ ์ฝ์ ๋๊ธฐ ์ ์ ํธ๋ฆฌ๋ AVL ์ฑ์ง์ ๋ง์กฑํ๊ณ ์์๊ณ , ์ฝ์ ๋ ํ์ ๋ ธ๋๋ค์ ๊ท ํ ์ธ์ ๊ฐ์ ์ต๋ ํ๋ ์ฆ๊ฐํ๊ฑฐ๋ ํ๋ ๊ฐ์ํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
AVL ํธ๋ฆฌ์์ ์ฝ์ ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ฝ์ ๊ณผ ๊ฐ๋ค. ๊ทธ๋ฌ๋ ์ด๋ ๊ฒ ์ฝ์ ์ ํ์์ ๋ AVL ํธ๋ฆฌ์ ์ฑ์ง์ด ๊ณ์ ์ ์ง๋์ง ์์ ์ ์๋ค. ์ด ๊ฒฝ์ฐ์๋ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ํ๋ค. ์ด ์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ์ค๋ช ํ ๋ ๊ธฐ์ ๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ฅผ ์ ์ฒด์ ์ผ๋ก ์ฌ์กฐ์ ํด์ ์์ ์ด์ง ํธ๋ฆฌ ๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ ์ฌ์กฐ์ ํ๋ค๋ ๊ฒ์ ์๋๋ค. ์ฌ๊ธฐ์์ ์ฌ์กฐ์ ์ ๋ถ๋ถ์ ์ผ๋ก๋ง ์ ๋ ดํ ๋น์ฉ์ผ๋ก ์ฌ์กฐ์ ํ์ฌ ์์ ์ด์ง ํธ๋ฆฌ๋ฅผ ๋ง๋ค์ง๋ ์์ง๋ง ์์ ์ด์ง ํธ๋ฆฌ์ ๊ฐ๊น์ด ํธ๋ฆฌ๋ฅผ ๋ง๋ค์ด ๋์ค์ ๊ฒ์ํ ๋ ํจ์จ์ฑ์ ๋์ด๊ฒ ๋ค๋ ๊ฒ์ ๋งํ๋ค. ํ ๋ ธ๋๊ฐ ์ฝ์ ๋์์ ๋ ๊ทธ ๋ ธ๋๋ถํฐ ๋ฃจํธ ๋ ธ๋๊น์ง์ ๊ฒฝ๋ก ์์ ์๋ ๋ ธ๋๋ค๋ง ๊ท ํ์ธ์ ๊ฐ ๋ณ๊ฒฝ๋ ์ ์๋ค. ์ด๊ฒ์ ์ด๋ค๋ง ์์ ๋ค์ ๋ถ๋ถ ํธ๋ฆฌ๊ฐ ๋ณ๊ฒฝ๋๊ธฐ ๋๋ฌธ์ด๋ค. ๊ท ํ์ ๋ค์ ๋ง์ถ๊ธฐ ์ํด์๋ ์ฝ์ ํ ๋ ธ๋๋ถํฐ ๋ฃจํธ๊น์ง์ ๊ฒฝ๋ก๋ฅผ ๋ฐ๋ผ ์ฌ๋ผ๊ฐ๋ฉด์ ๊ท ํ์ธ์๋ฅผ ๊ฐฑ์ ํ ๋ค. ๊ฐฑ์ ๋์ค์ AVL ์ฑ์ง์ ์๋ฐฐํ๋ ๋ ธ๋๋ฅผ ๋ง๋๋ฉด ์ด ๋ ธ๋์ ๋ถ๋ถ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํ๋ค. ์ด๋ ๊ฒ ํ๋ฒ ์ฌ์กฐ์ ์ ํ๊ฒ ๋๋ฉด ํธ๋ฆฌ๋ ๋ค์ AVL ์ฑ์ง์ ๋ง์กฑํ๊ฒ ๋๋ค. ์ด๊ฒ์ ์ฝ์ ๋๊ธฐ ์ ์ ํธ๋ฆฌ๊ฐ AVL ์ฑ์ง์ ๋ง์กฑํ๊ณ ์์์ผ๋ฏ๋ก ํ ๋ ธ๋๊ฐ ์ฝ์ ๋๋ฉด ๋ค๋ฅธ ๋ ธ๋๋ค์ ๊ท ํ์ธ์ ๊ฐ์ ์ต๋ ํ๋ ์ฆ๊ฐ๋๊ฑฐ๋ ํ๋ ๊ฐ์๋๋ค. ๋ฐ๋ผ์ ์ฝ์ ๋ ๋ ธ๋๋ก๋ถํฐ ๋ฃจํธ๊น์ง ์ฌ๋ผ๊ฐ๋ฉด์ ์ฒ์ ๊ท ํ์ด ์๋ฐฐ๋ ๋ ธ๋๋ฅผ ์ฌ์กฐ์ ํ๋ฉด ๋๋จธ์ง ๋ ธ๋๋ค์ ๊ท ํ์ธ์๋ ์ฝ์ ์ ๊ณผ ๊ฐ์์ง๋ค.
- 151 -
AVL ํธ๋ฆฌ: ์ฝ์ โ ๊ณ์ ๋ถ๋ถ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ํ๋ ๋ ธ๋ x๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฝ์ ๋ ๋ ธ๋์ ์์น๋ ๋ค์ ๋ค ๊ฐ์ง๋ก ๋ถ๋ฅํ ์ ์๋ค. LL: x์ ์ผ์ชฝ ์์์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์ฝ์ ๋ ๊ฒฝ์ฐ RR: x์ ์ค๋ฅธ์ชฝ ์์์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์ฝ์ ๋ ๊ฒฝ์ฐ LR: x์ ์ผ์ชฝ ์์์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์ฝ์ ๋ ๊ฒฝ์ฐ RL: x์ ์ค๋ฅธ์ชฝ ์์์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์ ์ฝ์ ๋ ๊ฒฝ์ฐ 2
2
-2 A
A -1
1 B C
RR
A 1
-1 B
B
LL
-2 A
C
B C
C RL
LR
ํธ๋ฆฌ์ ๊ท ํ์ ๋ง์ถ๊ธฐ ์ํด ๋ถ๋ถ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฝ์ ๋ ๋ ธ๋์ ์์น๋ ํฌ๊ฒ LL, RR, LR, RL ๋ค ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋ถ๋ฅํ ์ ์๋ค.
LL, RR ํ์ ํธ๋ฆฌ์ ๊ท ํ์ ๋ ธ๋๋ค์ ํ์ (rotate)ํ์ฌ ๋ง์ถ๋ค. ํ์ LL๊ณผ RR์ ๊ฒฝ์ฐ์๋ ๋จ์ผ ํ์ ์ผ๋ก ๊ท ํ์ ๋ง์ถ ์ ์์ง๋ง LR๊ณผ RL์ ๊ฒฝ์ฐ์๋ ์ด์ค ํ์ ์ ํด์ผ ๊ท ํ์ ๋ง์ถ ์ ์๋ค. 2
0
A
A
1
-1
A
T3 T1
T2
T1
B 0
0 B
0
-2
B
B
A
T1 T2
T3
LL Rotate
T2
T3
T1
T2
T3
RR Rotate
ํธ๋ฆฌ์ ๊ตฐํ์ ๋ ธ๋๋ค์ ํ์ ํ์ฌ ๋ง์ถ๋ค. ์ฝ์ ๋ ๋ ธ๋์ ์์น์ ๊ทธ๊ฒ์ ์กฐ์ ๋ ธ๋ ์ค์ ์ฒ ์์ผ๋ก ๊ท ํ์ธ์๊ฐ -2 ๋๋ 2๊ฐ ๋ ๋ ธ๋์ ์์น์ ๋ฐ๋ผ LL, RR, LR, RL ํ์ ์ ํ๋ค. ์ฝ์ ๋ ๋ ธ๋์ ์กฐ์ ๋ ธ๋๋ค ์ค์ ์ฝ์ ์ ์ํด ์ฒ์์ผ๋ก ๊ท ํ์ธ์๊ฐ -2 ๋๋ 2๊ฐ ๋ ๋ ธ๋๋ฅผ ํ์ ์ ๊ธฐ์ค ๋ ธ๋๋ผ ํ๋ค. ์ด ๋ LL๊ณผ RR์ ๋จ์ผ ํ์ ์ผ๋ก ๊ท ํ์ ๋ง์ถ ์ ์์ง๋ง LR๊ณผ RL์ ๋ ๋ฒ ํ์ ์ด ํ์ํ๋ฏ๋ก ์ด์ค ํ์ ์ด ํ์ํ๋ค๊ณ ๋งํ๋ค. LL๊ณผ RR์ ๊ธฐ์ค ๋ ธ๋์ ์์ ์ค ์๋ก ์ฝ์ ๋ ๋ ธ๋์ ์กฐ์ ๋ ธ๋๊ฐ ๋๋ ๋ ธ๋๋ฅผ ๊ธฐ์ค ๋ ธ๋ ์๋ฆฌ๋ก ๋์ด์ฌ๋ฆฌ๊ณ ๊ธฐ์ค ๋ ธ๋๋ ๋ฐ ๋ ๋ฐฉํฅ์ผ๋ก ๋ด๋ฆฐ๋ค.
- 152 -
LR ํ์ 2
2
A
2 A
A
-1
-1 B
-1 B
1
B -1 C
C
C T4 T1
T2
T3
0
0
0
C
C 0
0 B
T4 T1
T3
T2
C
0
A
1
-1 B
T1
A
T3
T2
0 B
T4
A
T2
T1
T3
T4
LR ํ์ ์ ์ฒ์์ผ๋ก ๊ท ํ์ธ์๊ฐ 2๊ฐ ๋ ๋ ธ๋๋ฅผ ํฌํจํ์ฌ ๊ทธ ๋ ธ๋๋ถํฐ ์ฝ์ ๋ ๋ ธ๋๊น์ง ๊ฒฝ ๋ก์ ์๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ๊ฐ์ ํ์ ๋ ธ๋๋ค์ด ํ์ ์ ์ฐธ์ฌํ๊ฒ ๋๋ค. ๊ธฐ์ค ๋ ธ๋๋ฅผ A ๋ ธ๋ ๋ผ ํ๊ณ ๋ ๊ฐ์ ํ์ ๋ ธ๋๋ค์ ์ฐจ๋ก๋๋ก B์ C ๋ ธ๋๋ผ ํ๋ฉด, ์ด ๋ถ๋ถ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํ์ ์ ๋ ๋ฃจํธ๋ C๊ฐ ๋๊ณ , C์ ์ผ์ชฝ ์์์ B, ์ค๋ฅธ์ชฝ ์์์ A ๋ ธ๋๊ฐ ๋๋ค. ๋ํ C ๋ ธ๋์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๋ B ๋ ธ๋์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๊ฐ ๋๊ณ , C์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ A์ ์ผ์ชฝ ๋ถ ๋ถํธ๋ฆฌ๊ฐ ๋๋ค.
RL ํ์ -2
-2
-2
A
A
A
1 1
1
B
B
-1
B 1
C
C
C T1
T1 T2
T4 T3
T2 0
0
0
C
C 0
0 A
T4
T3
C
1
B
0 A
T1
0
B
T2
T3
-1 A
T4
T1
B
T2
T3
T4
RL ํ์ ์ LR ํ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ฒ์์ผ๋ก ๊ท ํ์ธ์๊ฐ -2๊ฐ ๋ ๋ ธ๋๋ฅผ ํฌํจํ์ฌ ๊ทธ ๋ ธ๋๋ถ ํฐ ์ฝ์ ๋ ๋ ธ๋๊น์ง ๊ฒฝ๋ก์ ์๋ ๊ฐ์ฅ ๊ฐ๊น์ด ๋ ๊ฐ์ ํ์ ๋ ธ๋๋ค์ด ํ์ ์ ์ฐธ์ฌํ๊ฒ ๋ ๋ค. ๊ธฐ์ค ๋ ธ๋๋ฅผ A ๋ ธ๋๋ผ ํ๊ณ ๋ ๊ฐ์ ํ์ ๋ ธ๋๋ค์ ์ฐจ๋ก๋๋ก B์ C ๋ ธ๋๋ผ ํ๋ฉด, ์ด ๋ถ๋ถ ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํ์์ ๋ ์ด ํ์ ์ญ์ C๊ฐ ๋ฃจํธ๊ฐ ๋๊ณ , C์ ์ผ์ชฝ ์์์ A, ์ค๋ฅธ์ชฝ ์์์ B ๋ ธ๋๊ฐ ๋๋ค. ๋ํ C ๋ ธ๋์ ์ผ์ชฝ ๋ถ๋ถํธ๋ฆฌ๋ A ๋ ธ๋์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๊ฐ ๋ ๊ณ , C์ ์ค๋ฅธ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ B์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ๊ฐ ๋๋ค.
- 153 -
AVL ํธ๋ฆฌ๋ฅผ ๊ตฌํํ ๋ ๋ ธ๋๋ฅผ ์ฝ์ ํ ํ์ ๋ฃจํธ ๋ ธ๋๊น์ง ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋ฉด์ ๊ท ํ์ธ์ ๊ฐ ์ ์กฐ์ ํด์ผ ํ๋ค. ๋ฐ๋ผ์ ๋ถ๋ชจ๋ ธ๋์ ๋ํ ์ฐ๊ฒฐ์ด ํ์ํ๋ค. ์ด๋ฅผ ์ํด ๋ถ๋ชจ๋ ธ๋์ ๋ํ ์ฐ๊ฒฐ์ ๋ ธ๋๋ฅผ ๋ํ๋ด๋ ์ ๋ณด์ ์ถ๊ฐํ ์ ์์ง๋ง ์ ์งํด์ผ ํ๋ ์ ๋ณด๊ฐ ์ฆ๊ฐ๋๋ฏ๋ก ๊ฐ์ข ์ฐ์ฐ๋ค์ด ๋ณต์กํด์ง๋ ๋ฌธ์ ์ ์ด ์๋ค. ์ด๊ฒ์ ๊ทน๋ณตํ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ฝ์ ์ ํ๊ธฐ ์ํด ๋จ ๋ง๋ ธ๋๋ฅผ ์ฐพ์๊ฐ ๋ ์คํ์ ๋ฐฉ๋ฌธํ ๋ ธ๋๋ค์ pushํ๋ ๊ฒ์ด๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์คํ์ top์๋ ํญ์ ํ์ฌ ๋ ธ๋์ ๋ถ๋ชจ ๋ ธ๋๊ฐ ์ ์ฅ๋์ด ์๊ฒ ๋๋ค.
AVL ํธ๋ฆฌ: ์ฝ์ ์ -1
1
15
0
15
-2
2
2
10
45
7
0
10
1
45
15
30
45
30
LR
2 15
5
1 15
2
30
30
15
1 0
5
0
LL
2
0
0 45
5
0
30 0
0 45
5
0 -1
15
-1
45
5
RR
15
30
1
0 30 15
2
30
0
5 5
0 15
2
2 2
30
30
10
10
45
45
45 7
12
AVL ํธ๋ฆฌ์ ์ฝ์ ์ฐ์ฐ์ ๊ตฌํํ ๋ ์ฃผ์ํด์ผ ํ๋ ์ ์ ๋ค์๊ณผ ๊ฐ๋ค. ์ฒซ์งธ, ์ฝ์ ๋ ๋จ๋ง๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ํญ์ ๋ณํ๋ค. ๋์งธ, ์ฝ์ ๋ ๋ ธ๋๋ถํฐ ๋ฃจํธ๋ ธ๋๊น์ง ์ฌ๋ผ๊ฐ๋ฉด ๊ท ํ์ธ์๋ฅผ ๋ณ๊ฒฝํ ๋ ์ด๋ค ๋ ธ๋์ ๊ท ํ ์ธ ์ ๊ฐ์ด ๋ณ๊ฒฝ๋์ด 0์ด ๋๋ฉด ๊ทธ ์ดํ์ ์กฐ์๋ ธ๋๋ค์ ๊ท ํ์ธ์๋ ๋ณํ์ง ์๋๋ค. ์ ์์ ์ ์ 12๋ฅผ ์ฝ์ ํ์์ ๋ 10 ๋ ธ๋์ ๊ท ํ์ธ์ ๊ฐ์ 1์์ 0์ ๋ณ๊ฒฝ๋๋ค. ํ์ง๋ง ๊ทธ ์ดํ ์กฐ ์ ๋ ธ๋๋ค์ ๊ท ํ์ธ์๋ ๋ณํ์ง ์๋๋ค.
AVL ํธ๋ฆฌ: ์ฝ์ ์ โ ๊ณ์ 2 1
15
10 0
15
-2 5
RL
30
0 15
1
0
7 7
30
1 2
10
45
5 5
-1
10
8
12
30
45 15 2
7
12
14
2 2
8
12
-1 7
30
8
-1 5
2
10
8
45
12
14
- 154 -
LR
45
AVL ํธ๋ฆฌ: ์ญ์ ์ญ์ ๋ ์ผ๋ฐ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ญ์ ๋ฅผ ๋จผ์ ์ํํ๋ค. ์ญ์ ๋ ์ฝ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก AVL ํธ๋ฆฌ์ ์ฑ์ง์ ์๋ฐฐํ ์ ์๋ค. ์ฝ์ ์ ๊ฒฝ์ฐ์๋ ์ฒซ ๋ฒ์งธ ์๋ฐฐ๋ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ์กฐ์ ํ๋ฉด ์ ์ฒด ํธ๋ฆฌ์ ๊ท ํ์ด ์ด๋ฃจ์ด์ง์ง๋ง ์ญ์ ์ ๊ฒฝ์ฐ๋ ํ๋ฒ ์ฌ์กฐ์ ์ ํ์ฌ๋ ์ฌ์ ํ ํธ๋ฆฌ๊ฐ AVL ํธ๋ฆฌ์ ์ฑ์ง์ ์๋ฐฐํ ์ ์๋ค. ๋ฐ๋ผ์ ๋ฃจํธ๊น์ง ๊ณ์ ๊ฒ์ฌํ๋ฉด์ ์ฌ๋ฌ ๋ฒ ์ฌ์กฐ์ ํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ๋จ๋ง๋ ธ๋๊ฐ ์ญ์ ๋ ์ญ์ ๊ฒฝ์ฐ์๋ ์ญ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ๊น์ง์ ๊ฒฝ๋ก์ ์๋ ๋ ธ๋๋ค๋ง ๊ท ํ ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ๋ค. ์์์ด ํ๋์ธ ์ค๊ฐ๋ ธ๋๊ฐ ์ญ์ ๋ ์ญ์ ๊ฒฝ์ฐ์๋ ์ญ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ๊น์ง ๊ท ํ ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ๋ค. ์์์ด ๋์ธ ์ค๊ฐ ๋ ธ๋๊ฐ ์ญ์ ๋ ์ญ์ ๊ฒฝ์ฐ์๋ ์ค๊ฐ๋ ธ๋์ ๋์ฒด๋๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ๊น์ง ๊ท ํ ์ฌ๋ถ๋ฅผ ๊ฒ์ฌํ๋ค.
AVL ํธ๋ฆฌ์์ ์ญ์ ๋ ์ฝ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋จผ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ญ์ ๋ฅผ ์ํํ๋ค. ๊ทธ ๋ค ์์ ์ญ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ก๋ถํฐ ๋ฃจํธ๋ ธ๋๊น์ง ๊ฒฝ๋ก์ ์๋ ๊ท ํ์ธ์๋ฅผ ๊ฒํ ํ์ฌ ๊ท ํ์ด ์๋ฐฐ๋์์ผ๋ฉด ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํ๋ค. ์์์ ๋์ธ ์ค๊ฐ๋ ธ๋์ ์ญ์ ์ ๊ฒฝ์ฐ์๋ ์ค์ ์ญ์ ๋ ๋จ ๋ง์์ ์ด๋ฃจ์ด์ง๋ฏ๋ก ์ด ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๊ท ํ ์ธ์๋ฅผ ๊ฒํ ํด์ผ ํ๋ค. ์ญ์ ๋ ์ฝ์ ๊ณผ ๋ฌ๋ฆฌ ํ๋ฒ ์ฌ์กฐ์ ์ ํ๋ ๊ฒ์ผ๋ก ์๋ฃ๋์ง ์์ ์ ์๋ค. ์ฆ, ๊ท ํ์ ์๋ฐฐ๋์ด ๊ท ํ์ ์ฌ์กฐ ์ ํ๋ฉด ๊ทธ ๋ ธ๋๊ฐ ๋ฃจํธ๊ฐ ๋๋ ๋ถ๋ถํธ๋ฆฌ์ ๋์ด๊ฐ ํ๋ ๊ฐ์ํ๋ฉฐ, ์ด ๊ฐ์๋ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์์ ์ํฅ์ ์ค๋ค. ๋ฐ๋ผ์ ๋ฃจํธ ๋ ธ๋๊น์ง ์ฌ๋ผ๊ฐ๋ฉด์ ํธ๋ฆฌ๋ฅผ ์ฌ๋ฌ ๋ฒ ์ฌ์กฐ์ ํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ ์ ์๋ค.
AVL ํธ๋ฆฌ: ์ญ์ โ ๊ณ ๋ ค์ฌํญ1 ์ญ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ ๋ ธ๋๊น์ง ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋ฉด์ ๊ท ํ์ธ์๋ฅผ ์ฌ์กฐ์ ํ ๋ ๋ค์์ ๊ณ ๋ คํ๋ค. ๊ฒฝ์ฐ 1. ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 0์ผ๋ก ๋ฐ๋๋ฉด ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ๋ณ๊ฒฝ๋์ด์ผ ํ๋ค. (๋ฐ๋๊ธฐ ์ ์ธ์ ๊ฐ์ 1 ๋๋ -1) ๊ฒฝ์ฐ 2. ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 1 ๋๋ -1๋ก ๋ฐ๋๋ฉด ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ๋ณ๊ฒฝ๋์ง ์๋๋ค. (๋ฐ๋๊ธฐ ์ ์ธ์ ๊ฐ์ 0) ๊ฒฝ์ฐ 3. ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 2 ๋๋ -2๋ก ๋ฐ๋๋ฉด ๊ทธ ์์น์์ ์ฌ์กฐ์ ํด์ผ ํ๋ฉฐ, ์ฌ์กฐ์ ๋๋ฉด ๊ทธ ๋ ธ๋์ ๊ท ํ์ธ์๋ 0์ด ๋๋ค. ๋ฐ๋ผ์ ๊ฒฝ์ฐ 1๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ๋ณ๊ฒฝ๋์ด์ผ ํ๋ค. 0 1 0
-1
๊ฒฝ์ฐ 1.
0
0
๊ฒฝ์ฐ 2.
0
0 0
1 0
0
์ญ์ ๋ ๋ ธ๋(์์์ ๋์ธ ์ค๊ฐ๋ ธ๋๋ ์ค์ ์ญ์ ๋ ๋จ๋ง๋ ธ๋)์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ๋ ธ๋๊น์ง ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋ฉด์ ๊ท ํ์ธ์๋ฅผ ์ฌ์กฐ์ ํ ๋ ์ฝ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฐ๋์ ๋ฃจํธ๊น์ง ๊ณ์ ๊ฒํ ํด์ผ ํ๋ ๊ฒ์ ์๋๋ค. ์ญ์ ๋ ์ค๊ฐ๋ ธ๋๊ฐ ์ญ์ ๋ ์ ์์ง๋ง ์ด ์ญ์ ์ค์ ๋ก๋ ๋จ๋ง๋ ธ๋๊ฐ ์ญ์ ๋๋ ๊ฒ์ผ๋ก ๋ณผ ์ ์๋ค. ๋ฐ๋ผ์ ์ญ์ ๋ ๋จ๋ง๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ ๋ฐ๋์ ๊ทธ๊ฒ์ ๊ท ํ์ธ ์๊ฐ ๋ฐ๋๋ค. ํ์ง๋ง ์กฐ์๋ ธ๋๋ค์ ํญ์ ๋ณํ๋ ๊ฒ์ ์๋๋ค. ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ ์ญ์ ๋๋ฌธ
- 155 -
์ 0์ผ๋ก ๋ฐ๋๋ฉด ์ด๊ฒ์ ๊ทธ ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ํธ๋ฆฌ์ ๋์ด๊ฐ ํ๋ ๊ฐ์ํ๋ค๋ ๊ฒ์ ์๋ฏธํ ๋ค. ๋ฐ๋ผ์ ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ๋ฐ๋์ด์ผ ํ๋ค. ํ์ง๋ง ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ ์ญ์ ๋๋ฌธ์ 1 ๋๋ -1๋ก ๋ฐ๋์๋ค๋ฉด ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๋ ๋ณํ์ง ์๋๋ค. ์ฆ, ์ญ์ ์ ์๋ ํธ๋ฆฌ๊ฐ AVL ํธ๋ฆฌ์ ์ฑ์ง์ ๋ง์กฑํ๊ณ ์์ผ๋ฏ๋ก ํธ๋ฆฌ์ ์๋ ๋ชจ๋ ๋ ธ๋์ ๊ท ํ์ธ์๋
0, 1, ๋๋ -1์ด๋ค. ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 1 ๋๋ -1๋ก ๋ฐ๋์๋ค๋ ๊ฒ์ ๊ทธ ์ ์ ๊ท ํ์ธ์๊ฐ 0 ์ด์๋ค๋ ๊ฒ์ ๋งํ์ฌ, ์ด ๊ฒฝ์ฐ์๋ ์ด ๋ ธ๋๊ฐ ๋ฃจํธ๊ฐ ๋๋ ๋ถ๋ถํธ๋ฆฌ์ ๋์ด๋ ๋ณํ๊ฐ ์๋ค ๋ ๊ฒ์ ๋งํ๋ค. ๋ถ๋ชจ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ ๋ณํ์ง ์์ผ๋ฉด ๊ทธ๊ฒ์ ์กฐ์๋ ธ๋์ ๊ท ํ์ธ์๋ ๋น์ฐ ํ ๋ณํ์ง ์๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก ์ฌ๊ธฐ์ ์ญ์ ์ ์ํ ํธ๋ฆฌ์ ์ฌ์กฐ์ ์ ์ค๋จํ ์ ์๋ค.
AVL ํธ๋ฆฌ: ์ญ์ โ ๊ณ ๋ ค์ฌํญ2 ์ฝ์ ๊ณผ ์ ํ ๋ค๋ฅธ ํํ ์กด์ฌ 1
2
15
15 0
0 10 0
-1 10
LL
1
0
0 10
20
5
0 12
5
-1
-2
10
5 0 15
0 15
0
-1 10
20 0 25
20
RR 0
20
12 1
10 0
0
0
12
5
15
0 25
25 0 15
AVL ํธ๋ฆฌ์์ ์ญ์ ๋ ๊ธฐ์กด ์ฝ์ ์์ ๋ณด์๋ LL, LR, RR, RL ๋ค ๊ฐ์ง ์ธ์ ํน์ดํ ๋ ๊ฐ์ง ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ๋ณดํต ์ฝ์ ์์ LL์ A ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 2์ด๊ณ , B ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 1 ์ด๋ค. ํ์ง๋ง ์ญ์ ์ ๊ฒฝ์ฐ ์ด ์ฌ๋ผ์ด๋์์ ๋ณด์ฌ์ฃผ๋ฏ์ด A ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ 2์ด๊ณ , B ๋ ธ๋ ์ ๊ท ํ์ธ์๊ฐ 0์ธ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ๋ LL ํ์ ์ ํตํด ๊ท ํ์ ๋ง์ถ ์ ์ ๋ค. ๋ํ ์ฝ์ ์์ ๊ฒํ ๋์๋ RR์ A ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ -2์ด๊ณ , B ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ -1 ์ด๋ค. ํ์ง๋ง ์ญ์ ์ ๊ฒฝ์ฐ ์ด ์ฌ๋ผ์ด๋์์ ๋ณด์ฌ์ฃผ๋ฏ์ด A ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ -2์ด๊ณ , B ๋ ธ ๋์ ๊ท ํ์ธ์๊ฐ 0์ธ ๊ฒฝ์ฐ๊ฐ ์กด์ฌํ๋ค. ์ด ๊ฒฝ์ฐ๋ RL ํ์ ์ ํตํด ๊ท ํ์ ๋ง์ถ ์ ์๋ค.
- 156 -
AVL ํธ๋ฆฌ: ์ญ์ ์ -1 -1
0
30
8
5
10
17
50
25
7
20
10
25
17
60
40
7
50
20
8
50
65
55
15
30
60
40
0
-1 8
20
30
RR
15
-1 7
0
-2
RR
15
10
17
40
25
55
60
65
65
55
์ญ์ ์ ๊ฒฝ์ฐ, ์ญ์ ๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ถํฐ ๋ฃจํธ๊น์ง ๊ท ํ์ธ์๋ฅผ ๊ฒํ ํ๊ฒ ๋๋๋ฐ, ์ด ๊ฒฝ๋ก์ ์๋ ๋ ธ๋๋ค์ด ํ์ ์ ์ฌ์ฉ๋๋ B๋ ธ๋, C๋ ธ๋๊ฐ ๋์ง ์๋๋ค. (์ฝ์ ๊ณผ ์ฐจ์ด์ )
๋จ๋ง๋ ธ๋์ ์ญ์ ํค ๊ฐ์ด 5์ธ ๋ ธ๋์ ์ญ์ ๋ก ๊ท ํ์ ๋ง์ถ๊ธฐ ์ํด ๋ ๋ฒ์ ํ์ ์ด ํ์ํ๋ค.
์ด ์๋ ๋จ๋ง๋ ธ๋๊ฐ ์ญ์ ๋๋ ๊ฒฝ์ฐ์ ์์ด๋ค. ๋จ๋ง๋ ธ๋ 5๊ฐ ์ญ์ ๋๋ฉด 7 ๋ ธ๋์ ๊ท ํ์ธ์ ๊ฐ ์ด -2๊ฐ ๋๋ค. ๋ฐ๋ผ์ ์ด ๋ ธ๋๋ฅผ ๊ธฐ์ค ๋ ธ๋๋ก ํธ๋ฆฌ๋ฅผ ์ฌ์กฐ์ ํด์ผ ํ๋ค. ์ด ๋ ์ด ๋ ธ๋๊ฐ A ๋ ธ๋๊ฐ ๋๋ฉฐ, ์ญ์ ๋ ๋ ธ๋์ ๋ฐ๋์ชฝ ๋ฐฉํฅ์ ๋ ธ๋๋ค์ด B ๋ ธ๋์ C ๋ ธ๋๊ฐ ๋๋ค. ์ฆ, A ๋ ธ๋ ๋ฅผ ๊ธฐ์ค์ผ๋ก ์ญ์ ๋ ๋ ธ๋๊ฐ A ๋ ธ๋์ ์ผ์ชฝ ๋ถ๋ถํธ๋ฆฌ์ ์์์ผ๋ฉด A ๋ ธ๋์ ์ค๋ฅธ์ชฝ ๋ถ๋ถํธ๋ฆฌ ์ ์๋ ๋ ธ๋๋ค์ด B ๋ ธ๋์ C ๋ ธ๋๊ฐ ๋๋ค. ์ด ์ ๊ณผ ์ฌ๋ฌ ๋ฒ ์ฌ์กฐ์ ํด์ผ ํ๋ค๋ ๊ฒ์ด ์ฝ์ ๊ณผ ๊ฐ์ฅ ํฐ ์ฐจ์ด์ ์ด๋ค. ์ ์์์ 7๋ฅผ ๊ธฐ์ค์ผ๋ก ์ฌ์กฐ์ ํ ๊ฒฐ๊ณผ ๊ทธ ๋ถ๋ถ ํธ๋ฆฌ์ ๋ถ๋ชจ ๋ ธ๋ ์ธ 15 ๋ ธ๋์ ๊ท ํ์ธ์๊ฐ -2๊ฐ ๋์๋ค. ๋ฐ๋ผ์ ์ด ๋ ธ๋๋ฅผ ๊ธฐ์ค์ผ๋ก ๋ค์ ์ฌ์กฐ์ ์ ํด์ผ ํ ๋ค. ์ฆ, 5์ ์ญ์ ๋ก ์ด ๋ ๋ฒ์ ์ฌ์กฐ์ ์ด ๋ฐ์ํ์๋ค.
AVL ํธ๋ฆฌ: ์ญ์ ์ โ ๊ณ์ -1
-1
15
15
-1
-1 7
-1
30
7
25 1
5
8
20
10
17
50
25
40
55
5
60
-1 20
8
10
17
65
50
40
55
60
65
์์์ด ๋์ธ ์ค๊ฐ ๋ ธ๋์ ์ญ์ ์ด ๊ฒฝ์ฐ์๋ ์ ํ ํ์ ์ด ํ์์๋ค.
์ด ์๋ ์์์ด ๋์ธ ์ค๊ฐ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ์์ด๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์์์ด ๋์ธ ์ค๊ฐ๋ ธ ๋์ ์ญ์ ๋ ๊ทธ๊ฒ์ ์ผ์ชฝ ๋ถ๋ถ ํธ๋ฆฌ์์ ๊ฐ์ฅ ํฐ ๊ฐ์ผ๋ก ๋์ฒดํ์ฌ ์ญ์ ๋ฅผ ํ๋ค. ๋ฐ๋ผ์ ์ด ๊ฒฝ์ฐ์๋ ์ค๊ฐ ๋ ธ๋์ ์ญ์ ๋ก ๋ณด๊ธฐ ๋ณด๋ค๋ 25 ๋ ธ๋์ ์ญ์ ๋ก ์๊ฐํ์ฌ ์ฒ๋ฆฌํ๋ค.
- 157 -
AVL ํธ๋ฆฌ: ์ญ์ ์ โ ๊ณ์ -2
-1 10
15
7
10
25
17
5
50
40
55
10
1
-1 20
8
-1 7
25 1
5
25
0
-1
20
8
60
50
-1 50
17
60
40
65
7
55
5
20
8
17
40
55
60
65
65
์ด ์๋ ์ญ์ ์์์ด ๋์ธ ์ค๊ฐ๋ ธ๋๋ฅผ ์ญ์ ํ๋ ์์ด๋ค. ํ์ง๋ง ์ด ๊ฒฝ์ฐ๋ ์ ์์ ์ ๋ฌ๋ฆฌ ํ์ ์ด ํ์ํ๋ค.
AVL ํธ๋ฆฌ ๋ถ์ AVL ํธ๋ฆฌ
์ด์ง ๊ฒ์ ํธ๋ฆฌ
์ฐพ๊ธฐ: T(N) = O(log2N) ์ฒ๋ฆฌ: T(N) = O(1) ์ฝ์ ๊ท ํ: W(N) = O(log2N) ์ ์ฒด: W(N) = O(log2N)
์ ์ฒด: W(N) = O(N)
์ฐพ๊ธฐ: T(N) = O(log2N) ์ฒ๋ฆฌ: W(N) = O(log2N) ์ญ์ ๊ท ํ: W(N) = O(log2N ์ ์ฒด: W(N) = O(log2N)
์ ์ฒด: W(N) = O(N)
๊ฒ์ ์ ์ฒด: T(N) = O(log2N)
์ ์ฒด: W(N) = O(N)
ํ์ ๋น์ฉ์ ์์ ์๊ฐ์ด๋ฉฐ, ์ต์ ์ ๊ฒฝ์ฐ ํธ๋ฆฌ ๋์ด๋งํผ ํ์ ํ ์๋ ์๋ค. ๊ทธ๋ฌ๋ ์ด๊ฒ์ ์ ์ฒด ๋น์ฉ์ ํธ๋ฆฌ ๋์ด์ ๋น๋กํ๋ค. ์ฆ, AVL ํธ๋ฆฌ๋ ์ผ๋ฐ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ฌ๋ฆฌ ์ฝ์ ๊ณผ ์ญ์ ์ ์ฐ์ฐ ๋น์ฉ๋ ์ ๋ ดํ๋ฉด์ ๊ฒ์์ ํญ์ O(log2N)์ธ ํธ๋ฆฌ์ด๋ค.
- 158 -
์ 12์ฅ ๊ทธ๋ํ ์ด ์ฅ์์๋ ๊ทธ๋ํ๋ผ๋ ์๋ฃ๊ตฌ์กฐ์ ๋ํด ์ดํด๋ณธ๋ค.
12.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ ๊ฐ์ ๊ทธ๋ํ๋ ํธ๋ฆฌ๋ฅผ ํฌํจํ๊ณ ์๋ ๋ณด๋ค ํฐ ๊ฐ๋ ์ ์๋ฃ๊ตฌ์กฐ๋ก์, ๋ ธ๋์ ๋ ๋ค๋ฅธ ๋ ธ๋ ๊ฐ์ ์ฌ๋ฌ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ ์ ์๊ณ , ๊ฐ์ ์ ๋ฐฉํฅ์ด ์กด์ฌํ ์ ์๋ค. ๋น๊ฐ์ค์น ๊ทธ๋ํ ๊ทธ๋ํ ํ์: ๋๋น ์ฐ์ , ๊น์ด ์ฐ์ ์ ์ฅ ํธ๋ฆฌ ๊ฐ์ค์น ๊ทธ๋ํ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ
12.2. ๊ทธ๋ํ
๊ทธ๋ํ ๊ทธ๋ํ(graph): ๊ณต์งํฉ์ด ์๋ ์ ์ (vertex)๋ค์ ์ ํ ์งํฉ๊ณผ ๊ทธ๋ํ ์ ์ ์ด ์ ์ ๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ (edge)์ผ๋ก ๊ตฌ์ฑ๋๋ ์๋ฃ๊ตฌ์กฐ ๊ฐ์ ์ํ์ ์ ์: ๊ทธ๋ํ G๋ G = (V, E)๋ก ์ ์๋๋ฉฐ, ์ฌ๊ธฐ์ V(G): ๊ณต์งํฉ์ด ์๋ ์ ์ ๋ค์ ์ ํ์งํฉ E(G): ๊ฐ์ ๋ค์ ์งํฉ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ(undirected graph): ๊ฐ์ ์ ๋ฐฉํฅ์ฑ์ด ์๋ ๊ทธ๋ํ ๊ทธ๋ํ ์ ๋ฐฉํฅ ๊ทธ๋ํ(directed graph, digraph): ๊ฐ์ ์ ๋ฐฉํฅ์ฑ์ด ์๋ ๊ทธ๋ํ ๊ทธ๋ํ ๋ฐฉํฅ ๊ทธ๋ํ์์๋ ๊ฐ์ ์ ์ํฌ(arc)๋ผ๊ณ ๋ ํ๋ค. ์ํฌ ์ธ์ ์ ์ (adjacent vertex): ๊ฐ์ ์ ์ํด ์ฐ๊ฒฐ๋์ด ์๋ ์ ์ ์ ์ ๊ฒฝ๋ก(path): ๋ ๊ฐ์ ์ ์ ์ ์ฐ๊ฒฐํ๋ ์ผ๋ จ์ ์ ์ ๋ค ๊ฒฝ๋ก ์ ์ a์์ b๊น์ง์ ๊ฒฝ๋ก a, v1, v2, โฆ, vn, b๊ฐ ์กด์ฌํ๊ธฐ ์ํด์๋ ๊ฐ์ (a, v1), (v1, v2), โฆ, (vn-1, vn), (vn, b)๊ฐ ์กด์ฌํด์ผ ํ๋ค.
๊ณต์งํฉ์ด ์๋ ์ ์ (vertex)๋ค์ ์ ํ์งํ๊ณผ ์ด ์ ์ ๋ค์ ์ฐ๊ฒฐํ๋ ๊ฐ์ (edge)์ผ๋ก ๊ตฌ์ฑ๋๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ทธ๋ํ(graph)๋ผ ํ๋ค. ๋ฐ๋ผ์ 10์ฅ, 11์ฅ์์ ์ดํด๋ณธ ํธ๋ฆฌ ๊ตฌ์กฐ๋ ๊ทธ๋ํ์ ์ ํ๋ค. ์ฆ, ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ํน์ํ ํํ์ด๋ค. ๊ทธ๋ํ๋ ๊ฐ์ ์ ๋ฐฉํฅ์ฑ์ด ์๋์ง์ ๋ฐ๋ผ ๋ฌด๋ฐฉ ํฅ(undirected) ๋๋ ์ ๋ฐฉํฅ(directed) ๊ทธ๋ํ๋ก ๋๋์ด ์ง๋ค. ๋ฐฉํฅ์ฑ์ด ์๋ ๊ฐ์ ์ ๋ค๋ฅธ ๋ง
- 159 -
๋ก ์ํฌ(arc)๋ผ ํ๋ค. ์ธ์ ์ ์ (adjacent vertex)์ด๋ ๊ฐ์ ์ ์ํด ์ฐ๊ฒฐ๋๋ ์ ์ ์ ๋งํ๋ฉฐ, ๊ฒฝ๋ก(path)๋ ๋ ๊ฐ์ ์ ์ ์ ์ฐ๊ฒฐํ๋ ์ผ๋ จ์ ์ ์ ๋ค์ ๋งํ๋ค.
๊ทธ๋ํ โ ๊ณ์ M
A
V(G1)= {A,B,E,L,M}
E B
D
E(G1)= {(A,E),(B,L),(E,A) (L,L),(L,A),(M,B),(M,E)} B
C V(G1)={A,B,C,D} A
L
Path(M,A): M, B, L, A - ๊ธธ์ด: 3
E(G1)={(A,B),(A,D),(B,C),(C,D)}
๊ฒฝ๋ก์ ๊ธธ์ด: ๊ธธ์ด ๊ฒฝ๋ก๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ์ ์ ์ ์ฃผ๊ธฐ(cycle): ์ฒซ ๋ฒ์งธ ์ ์ ๊ณผ ๋ง์ง๋ง ์ ์ ์ด ๊ฐ์ ๊ฒฝ๋ก ์ฃผ๊ธฐ ์ ์ ์ ์ฐจ์: ์ฐจ์ ์ ์ ์ ์ฐ๊ฒฐ๋ ๊ฐ์ ์ ์๋ฅผ ๋งํ๋ฉฐ, ์ ๋ฐฉํฅ ๊ทธ๋ํ์์๋ ์ง์ ์ฐจ์(indegree)์ ์ง์ถ ์ฐจ์(outdegree)๋ก ๋๋์ด ๊ณ ๋ ค๋๋ค. ์ฐจ์ ์ฐจ์
์ด ์ฌ๋ผ์ด๋์ ์๋ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ A์ ์ธ์ ์ ์ ์ B์ D์ด๋ค. ๊ฒฝ๋ก์ ๊ธธ์ด๋ ๊ฒฝ๋ก๋ฅผ ๊ตฌ์ฑํ๋ ๊ฐ์ ์ ์๋ฅผ ๋งํ๋ค. ๊ฒฝ๋ก ์ค ์ฒซ ๋ฒ์งธ ์ ์ ๊ณผ ๋ ์ ์ ์ด ๊ฐ์ผ๋ฉด ์ฃผ๊ธฐ(cycle)๋ผ ํ ๋ค. ์ ์ฌ๋ผ์ด๋์ ์๋ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ (A, B), (B, C), (C, D), (D, A)๋ ์ฃผ๊ธฐ์ด๋ฉฐ, ์ด ๊ฒฝ๋ก์ ๊ธธ์ด๋ 4์ด๋ค. ๊ฒฝ๋ก์ ์ฐจ์(degree)๋ ์ ์ ์ ์ฐ๊ฒฐ๋ ๊ฐ์ ์ ์๋ฅผ ๋งํ๋ฉฐ, ์ ๋ฐฉํฅ ๊ทธ ๋ํ์์๋ ์ง์ ์ฐจ์์ ์ง์ถ์ฐจ์๋ฅผ ๋๋์ด ๊ณ ๋ คํ๋ค. ์ ์ฌ๋ผ์ด๋์ ์๋ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ ์ A์ ์ฐจ์๋ 2์ด๊ณ , ์ ๋ฐฉํฅ ๊ทธ๋ํ์์ A์ ์ง์ถ์ฐจ์๋ 1์ด๊ณ , ์ง์ ์ฐจ์๋ 2์ด๋ค.
๊ทธ๋ํ โ ๊ณ์ ์์ ๊ทธ๋ํ(complete graph): ์ต๋ ์์ ๊ฐ์ ์ ๊ฐ์ง ๊ทธ๋ํ ๊ทธ๋ํ ๋ชจ๋ ์ ์ ์ด ์ธ์ ์ ์ ์ด ๋๋ค. N๊ฐ์ ์ ์ ์ด ์์ผ๋ฉด ์ ๋ฐฉํฅ์ N(N-1)๊ฐ, ๋ฌด๋ฐฉํฅ์ N(N-1)/2๊ฐ์ ๊ฐ์ ์ด ์กด์ฌํ๋ค.
์์ ์ ๋ฐฉํฅ ๊ทธ๋ํ (complete directed graph)
์์ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ (complete undirected graph)
์์ ๊ทธ๋ํ(complete graph)๋ ์ต๋ ์์ ๊ฐ์ ์ ๊ฐ์ง ๊ทธ๋ํ๋ฅผ ๋งํ๋ค. ์ฆ, ๋ชจ๋ ์ ์ ์ ๋ค๋ฅธ ๋ชจ๋ ์ ์ ์ ์ธ์ ์ ์ ์ด ๋๋ค. ์ ๋ฐฉํฅ ๊ทธ๋ํ์์๋ ๎ ๊ฐ์ ์ ์ ์ด ์์ ๋, ์ด ๊ทธ๋ ํ๊ฐ ์์ ๊ทธ๋ํ์ด๋ฉด ์ด ๎ ๎ ๎ ๎ ๎ด ๎ ๊ฐ์ ๊ฐ์ ์ด ์กด์ฌํ๋ค. ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์๋ ๊ฐ์ ์กฐ๊ฑด ์์๋ ์ด ๎ ๎ ๎ ๎ ๎ด ๎ ๎๎ต ๊ฐ์ ๊ฐ์ ์ด ์กด์ฌํ๋ค.
- 160 -
๊ฐ์ค์น ๊ทธ๋ํ ๊ฐ์ค์น ๊ทธ๋ํ(weighted graph): ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ํ ๋น๋์ด ์๋ ๊ทธ๋ํ ๊ทธ๋ํ 120
10
์ธ์ฒ
120
์์ธ
์์ฃผ
๊ฐ๋ฆ
90 160 180
140
์ฒ์
250
50
๋์
๊ด์ฃผ
200
60 60 80
๋๊ตฌ
๋ถ์ฐ 80
๊ฐ์ค์น ๊ทธ๋ํ(weighted graph)๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ํ ๋น๋์ด ์๋ ๊ทธ๋ํ๋ฅผ ๋งํ๋ค.
12.3. ๋น๊ฐ์ค์น ๊ทธ๋ํ
๋น๊ฐ์ค์น ๊ทธ๋ํ์ ํํ ๋ฐฉ๋ฒ 1. ์ธ์ ํ๋ ฌ
M
A E B
D B C A A
B
C
D
A
0
1
0
1
B
1
0
1
0
C
0
1
0
1
D
1
0
1
0
L
ํฉ: ์ ์ ์ ์ฐจ์
A
B
E
L
M
A
0
0
1
0
0
B
0
0
0
1
0
E
1
0
0
0
0
L
1
0
0
1
0
M
0
1
1
0
0
ํ์ ํฉ: ์ ์ ์ ์ง์ถ ์ฐจ์ ์ด์ ํฉ: ์ ์ ์ ์ง์ ์ฐจ์
๋จ์ . ๋จ์ . n2 ๊ณต๊ฐ์ด ํ์ - ๋ฌด๋ฐฉํฅ ํ๋ ฌ์ ์ด๊ฒ์ ๋ฐ๋ง์ผ๋ก ํํ๊ฐ๋ฅ
๋น๊ฐ์ค์น ๊ทธ๋ํ๋ฅผ ์ปดํจํฐ๋ก ํํํ ๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ ๊ฐ์ง๊ฐ ์๋ค. ์ฒซ์งธ, ์ธ์ ํ๋ ฌ ๋ฐฉ๋ฒ ๋์งธ, ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ๋ฒ ์ธ์ ํ๋ ฌ ๋ฐฉ๋ฒ์ ํ๋ ฌ์ ํตํด ์ ์ ๊ฐ์ ์ธ์ ์ฌ๋ถ๋ฅผ ๋ํ๋ธ๋ค. ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ ๊ฒฝ์ฐ์๋ ๎ต ํ๋ ฌ์ด ๋์นญ์ ์ด๋ฏ๋ก ์ค์ ๋ ๎ฒ ๎๎ต ๋งํผ์ ๊ณต๊ฐ์ด ํ์ํ๋ค. ๋ฐ๋ฉด ์ ๋ฐฉํฅ ๊ทธ๋ํ๋ ํ๋ ฌ์ด ๋ ๎ต ์นญ์ ์ด์ง ์์ผ๋ฏ๋ก ๎ฒ ๋งํผ์ ๊ณต๊ฐ์ด ํ์ํ๋ค. ์ ๋ฐฉํฅ ๊ทธ๋ํ์์๋ ํ์ ํฉ์ด ์ ์ ์ ์ง์ถ
์ฐจ์๋ฅผ ๋ํ๋ด๋ฉฐ, ์ด์ ํฉ์ ์ง์ ์ฐจ์๋ฅผ ๋ํ๋ธ๋ค.
- 161 -
๋น๊ฐ์ค์น ๊ทธ๋ํ์ ํํ โ ๊ณ์ ๋ฐฉ๋ฒ 2. ์ธ์ ๋ฆฌ์คํธ
A
M
A E B
D B
E
B
L
E
A
L
A
L
M
B
E
C A A
B
D
B
A
C
C
B
D
D
A
C
L
๋จ์ . ๋จ์ . ์ง์ ์ฐจ์๋ฅผ ๊ณ์ฐํ๋ ๊ฒ์ด ์ด๋ ต๋ค. - ์ญ์ธ์ ๋ฆฌ์คํธ ์ ์ง
์ธ์ ๋ฆฌ์คํธ ํํ ๋ฐฉ๋ฒ์ ๊ฐ ์ ์ ๋ง๋ค ๊ทธ๊ฒ์ ์ธ์ ํ ์ ์ ๋ค์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ก ์ ์งํ๋ค. ์ ๋ฐฉํฅ ๊ทธ๋ํ์์๋ ์ธ์ ํ๋ ฌ ํํ ๋ฐฉ๋ฒ๊ณผ ๋ฌ๋ฆฌ ์ง์ ์ฐจ์๋ฅผ ๊ณ์ฐํ๋ ๊ฒ์ด ์ด๋ ต๋ค. ์ด๋ฅผ ์ํด ์ญ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ถ๊ฐ๋ก ์ ์งํ๊ธฐ๋ ํ๋ค.
Graph ADT <<interface>> Graph
MatrixGraph
WeightedMatrixGraph
ListGraph
UnweightedMatrixGraph
WeightedListGraph
DirectedWeightedMatrixGraph
UnweightedListGraph
UndirectedUnweightedListGraph
UndirectedUnweightedMatrixGraph
๊ทธ๋ํ๋ ํฌ๊ฒ ์ธ์ ํ๋ ฌ ๋๋ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ๋ ๊ตฌํํ ์ ์๋ค. ๋ฐ๋ผ์ Graph๋ผ๋ ๊ณตํต ์ธํฐํ์ด์ค๋ฅผ ์ ์ํ ํ์, ์ธ์ ํ๋ ฌ์ ์ด์ฉํ๋ ๊ตฌํ ๋ฐฉ์์ ์ํ ์ถ์ ํด๋์ค
MatrixGraph์ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ๋ ๊ตฌํ ๋ฐฉ์์ ์ํ ์ถ์ ํด๋์ค๋ฅผ ListGraph๋ฅผ ์ ์ ํ๋ค. ๊ทธ ๋ค์์ ๊ทธ๋ํ๊ฐ ๊ฐ์ค์น, ๋น๊ฐ์ค์น ๊ทธ๋ํ์ธ์ง์ ๋ฐ๋ผ ListGraph๋ ๋ค์ ๊ทธ๊ฒ์ ์ ์
์ถ์ํด๋์ค์ธ
WeightedListGraph,
UnweightedListGraph๋ฅผ
WeightedMatrixGraph, UnweightedMatrixGraph๋ฅผ ์ ์ํ๋ค.
- 162 -
์ ์ํ๊ณ ,
MatrixGraph๋
Graph ADT import java.util.Iterator; interface Graph{ int DEF_CAPACITY = 10; int DFS = 1; // ํ์ ๋ฐฉ๋ฒ์ ์ง์ ํ๊ธฐ ์ํ ์์ int BFS = 2; // ํ์ ๋ฐฉ๋ฒ์ ์ง์ ํ๊ธฐ ์ํ ์์ boolean isEmpty(); boolean isFull(); void clear(); void insertVertex(String label) throws GraphOverflowException; void removeVertex(String label) throws GraphUnderflowException; void removeEdge(String from, String to) throws GraphUnderflowException; // ๋น๊ฐ์ค์น ๊ทธ๋ํ // void insertEdge(String from, String to); // ๊ฐ์ค์น ๊ทธ๋ํ // void insertEdge(String from, String to, int weight); Iterator iterator(int type, String start); }
๊ฐ์ค์น ๊ทธ๋ํ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์ฐ๊ด๋ ๊ทธ๋ํ๋ก์ ํ์ ๋ณด๋ค ์์ธํ ์ค๋ช ํ๋ค. ๊ฐ์ค์น ๊ทธ๋ํ์์ ๊ฐ์ ์ ์ถ๊ฐ๋ ์ถ๊ฐ์ ์ผ๋ก ๊ฐ์ ์ ๊ฐ์ค์น ๊ฐ์ ์ ๊ณตํด์ผ ํ๋ค. ๋ฐ๋ฉด์ ๋น๊ฐ์ค์น ๊ทธ๋ํ์์ ๊ฐ์ ์ ์ถ๊ฐํ ๋์๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ํ์ ์๋ค. public abstract ListGraph implements Graph{ protected class Vertex{ public String label; public SortedLinkedList edges; } protected class GraphIterator implements Iterator{ โฆ } protected Vertex[] graph; protected int size = 0; // ์ ์ ์ ๊ฐ์ ์ธ์ ๋ฆฌ์คํธ ํํ ๋ฐฉ๋ฒ์ ์ฌ์ฉ public ListGraph(){ setup(DEF_CAPACITY); } public ListGraph(int capacity){ if(capcity>0) setup(capacity); else setup(DEF_CAPACITY); } private void setup(int capacity){ โฆ } public boolean isEmpty(){ return (size == 0); } public boolean isFull(){ return (size == graph.length); } public void clear() { โฆ } protected int index(String label){ โฆ } // ์ ์ ์ ์์ธ ์ฐพ๊ธฐ public void insertVertex(String label) throws GraphOverflowException { โฆ } public abstract void removeVertex(String label) throws GraphUnderflowException; public abstract void removeEdge(String from, String to) throws GraphUnderflowException; public boolean search(int type, String from, String to) throws GraphUnderflowException { โฆ } public Iterator iterator(int type, String start) throws GraphUnderflowException { โฆ } }
์ธ์ ๋ฆฌ์คํธ ํํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ ๋ ํ ๊ฐ์ง ๊ณ ๋ คํด์ผ ํ๋ ๊ฒ์ ๋ด๋ถ์ ์ผ๋ก ์ ์ ๋ค์ ์ด๋ป ๊ฒ ์ ์งํ ์ง ๊ฒฐ์ ํด์ผ ํ๋ค. ์ด ์ฅ์์๋ ๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ก ์ ์ ๋ค์ ์ ์งํ ์ง๋ง ๋ค๋ฅธ ์ฌ๋ฌ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ ์งํ ์๋ ์๋ค. ๊ฐ์ ์ ๋ฐฉํฅ์ฑ ์ฌ๋ถ, ๊ฐ์ ์ ๊ฐ์ค์น ์ฌ๋ถ ์ ๊ด๊ณ์์ด ์ ์ ์ ์ถ๊ฐ๋ ๋ชจ๋ ๋์ผํ๋ค. ํ์ง๋ง ์ ์ ์ ์ ๊ฑฐ, ๊ฐ์ ์ ์ถ๊ฐ, ๊ฐ์ ์ ์ ๊ฑฐ ๋ ๊ฐ์ ์ ๊ฐ์ค์น, ๋ฐฉํฅ์ฑ์ ๋ฐ๋ผ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์ด ์ฌ๋ผ์ด๋์ ์ ์๋ ListGraph ํด๋์ค์ ์๋ ์ ์ํ ์ ์๋ค. ์ํ, ๊ฒ์์ ๋ฐฉํฅ์ฑ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ๊ตฌํ๋์ด์ผ ํ ๊ฒ์ผ๋ก ์๊ฐ๋์ง ๋ง ๊ทธ๋ ์ง ์๋ค. ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์๋ ๊ฐ์ ์ ์ถ๊ฐํ ๋ ์์ชฝ์ ๋ชจ๋ ์ถ๊ฐํด์ผ ํ๋ค๋ ์ธก๋ฉด ์ ์ ์ธํ๊ณ ๋ ๋์ผํ๊ธฐ ๋๋ฌธ์ ์ํ, ๊ฒ์์ ๊ตฌํ์ ๋ฐฉํฅ์ฑ์ ์ํฅ์ ๋ฐ์ง ์๋๋ค.
- 163 -
WeightedListGraph, UnweightedListGraph public abstract class WeightedListGraph extends ListGraph{ public WeightedListGraph(){ super(); } public WeightedListGraph(int capacity){ super(capacity); } public abstract void insertEdge(String from, String to, int weight); } public abstract class UnweightedListGraph extends ListGraph{ public WeightedListGraph(){ super(); } public WeightedListGraph(int capacity){ super(capacity); } public abstract void insertEdge(String from, String to); }
UndirectedUnweightedListGraph public abstract UndirectedUnweightedListGraph implements UnweightedGraph{ public UndirectedUnweightedListGraph(){ super(DEF_CAPACITY); } public UndirectedUnweightedListGraph(int capacity){ super(DEF_CAPACITY); } public void removeVertex(String label) throws GraphUnderflowException { โฆ } public void removeEdge(String from, String to) throws GraphUnderflowException { โฆ } public void insertEdge(String from, String to) throws GraphUnderflowException { โฆ } }
์ด ์ ์์๋ ์ธ์ ๋ฆฌ์คํธ ํํ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ์ฌ ๋ฌด๋ฐฉํฅ ๋น๊ฐ์ค์น ๊ทธ๋ํ๋ฅผ ๊ตฌํํด๋ณธ๋ค. ์ด ๋ฅผ ์ํด UnweightedListGraph์ ์์๋ฐ์ UndirectedUnweightedListGraph ํด๋์ค๋ฅผ ์ ์ํ ๋ค.
- 164 -
Insert Vertex public void insertVertex(String label) throws GraphOverflowException{ if(label==null) throw new NullPointerException(โโฆโ); if(isFull()) throw new GraphOverflowException(โโฆ"); Vertex v = new Vertex(); v.label = label; v.edges = new SortedLinkedList(); graph[size] = v; size++; } // ListGraph: insertVertex protected int index(String label){ for(int i=0; i<size; i++){ if(label.equals(graph[i].label)) return i; } return -1; ์ ์ ๋ค์ ๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฐฉ์์ผ๋ก ์ ์ง } // ListGraph: index
์ด ์ฅ์์๋ ๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ๋ก ์ ์ ๋ค์ ์ ์งํ๊ธฐ ๋๋ฌธ์ ์ ์ ์ ์ถ๊ฐ๋ ๋ฆฌ์ค ํธ์ ๋งจ ๋์ ์ถ๊ฐํ๊ฒ ๋๋ค. ์ ์ ์ ์ ๊ฑฐ, ๊ฐ์ ์ ์ถ๊ฐ, ๊ฐ์ ์ ์ ๊ฑฐ๋ ๋ชจ๋ ํด๋น ์ ์ ์ด ์ด๋ฏธ ๊ทธ๋ํ์ ์กด์ฌํด์ผ ํ๋ค. ๊ทธ๋ํ์ ์ฃผ์ด์ง ์ด๋ฆ์ ์ ์ ์ด ์๋์ง ํ์ ํ๊ณ ์๋ ๊ฒฝ์ฐ ์๋ ๊ทธ ์ ์ ์ ๊ดํ ์ ๋ณด๊ฐ ์ ์ฅ๋์ด ์๋ ๋ฐฐ์ด์ ์์น๋ฅผ ์์๋ด๊ธฐ ์ํด index๋ผ๋ ๋ด๋ถ ๋ฉ์๋๋ฅผ ์ ์ํ์ฌ ์ฌ์ฉํ๋ค.
Insert Edge public void insertEdge(String from, String to) throws GraphUnderflowException{ if(from==null||to==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new GraphUnderflowException(โโฆโ); int v1 = index(from); int v2 = index(to); // v1 ์ ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(v1==-1) throw new GraphUnderflowException(โโฆโ); // v2 ์ ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(v2==-1) throw new GraphUnderflowException(โโฆโ); graph[v1].edges.insert(graph[v2].label); graph[v2].edges.insert(graph[v1].label); } // UndirectedUnweightedListGraph: insertEdge ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ด๋ฏ๋ก ์์ชฝ ์ธ์ ๋ฆฌ์คํธ์ ๋ชจ๋ ์ถ๊ฐํด์ผ ํจ.
๊ฐ์ ์ ์ถ๊ฐํ๊ณ ์ ํ ๊ฒฝ์ฐ์๋ ๊ฐ์ ์ ๋ ์ ์ ์ด ๋ชจ๋ ์กด์ฌํด์ผ ํ๋ค. ๊ตฌํํ๋ ๊ทธ๋ํ๊ฐ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ด๋ฏ๋ก A์์ B๋ฅผ ์๋ ๊ฐ์ ์ ์ถ๊ฐํ ๊ฒฝ์ฐ์๋ B์์ A๋ฅผ ์๋ ๊ฐ์ ๋ ํจ ๊ป ์ถ๊ฐํด์ผ ํ๋ค.
- 165 -
Remove Vertex public void removeVertex(String label) throws GraphUnderflowException{ if(label==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new GraphUnderflowException(โโฆโ); int v = index(label); // ์ ๊ฑฐํ๊ณ ์ ํ๋ ์ ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(v == -1) throw new GraphUnderflowException(โโฆโ); graph[v] = graph[size-1]; size--; for(int i=0;i<size;i++){ if(!graph[i].edges.isEmpty()) graph[i].edges.delete(label); } } // UndirectedUnweightedListGraph: RemoveVertex ์ ์ ์ ์ ๊ฑฐํ๋ ์ด ์ ์ ์ ์ฐ๊ฒฐ๋ ๋ชจ๋ ๊ฐ์ ์ ์ ๊ฑฐํด์ผ ํ๋ค.
์ ์ ์ ์ ๊ฑฐํ๋ค๋ ๊ฒ์ ๊ทธ ์ ์ ๊ณผ ๊ทธ ์ ์ ์ ์ฐ๊ฒฐ๋ ๋ชจ๋ ๊ฐ์ ์ ์ ๊ฑฐํ๋ค๋ ๊ฒ์ ์๋ฏธํ ๋ค. ๋ฐ๋ผ์ ๊ทธ ์ ์ ์ ์ ์ ๋ค์ ๊ด๋ฆฌํ๋ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ ๊ฑฐํ๋ ๊ฒ์ ๋ฌผ๋ก ๊ทธ๊ฒ์ ์ธ ์ ์ ์ ๋ค์ ์ธ์ ๋ฆฌ์คํธ์์๋ ์ด ์ ์ ์ ์ ๊ฑฐํด์ผ ํ๋ค. ์ด ๊ตฌํ์์๋ ๋ชจ๋ ์ ์ ์ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ๊ฒ์ํ๊ณ ์๋ค. ์ด ๋ฐฉ๋ฒ์ ์ ์ ์ด ๋ง์ ๊ฒฝ์ฐ์๋ ๋งค์ฐ ๋นํจ์จ์ ์ด๋ค. ์ด๊ฒ์ ๊ฐ์ ํ๊ธฐ ์ํ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ ์ ๊ฑฐํ๊ณ ์ ํ๋ ์ ์ ์ ์ธ์ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ์ฌ ์ค์ ์ธ์ ํ ์ ์ ์ ์ธ์ ๋ฆฌ์คํธ๋ง ๊ฒ์ํ์ฌ ๋ณ๊ฒฝํ ์ ์๋ค.
Remove Edge public void removeEdge(String from, String to) throws GraphUnderflowException{ if(isEmpty()) throw new GraphUnderflowException(โโฆโ); if(from==null||to==null) throw new NullPointerException(โโฆโ); int v1 = index(from); int v2 = index(to); // v1 ์ ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(v1==-1) throw new GraphUnderflowException(โโฆโ); // v2 ์ ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(v2==-1) throw new GraphUnderflowException(โโฆโ); // v1์์ v2๋ฅผ ์๋ ๊ฐ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ if(!graph[v1].edges.delete(graph[v2].label)) throw new GraphUnderflowException(โโฆโ); graph[v2].edges.delete(graph[v1].label); } // UndirectedUnweightedListGraph: RemoveEdge ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ด๋ฏ๋ก ์์ชฝ ์ธ์ ๋ฆฌ์คํธ์ ๋ชจ๋ ์ ๊ฑฐํด์ผ ํจ.
A์์ B๋ฅผ ์๋ ๊ฐ์ ์ ์ ๊ฑฐํ๊ณ ์ ํ ๊ฒฝ์ฐ์๋ A ์ ์ ๊ณผ B ์ ์ ์ด ์กด์ฌํด์ผ ํ ๋ฟ๋ง ์ ๋๋ผ A์์ B๋ฅผ ์๋ ๊ฐ์ ์ด ์ค์ ์กด์ฌํด์ผ ํ๋ค. ๋ํ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ด๋ฏ๋ก A์์ B๋ฅผ ์ ๋ ๊ฐ์ ์ ์ ๊ฑฐํ ๋ B์์ A๋ฅผ ์๋ ๊ฐ์ ์ ๋ณด ์ญ์ ํจ๊ป ์ ๊ฑฐํด์ผ ํ๋ค.
12.4. ์ํ ํธ๋ฆฌ์์ ์ํ๋ ํฌ๊ฒ ์ ์, ์ค์, ํ์ ์ธ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค. ๊ทธ๋ํ์์ ์ํ๋ ํฌ๊ฒ
- 166 -
๊น์ด์ฐ์ ๋ฐฉ๋ฒ๊ณผ ๋๋น์ฐ์ ๋ฐฉ๋ฒ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ด ์กด์ฌํ๋ค.
Traverse ๊น์ด์ฐ์ ํ์(DFS, Depth First Search) ๊น์ด์ฐ์ ํ์ ๋จ๊ณ 1. ์ ์ i๋ฅผ ๋ฐฉ๋ฌธํ๋ค. ๋จ๊ณ 2. ์ ์ i์ ์ธ์ ํ ์ ์ ์ค์ ์์ง ๋ฐฉ๋ฌธํ์ง ์์ ์ ์ ์ด ์์ผ๋ฉด ๋ชจ๋ ์คํ์ ์ ์ฅํ๋ค. ๋จ๊ณ 3. ์คํ์์ ์ ์ ์ ์ ๊ฑฐํ๊ณ , ์ด ์ ์ ์ i๋ก ํ์ฌ ๋จ๊ณ 1๋ถํฐ ๋ค์ ์ํํ๋ค. ๋ง์ฝ ์คํ์ด ๋น์ด์๊ฑฐ๋ ๋ชจ๋ ์ ์ ์ ๋ฐฉ๋ฌธํ์์ผ๋ฉด ์ข ๋ฃํ๋ค. A A ์ํ ์์: A,D,G,C,F,B,E C
์ํ ์์: A,C,E,D,B
C D
B
B G
D
E
E
F
๊น์ด์ฐ์ ๋ฐฉ๋ฒ์ ํ์ชฝ ๋ฐฉํฅ์ผ๋ก ๊ฐ ์ ์์ ๋๊น์ง ๊ณ์ ๋ฐฉ๋ฌธํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ด ๋ฐฉ๋ฒ์ ์ค ํ์ ์ฌ์ฉํ์ฌ ๊ตฌํํ๋ค. ์ ์ฌ๋ผ์ด๋์ ์๋ ์ฒซ ๋ฒ์งธ ๊ทธ๋ํ๋ฅผ ์ด์ฉํ์ฌ ๊น์ด์ฐ์ ๋ฐฉ๋ฒ์ ์ค๋ช ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ๋จผ์ A์์ ์ถ๋ฐํ๋ฏ๋ก A๋ฅผ ์คํ์ pushํ๋ค. ๊ทธ ๋ค์ ์คํ์์ ์ ์ ์ ์ ๊ฑฐํ๊ณ ์ด ์ ์ ์ ์ธ์ ์ ์ ์ ์คํ์ pushํ๋ค. ๋ฐ๋ผ์ ์คํ์ B์ C๊ฐ ์ฐจ๋ก๋๋ก
push๋๋ค. ์คํ์ ์ธ์ ์ ์ ๋ค์ pushํ ๋ค์์๋ ๋ฐ๋ก ์ ์ ์ ํ๋ pop์ ํ๋ค. C๊ฐ top ์ ์์ผ๋ฏ๋ก ์ด ์ ์ ์ ์ธ์ ์ ์ ์ ์คํ์ pushํ๋ค. ๋ฐ๋ผ์ ์คํ์ D, E ์์ผ๋ก push๋ ๋ค. ํ์ฌ ์คํ์ ์๋ ์ ์ ์ top๋ถํฐ ๋์ดํ์์ ๋ E, D, B์ด๋ค. ์ด๋ฐ ๋ฐฉ๋ฒ์ผ๋ก ์ํํ๋ฉด ๊ทธ ๊ฒฐ๊ณผ๋ A, C, E, D, B ์์ผ๋ก ๋ฐฉ๋ฌธํ๊ฒ ๋๋ค.
Traverse ๋๋น์ฐ์ ํ์(BFS, Breadth First Search) ๋๋น์ฐ์ ํ์ ๋จ๊ณ 1. ์ ์ i๋ฅผ ๋ฐฉ๋ฌธํ๋ค. ๋จ๊ณ 2. ์ ์ i์ ์ธ์ ํ ์ ์ ์ค์ ์์ง ๋ฐฉ๋ฌธํ์ง ์์ ์ ์ ์ด ์์ผ๋ฉด ๋ชจ๋ ํ์ ์ ์ฅํ๋ค. ๋จ๊ณ 3. ํ์์ ์ ์ ์ ์ ๊ฑฐํ๊ณ , ์ด ์ ์ ์ i๋ก ํ์ฌ ๋จ๊ณ 1๋ถํฐ ์ํํ๋ค. ๋ง์ฝ ํ๊ฐ ๋น์ด์๊ฑฐ๋ ๋ชจ๋ ์ ์ ์ ๋ฐฉ๋ฌธํ์์ผ๋ฉด ์ข ๋ฃ ํ๋ค. A A ์ํ ์์: A,B,C,D,F,E,G C
์ํ ์์: A,B,C,E,D
C D
B
B G
D
E
E
F
๋๋น์ฐ์ ๋ฐฉ๋ฒ์ ์ถ๋ฐ ์ ์ ์ ๊ฐ์ฅ ๊ฐ๊น์ด ๊ฑฐ๋ฆฌ์ ์๋ ์ ์ ๋ถํฐ ์ฐจ๋ก๋ก ๋ฐฉ๋ฌธํ๋ค. ์ด ๋ฐฉ๋ฒ ์ ๊น์ด์ฐ์ ๋ฐฉ๋ฒ๊ณผ ๋ฌ๋ฆฌ ํ๋ฅผ ์ฌ์ฉํ์ฌ ๊ตฌํํ๋ค. ์ ์ฌ๋ผ์ด๋์ ์๋ ์ฒซ ๋ฒ์งธ ๊ทธ๋ํ๋ฅผ ์ด์ฉํ์ฌ ๊น์ด์ฐ์ ๋ฐฉ๋ฒ์ ์ค๋ช ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ๋จผ์ A์์ ์ถ๋ฐํ๋ฏ๋ก A๋ฅผ ํ์
enqueueํ๋ค. ๊ทธ ๋ค์ ํ์์ ์ ์ ์ dequeueํ๊ณ ์ด ์ ์ ์ ์ธ์ ์ ์ ๋ค์ ํ์ enqueue
- 167 -
ํ๋ค. ๋ฐ๋ผ์ ํ์ B์ C๊ฐ ์ฐจ๋ก๋๋ก enqueue๋๋ค. ํ ์ ์ ์ ์ธ์ ์ ์ ๋ค์ ํ์
enqueue๋ฅผ ํ ๋ค์์๋ ๋ฐ๋ก ์ ์ ์ ํ๋ dequeueํ๋ค. B๊ฐ ํ front์ ์์ผ๋ฏ๋ก ์ด ์ ์ ์ ์ธ์ ์ ์ ์ ํ์ enqueueํ๋ค. ๋ฐ๋ผ์ ํ์ E๊ฐ enqueue๋๋ค. ํ์ฌ ํ์ ์๋ ์ ์ ์ ํ front๋ถํฐ ๋์ดํ๋ฉด C, E์ด๋ค. ์ด๋ฐ ๋ฐฉ๋ฒ์ผ๋ก ์ํํ๋ฉด ๊ทธ ๊ฒฐ๊ณผ๋ A, B, C, E, D ์์ผ๋ก ๋ฐฉ๋ฌธํ๊ฒ ๋๋ค.
UnweightedListGraph์ ๋ฐ๋ณต์ ํด๋์ค public Iterator iterator(int type, String start) throws GraphUnderflowException { if(start==null) throw new NullPointerException(โโฆโ); int v = index(start); if(v==-1) throw new GraphUnderflowException(โโฆโ); if(type==Graph.BFS||type==Graph.DFS) return new GraphIterator(type, v); else throw new GraphUnderflowException(โโฆโ); } protected class GraphIterator implements Iterator{ LinkedQueue traverseQueue; public GraphIterator(int type, int start){ โฆ } public boolean hasNext() { โฆ } public Object next() { โฆ } public void remove() { โฆ } private void BreadthFirstSearch(int start); private void DepthFirstSearch(int start); } public GraphIterator(int type, int start){ traverseQueue = new LinkedQueue(); if(type==Graph.BFS) BreadthFirstSearch(start); else DepthFirstSearch(start); }
๊ทธ๋ํ๋ ์์ ์ค๋ช ํ ๋ฐ์ ๊ฐ์ด ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ํํ ์ ์๋ค. ๋ฐ๋ผ์ ๋ฐ๋ณต์ ํด๋์ค ๋ ๋ ๊ฐ์ง ๋ฐฉ๋ฒ์ผ๋ก ์ํํ ์ ์๋๋ก ํด์ผ ํ๋ค. ์ฌ๊ธฐ์ traverseQueue๋ ๊ฐ ์ํ ๋ฐฉ๋ฒ์ ๊ตฌํํ ๋ ์ฌ์ฉํ๋ ํ๊ฐ ์๋๊ณ ๊ฐ ๋ฐฉ๋ฒ์ ์ํด ์ํ๋๋ ์ ์ ์ ์์๋ฅผ ์ ์ฅํ๋ ํ์ด๋ค. ๋ฐ๋ผ์ BreadthFirstSearch์ DepthFirstSearch ๋ฉ์๋ ๋ด์์๋ traverseQueue ์ธ์ ๊ฐ๊ฐ ๋ณ๋์ ์คํ๊ณผ ํ๊ฐ ํ์ํ๋ค.
์ฐ๊ฒฐ ์ฌ๋ถ ์ฐ๊ฒฐ ๊ทธ๋ํ(connected graph): ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ์๋ก ๋ค๋ฅธ ๋ชจ๋ ๊ทธ๋ํ ์์ ์ ์ ๋ค ์ฌ์ด์ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ ๊ทธ๋ํ DFS, BFS๋ฅผ ์ด์ฉํ์ฌ ์ฐ๊ฒฐ ์ฌ๋ถ๋ฅผ ํ์ธํ ์ ์๋ค. DFS(G, i): i ๋ ธ๋๋ก๋ถํฐ ์์ํ์ฌ ๋ฐฉ๋ฌธํ ๋ชจ๋ ์ ์ ์ด ๋ G = DFS(G, i)์ด๋ฉด ์ฐ๊ฒฐ ๊ทธ๋ํ ์ด๋ค ์ฐ๊ฒฐ ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ์ ์ฐจ์๊ฐ ์ง์์ด๋ฉด ์ฌ๊ธฐ์ ํ๋์ ๊ฐ์ ์ ์ ๊ฑฐํ์ฌ๋ ์ฌ์ ํ ์ฐ๊ฒฐ ๊ทธ๋ํ์ด๋ค.
์ฐ๊ฒฐ ๊ทธ๋ํ(connected graph)๋ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ์๋ก ๋ค๋ฅธ ๋ชจ๋ ์์ ์ ์ ๋ค ์ฌ์ด์ ๊ฒฝ ๋ก๊ฐ ์กด์ฌํ๋ ๊ทธ๋ํ๋ฅผ ๋งํ๋ค. ์ฐ๊ฒฐ ๊ทธ๋ํ๊ฐ ๋๊ธฐ ์ํด์๋ ๋ชจ๋ ์์ ์ ์ ๋ค ์ฌ์ด์ ๊ฐ ์ ์ด ์กด์ฌํด์ผ ํ๋ ๊ฒ์ ์๋๋ค. ๋ง์ฝ ๋ชจ๋ ์์ ์ ์ ๋ค ์ฌ์ด์ ๊ฐ์ ์ด ์กด์ฌํ๋ฉด ์ด ๊ทธ๋
- 168 -
ํ๋ฅผ ์์ ๊ทธ๋ํ๋ผ ํ๋ค. ๋ฌผ๋ก ์์ ๊ทธ๋ํ๋ ์ฐ๊ฒฐ ๊ทธ๋ํ์ด๋ค. ๊ทธ๋ํ๊ฐ ์ฐ๊ฒฐ๋์ด ์๋์ง ์ฌ๋ถ๋ ์ํ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ํ๋ณํ ์ ์๋ค. ๊น์ด์ฐ์ ๋๋ ๋๋น์ฐ์ ์ผ๋ก ์ํํ์์ ๋ ๋ฐฉ๋ฌธ ์ ์ ๋ค์ ์งํฉ์ด ๊ทธ๋ํ์ ๋ชจ๋ ์ ์ ๋ค์ ์งํฉ๊ณผ ์ผ์นํ์ง ์์ผ๋ฉด ์ด ๊ทธ๋ํ๋ ๋น์ฐ๊ฒฐ ๊ทธ๋ํ์ด๋ค.
Spanning Tree ๋ถ๋ถ ๊ทธ๋ํ(subgraph): ๋ค์์ด ์ฑ๋ฆฝํ๋ฉด G'(V', E')๋ G(V, E)์ ๊ทธ๋ํ ๋ถ๋ถ ๊ทธ๋ํ๋ผ ํ๋ค. V' โ V, E' โ E ์ ์ฅ ํธ๋ฆฌ(spanning tree): G์ ๋ถ๋ถ ๊ทธ๋ํ ์ค G์ ๋ชจ๋ ์ ์ ๋ค์ ํธ๋ฆฌ ํฌํจํ๋ ํธ๋ฆฌ A
A
C
B
D
E
A
B
C
D
A
C
B
D
E
๋ถ๋ถ ๊ทธ๋ํ์ด์ง๋ง ์ต์ ์ ์ฅํธ๋ฆฌ๊ฐ ์ ์ฅ ํธ๋ฆฌ๊ฐ ์๋ ์๋
C
B
D
E
์ต์ ์ ์ฅํธ๋ฆฌ
๋ถ๋ถ ๊ทธ๋ํ(subgraph)๋ ์ ๊ทธ๋ํ์ ์ ์ ์งํฉ ์ค์ ๋ถ๋ถ์งํฉ์ ์ทจํ๊ณ , ์ ๊ทธ๋ํ์์ ์ด๋ค ๋ถ๋ถ์งํฉ์ ์ํ ์ ์ ๋ค์ ์๋ ๊ฐ์ ์ค์ ์ผ๋ถ๋ฅผ ์ทจํด ๋ง๋ ๊ทธ๋ํ๋ฅผ ์ ๊ทธ๋ํ์ ๋ถ ๋ถ ๊ทธ๋ํ๋ผ ํ๋ค. ์ ์ฅ ํธ๋ฆฌ(spanning tree)๋ ์ ๊ทธ๋ํ์ ๋ถ๋ถ ๊ทธ๋ํ ์ค ์ ๊ทธ๋ํ์ ๋ชจ ๋ ์ ์ ์ ํฌํจํ๋ ํธ๋ฆฌ๋ฅผ ๋งํ๋ค. ์ ์ฅ ํธ๋ฆฌ๋ ์ํํ ๋ ์ฌ์ฉํ๋ ๊น์ด์ฐ์ ๋ฐฉ๋ฒ์ด๋ ๋ ๋น์ฐ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ๋ง๋ค ์๋ ์๋ค.
์ต์ ์ ์ฅ ํธ๋ฆฌ ์ต์ ์ ์ฅ ํธ๋ฆฌ(minimum spanning tree): ์ต์์ ๊ฐ์ ์๋ก ํธ๋ฆฌ ๊ตฌ์ฑ๋ ๊ทธ๋ํ์ ์ ์ฅ ํธ๋ฆฌ ๊ทธ๋ํ์ ์ ์ ์๊ฐ N์ด๋ฉด ์ต์ ์ ์ฅ ํธ๋ฆฌ์ ๊ฐ์ ์๋ N-1์ด๋ค. DFS, BFS๋ก ๋ง๋ค์ด์ง ์ ์ฅ ํธ๋ฆฌ๋ ์ต์ ์ ์ฅ ํธ๋ฆฌ๊ฐ ๋๋ค. ๊น์ด์ฐ์ ์ ์ฅํธ๋ฆฌ(depth first spanning tree) ์ ์ฅํธ๋ฆฌ ๋๋น์ฐ์ ์ ์ฅํธ๋ฆฌ(breadth first spanning tree) ์ ์ฅํธ๋ฆฌ A
A
A
C
B
D
E
์ ๊ทธ๋ํ
C
B
D
E
DFS(A)์ ์ ์ฅ ํธ๋ฆฌ
C
B
D
E
BFS(A)์ ์ ์ฅ ํธ๋ฆฌ
์ต์ ์ ์ฅ ํธ๋ฆฌ(minimum spanning tree)๋ ์ต์์ ๊ฐ์ ์๋ก ๊ตฌ์ฑ๋ ์ ์ฅ ํธ๋ฆฌ๋ฅผ ๋งํ๋ค. ๋ฐ๋ผ์ ๊ทธ๋์ ์ ์ ์ ์๊ฐ ๎ ์ด๋ฉด ์ต์ ์ ์ฅ ํธ๋ฆฌ์ ๊ฐ์ ์ ์๋ ๎ ๎ ๎ด ์ด๋ค. ๊น์ด์ฐ์ ๋ ๋ ๋๋น์ฐ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ๋ง๋ ์ ์ฅ ํธ๋ฆฌ๋ ์ต์ ์ ์ฅ ํธ๋ฆฌ๊ฐ ๋๋ค.
- 169 -
12.5. ๊ฐ์ค์น ๊ทธ๋ํ
๊ฐ์ค์น ๊ทธ๋ํ์ ํํ ๋ฐฉ๋ฒ 1. ์ธ์ ๋ฆฌ์คํธ ์์ธ
๋๊ฒฝ
๋ถ์ฐ
100
๋ถ๊ฒฝ
60
180
๋ถ์ฐ ์ ์ฃผ
๋ถ๊ฒฝ
180
๋๊ฒฝ ํ์ฝฉ
60
์์ ํ
1600
์์ธ
๋ถ๊ฒฝ
600
ํ์์ด
800
1200 100
ํ์์ด
120
ํ์ฝฉ
60
90
์์ ํ
๋๊ฒฝ
๋ถ์ฐ
-
40
20
์ ์ฃผ
40
๊ฐ์ค์น ๊ทธ๋ํ์ ํํ โ ๊ณ์ ๋ฐฉ๋ฒ 2. ์ธ์ ํ๋ ฌ 0
1
2
3
4
5
6
7
8
0
์์ธ
0
0
60
90
100
120
180
800
1600
-
9 -
1
๋ถ์ฐ
1
60
0
-1
20
-1
-1
-1
-1
-
-
2
์ ์ฃผ
2
90
-1
0
40
40
-1
-1
-1
-
-
3
๋๊ฒฝ
3
100
-1
-1
0
-1
-1
-1
1200
-
-
4
ํ์ฝฉ
4
-1
-1
-1
-1
0
60
-1
-1
-
-
5
๋ถ๊ฒฝ
5
180
-1
-1
-1
-1
0
-1
-1
-
-
6
ํ์์ด
6
-1
-1
-1
-1
-1
-1
0
600
-
-
7
์์ ํ
7
1600
-1
-1
1200
-1
-1
600
0
-
-
8
-
8
-
-
-
-
-
-
-
-
-
-
9
-
9
-
-
-
-
-
-
-
-
-
-
๊ฐ์ค์น ๊ทธ๋ํ๋ ๋น๊ฐ์ค์น ๊ทธ๋ํ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ธ์ ํ๋ ฌ ๋ฐฉ๋ฒ์ด๋ ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ๋ฒ์ผ๋ก ํํํ ์ ์๋ค. ๋ค๋ง ์ธ์ ๋ฆฌ์คํธ ๋ฐฉ๋ฒ์ ๊ฒฝ์ฐ์๋ ์ธ์ ๋ฆฌ์คํธ์ ๊ฐ ๋ ธ๋์ ๊ฐ์ค์น ๊ฐ์ ๋ํ๋ด๊ธฐ ์ํ ์ ๋ณด๊ฐ ์ถ๊ฐ๋๋ฉฐ, ์ธ์ ํ๋ ฌ์ ๊ฐ ํญ์๋ ๊ฐ์ค์น ๊ฐ์ด ์ ์ฅ๋๋ค. ์ธ์ ํ๋ ฌ ์์ ๊ฐ์ ์ด ์กด์ฌํ์ง ์๋ ๊ฒฝ์ฐ์๋ ๊ฐ์ค์น ๋ฒ์์ ํฌํจ๋์ง ์๋ ๊ฐ์ผ๋ก ๋ํ๋ด์ผ ํ๋ค. ์ด ์ ์์๋ -1 ๊ฐ์ ์ด์ฉํ์ฌ ๊ฐ์ ์ด ์กด์ฌํ์ง ์๋๋ค๋ ๊ฒ์ ๋ํ๋ธ๋ค. ํ์ง๋ง ์ธ์ ํ๋ ฌ ์ ์ฌ์ฉํ ๊ฒฝ์ฐ์๋ ๊ฐ์ ์ด ์กด์ฌํ์ง ์๋๋ค๋ ๊ฒ์ ๋ํ๋ด๊ธฐ ์ํ ์ ์ ํ ๊ฐ์ด ์์ ์๋ ์๋ค.
- 170 -
public abstract MatrixGraph implements Graph{ public static final int NULLEDGE = -1; protected class GraphIterator implements Iterator{ โฆ private void setup(int capacity){ } graph = new String[capacity]; protected String[] graph; adjMatrix = new int[capacity][capacity]; protected int size = 0; // ์ ์ ์ ๊ฐ์ for(int i=0; i<capacity; i++) public MatrixGraph(){ for(int j=0; j<capacity; j++) setup(DEF_CAPACITY); if(i!=j) adjMatrix[i][j] = NULLEDGE; } else adjMatrix[i][j] = 0; public MatrixGraph(int capacity){ } if(capcity>0) setup(capacity); else setup(DEF_CAPACITY); } private void setup(int capacity){ โฆ } ์ธ์ ํ๋ ฌ ํํ ๋ฐฉ๋ฒ์ ์ฌ์ฉ public boolean isEmpty(){ return (size == 0); } public boolean isFull(){ return (size == graph.length); } public void clear() { โฆ } protected int index(String label){ โฆ } // ์ ์ ์ ์์ธ ์ฐพ๊ธฐ public void insertVertex(String label) throws GraphOverflowException { โฆ } public abstract void removeVertex(String label) throws GraphUnderflowException; public abstract void removeEdge(String from, String to) throws GraphUnderflowException; public boolean search(int type, String from, String to) throws GraphUnderflowException { โฆ } public Iterator iterator(int type, String start) throws GraphUnderflowException { โฆ } }
์ด ์ ์์๋ ์ธ์ ํ๋ ฌ ๋ฐฉ๋ฒ์ ์ด์ฉํ์ฌ ์ ๋ฐฉํฅ ๊ฐ์ค์น ๊ทธ๋ํ๋ฅผ ๊ตฌํํด๋ณธ๋ค. ๋ฌด๋ฐฉํฅ ๋น๊ฐ ์ค์น ๊ทธ๋ํ๋ฅผ ๊ตฌํํ ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ์ ๋ค์ ์ ๋ ฌํ์ฌ ์ ์งํ์ง ์๋๋ค. ์ด๋ฅผ ์ํด ์ฐ ์ Graph ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ์ถ์ ํด๋์ค MatrixGraph๋ฅผ ์ ์ํ๋ค. MatrixGraph๋ ์์ ์ดํด๋ณธ ListGraph์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ ์ ์ ์ถ๊ฐ, ๊ฒ์, ์ํ๋ ๊ฐ์ ์ ๊ฐ์ค์น ์ฌ๋ถ, ๋ฐฉํฅ์ฑ ์ฌ ๋ถ์ ๋ฌด๊ดํ๊ฒ ๊ตฌํํ ์ ์๋ค.
WeightedMatrixGraph, UnweightedMatrixGraph public abstract class WeightedMatrixGraph extends MatrixGraph{ public WeightedMatrixGraph(){ super(); } public WeightedMatrixGraph(int capacity){ super(capacity); } public abstract void insertEdge(String from, String to, int weight); } public abstract class UnweightedMatrixGraph extends MatrixGraph{ public WeightedMatrixGraph(){ super(); } public WeightedMatrixGraph(int capacity){ super(capacity); } public abstract void insertEdge(String from, String to); }
- 171 -
DirectedWeightedMatrixGraph public class DirectedWeightedMatrixGraph implements WeightedListGraph{ public DirectedWeightedMatrixGraph(){ super(); } public DirectedWeightedMatrixGraph(int capacity){ super(capacity); } public void removeVertex(String label) throws GraphUnderflowException { โฆ } public void removeEdge(String from, String to) throws GraphUnderflowException { โฆ } public void insertEdge(String from, String to, int weight) throws GraphUnderflowException { โฆ } }
Insert Vertex public void insertVertex(String label) throws GraphOverflowException{ if(label==null) throw new NullPointerException(โโฆโ); if(isFull()) throw new GraphOverflowException(โโฆโ); graph[size] = label; size++; } // MatrixGraph: insertVertex
์ ์ ๋ค์ ์ ๋ ฌํ์ฌ ์ ์งํ์ง ์๊ธฐ ๋๋ฌธ์ ์ ์ ์ ์ถ๊ฐ๋ ๋ฌด๋ฐฉํฅ ๋น๊ฐ์ค์น ๊ทธ๋ํ์ ๋ง์ฐฌ๊ฐ ์ง๋ก ์ ์ ๋ค์ ์ด๋ฆ์ ์ ์ฅํ๊ณ ์๋ ๋ฐฐ์ด์ ๋์ ์ถ๊ฐํ๋ค.
- 172 -
Insert Edge public void insertEdge(String from, String to, int weight) throws GraphUnderflowException{ if(from==null||to==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new GraphUnderflowException(โโฆโ); int v1 = index(from); int v2 = index(to); if(v1==-1) throw new GraphUnderflowException(โโฆโ); if(v2==-1) throw new GraphUnderflowException(โโฆโ); adjMatrix[v1][v2] = weight; } // DirectedWeightedMatrixGraph: insertEdge
์ ๋ฐฉํฅ ๊ฐ์ค์น ๊ทธ๋ํ์ ๊ฒฝ์ฐ์๋ ๋ฌด๋ฐฉํฅ๊ณผ ๋ฌ๋ฆฌ A์์ B๋ก ๊ฐ๋ ์ํฌ๋ฅผ ์ถ๊ฐํ ๋ B์์
A๋ก ๊ฐ๋ ์ํฌ๋ฅผ ์๋์ผ๋ก ์ถ๊ฐํ์ง ์๋๋ค.
Remove Vertex public void removeVertex(String label) throws GraphUnderflowException{ if(label==null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new GraphUnderflowException(โโฆโ); int v = index(label); if(v == -1) throw new GraphUnderflowException(โโฆโ); size--; graph[v] = graph[size]; for(int i=0;i<size; i++){ adjMatrix[v][i] = adjMatrix[size][i]; adjMatrix[size][i] = NULLEDGE; adjMatrix[i][v] = adjMatrix[i][size]; adjMatrix[i][size] = NULLEDGE; } adjMatrix[v][v] = NULLEDGE; }// DirectedWeightedMatrixGraph: insertEdge
์ธ์ ํ๋ ฌ ๋ฐฉ์์์ ์ ์ ์ ์ ๊ฑฐ๋ ๋ฐฐ์ด์ ์ด์ฉํ ๋น์ ๋ ฌ ๋ฆฌ์คํธ์์ ์ ๊ฑฐ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋งจ ๋ง์ง๋ง์ ์๋ ์ ์ ์ผ๋ก ์ ๊ฑฐํ๊ณ ์ ํ๋ ์ ์ ์ ๋ฎ์ด ์ฐ๋ฉด ๋๋ค. ์ด ๋ ์ง์ ๊ณผ ์ง์ถ ์ํฌ ๋ฅผ ๋ชจ๋ ๊ณ ๋ คํด์ผ ํ๋ค.
12.6. ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ ์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ (shortest path problem)๋ ์ ์ ๊ฐ์ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฌธ์ ๋ฅผ ๋งํ๋ค. ์งง์ ๊ฒฝ๋ก๋ ๋น๊ฐ์ค์น ๊ทธ๋ํ์์๋ ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ๊ฒ์ ๋งํ๋ฉฐ, ๊ฐ์ค์น ๊ทธ๋ํ ์์๋ ๊ฒฝ๋ก์ ์๋ ๊ฐ์ ๋ค์ ๊ฐ์ค์น์ ํฉ์ด ๊ฐ์ฅ ์์ ๊ฒ์ ๋งํ๋ค.
- 173 -
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ ์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ : ๋ฌธ์ ์ ์ ๊ฐ์ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ๋ฌธ์ ์ด ๋ฌธ์ ๋ ๊ทธ๋ํ์ ์ข ๋ฅ์ ๋ฐ๋ผ ๋ค์ํ ์์ฉ ๋ฌธ์ ๊ฐ ์กด์ฌํ๋ค. ๊ทธ๋ํ๊ฐ ์ ํ ๊ทธ๋ํ์ธ์ง ๋ฌดํ ๊ทธ๋ํ์ธ์ง? ์ ํ ๊ทธ๋ํ: ๋ ธ๋์ ์๊ฐ ์ ํํ ๊ทธ๋ํ ๊ทธ๋ํ๊ฐ ์ ๋ฐฉํฅ์ธ์ง ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์ธ์ง? ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ๋ชจ๋ ๊ฐ์ ๊ฒฝ์ฐ, ๊ฐ์ค์น๊ฐ ๋ชจ๋ ์์์ธ ๊ฒฝ์ฐ, ์์์ ๊ฐ์ค์น๊ฐ ์๋ ๊ฒฝ์ฐ(๊ฐ์ฅ ์ด๋ ค์)
์ต๋จ ๊ฒฝ๋ก ๋ฌธ์ ๋ ๊ทธ๋ํ์ ์ข ๋ฅ์ ๋ฐ๋ผ ๊ทธ๊ฒ์ ํด๊ฒฐ์ฑ ์ด ๋ค๋ฅด๋ค. ํนํ ๊ทธ๋ํ๊ฐ ์ ๋ฐฉํฅ์ธ ์ง ๋ฌด๋ฐฉํฅ์ธ์ง์ ๋ฐ๋ผ ์๊ณ ๋ฆฌ์ฆ์ด ๋ค๋ฅด๊ฒ ์ ์ฉ๋์ด์ผ ํ๋ฉฐ, ๊ฐ์ค์น๊ฐ ์๋ ๊ฒฝ์ฐ์๋ ๊ฐ์ค์น ๊ฐ์ ์ํด ์ต๋จ ๊ฒฝ๋ก๊ฐ ๋ค๋ฅด๊ฒ ๋๋ฏ๋ก ๋์ฑ ์ด๋ ต๋ค. ๊ฐ์ฅ ์ด๋ ค์ด ๊ฒฝ์ฐ๋ ์ ๋ฐฉํฅ ๊ฐ์ค์น ๊ทธ ๋ํ์์ ์์์ ๊ฐ์ค์น๋ฅผ ๊ฐ์ง ์ ์๋ ๊ฒฝ์ฐ์ด๋ค.
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 1. ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ๊ฐ์ ์ ํ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ์ ์ s์์ ์ ์ t๊น์ง ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ์๋ผ. BFS ๊ฒ์์ ์ด์ฉํ๋ฉด ์ฐพ์ ์ ์๋ค. Moore ์๊ณ ๋ฆฌ์ฆ: ์๊ณ ๋ฆฌ์ฆ ์ ์ ์ ์๋ n์ด๋ผ ํ์. ๋จ๊ณ 1. โฮป[v] = -1 ฮป[s] = 0; ๋จ๊ณ 2. l = 0; ๋จ๊ณ 3. ฮป[v] = l์ธ ์ ์ v์ ์ธ์ ํ ๋ชจ๋ ์ ์ u ์ค ฮป[u]๊ฐ -1์ด๋ฉด ฮป[u] = l +1, ์ธ์ ํ ๋ ธ๋๊ฐ ์์ผ๋ฉด ์ข ๋ฃํ๋ค. ๋จ๊ณ 4. ฮป[t] != -1์ด๋ฉด ์ข ๋ฃํ๋ค. ๋จ๊ณ 5. l = l +1; ๋จ๊ณ 3๋ถํฐ ๋ฐ๋ณต
๋จผ์ ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ๊ฐ์ ์ ํ ๋ฌด๋ฐฉํฅ ๊ทธ๋ํ์์ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ ์ด ํด๋ณธ๋ค. ์ด ์๊ณ ๋ฆฌ์ฆ์ Moore๊ฐ ์ ์ํ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก์ ๋๋น์ฐ์ ๋ฐฉ๋ฒ์ ์ด์ฉํ๋ค.
- 174 -
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 1. โ ๊ณ์ A์์ D๊น์ง
A
B
E
C
D
C์์ A๊น์ง
A
B
C
D
E
A
B
C
D
E
-1
-1
-1
-1
-1
-1
-1
-1
-1
-1
A
B
C
D
E
A
B
C
D
E
0
-1
-1
-1
-1
-1
-1
0
-1
-1
A
B
C
D
E
A
B
C
D
E
0
1
-1
-1
1
-1
1
0
1
1
A
B
C
D
E
A
B
C
D
E
0
1
2
2
1
2
1
0
1
1
Moore์ ์๊ณ ๋ฆฌ์ฆ์ ์์ ๋ฅผ ํตํด ์ค๋ช ํ๋ฉด ๋ค์๊ณผ ๊ฐ๋ค. ๋จผ์ ์ ์ ๊ฐ์๋งํผ์ ์ ์ ๋ฐฐ์ด ์ ๋ง๋ ๋ค. ๋ฐฐ์ด์ ๊ฐ ํญ์ ์ฐ์ -1๋ก ์ด๊ธฐํํ๊ณ , ์ถ๋ฐ ์ ์ ์ ํด๋นํ๋ ํญ์ 0์ผ๋ก ์ด๊ธฐํ ํ๋ค. ๊ทธ ๋ค์ ์ถ๋ฐ ์ ์ ๊ณผ ์ธ์ ํ ์ ์ ์ ํญ์ ๊ฐ์ 1๋ก ๋ฐ๊พผ๋ค. ์ด ์์ ์์๋ ์ถ๋ฐ ์ ์ ์ด A์ด๋ฏ๋ก A์ ํญ ๊ฐ์ 0์ผ๋ก ์ด๊ธฐํ๋์๊ณ , A์ ์ธ์ ์ ์ ์ธ B์ E๋ 1 ๊ฐ์ ๊ฐ์ง๊ฒ ๋ ๋ค. ๊ทธ ๋ค์ ๋ฐฐ์ด์ ํญ ๊ฐ์ด 1์ธ ๊ฐ ์ ์ ์ ๋ํด ๊ทธ๊ฒ์ ์ธ์ ์ ์ ์ ์ฐพ์ ์ด ์ ์ ๋ค์ ๋ฐฐ ์ด ๊ฐ์ 2๋ก ๋ฐ๊พผ๋ค. ๋ฐ๋ผ์ B์ ์ธ์ ์ ์ ์ธ C์ D๋ 2 ๊ฐ์ ๊ฐ์ง๊ฒ ๋๋ค. ์ด๋ ๊ฒ ํ์ฌ ์ฐพ๊ณ ์ ํ๋ ์ ์ ๊น์ง ๋๋ฌํ๋ฉด ๊ทธ ๋ ๋ฐฐ์ด์ ํญ์ ์๋ ๊ฐ์ด ์ต๋จ ๊ฒฝ๋ก์ ๊ฐ์ด ๋๋ค.
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 2. ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์์์ธ ์ ํ ์ ๋ฐฉํฅ ๊ทธ๋ํ์์ ์ ์ s์์ ์ ์ t๊น์ง ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ์๋ผ. Dijkstra ์๊ณ ๋ฆฌ์ฆ ์ ์ ์ ์๋ n์ด๋ผ ํ๊ณ , ์ ์ ๋ค์ ์งํฉ์ V๋ผ ํ์. ๋จ๊ณ 1. โฮป[v] = โ; ฮป[s] = 0; ๋จ๊ณ 2. T ร V ๋จ๊ณ 3. T ์ค์ ฮป[u]๊ฐ ์ต์์ธ ์ ์ ์ u๋ผ ํ์. ๋จ๊ณ 4. u๊ฐ t์ด๋ฉด ์ข ๋ฃ e โ v ์ ๋ํด vโT์ด๊ณ ๋จ๊ณ 5. ์ ์ u์์ ์ง์ถํ๋ ๋ชจ๋ ๊ฐ์ u โฏโฏ ฮป[v] > ฮป[u]+l(e)์ด๋ฉด ฮป[v] = ฮป[u]+l(e) ๋จ๊ณ 6. T ร T - {u}, ๋จ๊ณ 3๋ถํฐ ๋ฐ๋ณต
๋ ๋ฒ์งธ๋ก ์ดํด๋ณผ ์๊ณ ๋ฆฌ์ฆ์ ๋ชจ๋ ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์์์ธ ์ ๋ฐฉํฅ ๊ทธ๋ํ์ ์ ์ฉํ ์ ์ ๋ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก์ Dijkstra๊ฐ ์ ์ํ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
- 175 -
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 2. โ ๊ณ์ A์์ D๊น์ง์ ์ต๋จ ๊ฒฝ๋ก์ ์
A
5
2 3 B
E 7 1
6
B
C
D
E
0
99
99
99
99
A
B
C
D
E
0
2
3
99
5
A
B
C
D
E
0
2
3
8
5
A
B
C
D
E
0
2
3
8
4
A
B
C
D
E
0
2
3
6
4
T = {A,B,C,D,E}
T = {B,C,D,E}
C
3 D
A
2
T = {C,D,E}
T = {D,E}
T = {D}
Dijkstra ์๊ณ ๋ฆฌ์ฆ์ Moore ์๊ณ ๋ฆฌ์ฆ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ทธ๋ํ์ ์ ์ ์๋งํผ์ ๋ฐฐ์ด์ ์ฌ์ฉํ ๋ค. ์ฐจ์ด์ ์ ๋ฐฐ์ด์ ๊ฐ ๊ฐ์ -1๋ก ์ด๊ธฐํ๋์ง ์๊ณ โ ๋ก ์ด๊ธฐํ ํ๋ค. ์ฆ, ๊ฒฝ๋ก์ ๊ฐ์ค์น ๊ฐ๋ค์ ํฉ์ด โ ๋ณด๋ค๋ ์ ๋ ํด ์ ์๋๋ก โ ๋ฅผ ์ค์ ํด์ผ ํ๋ค. ์ถ๋ฐ ์ ์ ์ Moore ์๊ณ ๋ฆฌ ์ฆ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก 0์ผ๋ก ์ด๊ธฐํํ๋ค. ๊ทธ ๋ค์ ์ถ๋ฐ ์ ์ ์์ ์ง์ถํ๋ ๋ชจ๋ ๊ฐ์ ์ด ์๋ ์ ์ ์ ๋ํด ๊ทธ ๊ฐ์ ์ ๊ฐ์ค์น๋ฅผ ์ ์ ์ ๋ฐฐ์ด ๊ฐ์ผ๋ก ์ ์ฅํ๋ค. ์ ์ฌ๋ผ์ด๋์์ A๊ฐ ์ถ๋ฐ ์ ์ ์ด๋ฏ๋ก ๊ทธ๊ฒ์ ์ธ์ ํ B, C, E๋ ๊ฐ๊ฐ 2, 3, 5 ๊ฐ์ ๊ฐ์ง๊ฒ ๋๋ค. ๊ทธ ๋ค์ ๋ฐฐ์ด์ ๊ฐ ์ค ์์ ๊ฐ์ฅ ์์ ๊ฐ์ ์ ํํ์ฌ ๊ทธ ์ ์ ๊ณผ ์ด์ํ ์ ์ ์ ๋ํด ๋ฐฐ์ด ๊ฐ์ ๊ฐฑ์ ํ๋ค. ์ด ๋ ์๋กญ๊ฒ ๊ณ์ฐํ ๊ฒฝ๋ก์ ๊ฐ์ด ์ด๋ฏธ ์ ์ฅ๋์ด ์๋ ๊ฒฝ๋ก์ ๊ฐ๋ณด๋ค ํฌ๋ฉด ๊ฐฑ์ ํ์ง ์๋๋ค. ์ ์ฌ๋ผ์ด๋์์ (A, B), (B, C) ๊ฒฝ๋ก์ ๊ฐ์ (A, C) ๊ฒฝ๋ก์ ๊ฐ๋ณด๋ค ํฌ๊ธฐ ๋๋ฌธ์ (A, B), (B, C) ๊ฒฝ๋ก๋ ๋ฐฐ์ด์ ๋ฐ์ํ์ง ์๋๋ค. ์ด ๊ณผ์ ์ ๋ชจ๋ ์ ์ ์ ๋ค ๊ณ ๋ คํ ๋๊น์ง ๋ฐ๋ณตํ๋ค.
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 3. A
๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์์๊ฐ ๋ ์ ์๋ ์ ํ ์ ๋ฐฉํฅ ๊ทธ๋ํ์์ ์ ์ s์์ ์ ์ t๊น์ง ๊ธธ์ด๊ฐ ๊ฐ์ฅ ์งง์ ๊ฒฝ๋ก๋ฅผ ์ฐพ์๋ผ. ์์ ์ฃผ๊ธฐ๊ฐ ์กด์ฌํ์ง ์์ n์ด ์ ์ ์ ์์ผ ๋, ์์ ์ฃผ๊ธฐ๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด๋ ์ต๋ n-1์ด๋ค. ๊ธฐ๋ณธ ์๊ฐ ๊ธธ์ด๊ฐ 1์ธ ๊ฒ๋ถํฐ n-1์ธ ๊ฒ๊น์ง ๋ชจ๋ ๊ตฌํ๋ค.
5 3 B -2 C
A
5 3 B -2 1 C
์์ ์ฃผ๊ธฐ๊ฐ ์กด์ฌํ๋ ๊ฒฝ์ฐ
๋ง์ง๋ง์ผ๋ก ๊ฐ์ ์ ๊ฐ์ค์น๊ฐ ์์๊ฐ ๋ ์ ์๋ ์ ๋ฐฉํฅ ๊ทธ๋ํ์ ์ ์ฉํ ์ ์๋ ์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ์ ์ดํด๋ณธ๋ค. ๊ทธ๋ฐ๋ฐ ๊ทธ๋ํ ๋ด์ ์์ ์ฃผ๊ธฐ๊ฐ ์กด์ฌํ๋ฉด ์ต๋จ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์์ผ ๋ฏ๋ก ์์ ์ฃผ๊ธฐ๊ฐ ์๋ ๊ฒฝ์ฐ์๋ง ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ์ ์ ์๋ค. ๋ํ ๎ฒ ์ด ๊ทธ๋ํ์ ์๋ ์ ์
- 176 -
์ ์์ผ ๋, ์์ ์ฃผ๊ธฐ๊ฐ ์์ผ๋ฉด ์ต๋จ ๊ฒฝ๋ก์ ๊ธธ์ด๋ ์ต๋ ๎ฒ ๎ ๎ด ์ด๋ค. ์ด๊ฒ์ ๊ฒฝ๋ก์ ๊ธธ์ด ๊ฐ ๎ฒ ๎ ๎ด ์ ๋์ผ๋ฉด ์ด ๊ฒฝ๋ก์ ๋ ๋ฒ ์ด์ ํฌํจ๋ ์ ์ ์ด ์กด์ฌํ๊ฒ ๋๋ฏ๋ก ํญ์ ์ด ๊ฒฝ๋ก๋ณด๋ค ๋ ๋ ์งง์ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ ์ ์๋ค.
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 3. โ ๊ณ์ D
5 -1
3
๊ฒฝ๋ก์ ๊ธธ์ด=3
๊ฒฝ๋ก์ ๊ธธ์ด=1
-2 A
A
B
C
D
E
A
B
C
D
E
0
99
99
99
99
99
99
99
0
99
A
B
C
D
E
A
B
C
D
E
0
5
3
-2
99
99
99
99
0
7
3
B -2
E
๊ฒฝ๋ก์ ๊ธธ์ด=2
-1
C
๊ฒฝ๋ก์ ๊ธธ์ด=4
A
B
C
D
E
A
B
C
D
E
99
99
99
4
99
99
99
99
99
3
A
B
C
D
E
99
1
99
4
2
A
B
C
D
E
99
1
99
4
1
Bellman๊ณผ Ford๊ฐ ์ ์ํ ์๊ณ ๋ฆฌ์ฆ์ ๊ทธ๋ํ์ ๎ฒ ๊ฐ์ ์ ์ ์ด ์์ ๋ ์ถ๋ฐ ์ ์ ๋ถํฐ ๊ฒฝ๋ก ๊ฐ 1์ธ ๊ฒ๋ถํฐ ๎ฒ ๎ ๎ด ๊ฒ๊น์ง ๋ชจ๋ ๊ตฌํ ๋ค์ ์ด๋ค์ ๋น๊ตํ์ฌ ์ต๋จ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋๋ค. ์ ์์ ์ ์ฐ์ A๋ฅผ ์ถ๋ฐ ์ ์ ์ผ๋ก ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ 1์ธ ๋ชจ๋ ๊ฒฝ๋ก๋ฅผ ๊ตฌํ๋ค. ๊ทธ ๋ค์์ ๊ฒฝ๋ก์ ๊ธธ์ด ๊ฐ 1์ธ ๊ฒฝ๋ก๊ฐ ์กด์ฌํ๋ฉด ์ด ๊ฒฝ๋ก์ ๋ ๊ฒฝ๋ก์์ ์ง์ถํ๋ ๊ฐ์ ์ ๊ณ ๋ คํ๋ฉด ๊ฒฝ๋ก์ ๊ธธ์ด๊ฐ
2์ธ ๊ฒฝ๋ก์ ๊ฐ์ ๊ตฌํ ์ ์๋ค. ์ด ๊ณผ์ ์ ๎ฒ ๎ ๎ด ์ธ ๊ฒฝ๋ก์ ๊ฐ๋ค์ ๋ชจ๋ ๊ตฌํ ๋๊น์ง ๋ฐ๋ณตํ ๋ค.
์ต๋จ ๊ฒฝ๋ก ์๊ณ ๋ฆฌ์ฆ 3. โ ๊ณ์ Bellman๊ณผ Bellman๊ณผ Ford ์๊ณ ๋ฆฌ์ฆ Distk[u]: ์์ ์ ์ v์์ u๊น์ง ์ต๋ k๊ฐ์ ์ํฌ๋ฅผ ํฌํจํ ์ ์๋ ์ต๋จ ๊ฒฝ๋ก Dist k [u] โ min(Dist k โ1 [ u],min(Dist k โ1 [i ] + weight[ i , u])) D
5 -1
3
3
B -2 C
E
Dist1
A
B
C
D
E
A
0
5
3
-2
99
A
B
C
D
E
B
99
0
99
-1
99
0
5
3
-2
99
C
99
-2
99
99
-1
D
99
99
99
99
3
E
99
99
99
99
99
-2 A
-1
- 177 -
Dist2 ๊ฐ ์ ์ ์ ์ง์ ์ฐจ์ ๊ณ ๋ ค(์ด) Dist2[B] = min(5, (3+(-2))=1 Dist2[D] = min(-2, (5+(-1))=-2 Dist2[E] = min(99, min(3+(-1), -2+3))=1
์ 13์ฅ 2-3 ํธ๋ฆฌ, 2-3-4 ํธ๋ฆฌ ์ด ์ฅ์์๋ 2-3 ํธ๋ฆฌ, 2-3-4 ํธ๋ฆฌ์ ๋ํด ์ดํด๋ณธ๋ค.
13.1. ๊ต์ก๋ชฉํ ์ด ์ฅ์ ๊ต์ก๋ชฉํ๋ ๋ค์๊ณผ ๊ฐ๋ค.
๊ต์ก๋ชฉํ 2-3 ํธ๋ฆฌ 2-3-4 ํธ๋ฆฌ 2-3 ํธ๋ฆฌ์ 2-3-4 ํธ๋ฆฌ๋ AVL ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ํจ์จ์ ์ธ ๊ฒ์์ ์ํ ๊ท ํ ํธ๋ฆฌ ๊ตฌ์กฐ์ด๋ค.
13.2. 2-3 ํธ๋ฆฌ AVL ํธ๋ฆฌ๋ ํธ๋ฆฌ์ ๋์ด๊ฐ ๊ฑฐ์ ์ต์ ๋์ด์ ๊ฐ๊น๋๋ก ์ ์งํด ์ฃผ์ง๋ง ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๋งค์ฐ ๋ณต์กํ๋ค. 2-3 ํธ๋ฆฌ๋ ์ฝ์ ๊ณผ ์ญ์ ์ฐ์ฐ์ด AVL ํธ๋ฆฌ๋ณด๋ค๋ ๊ฐ๋จํ๊ณ ๊ฐ ์ฐ์ฐ์ ์๊ฐ๋ณต์ก๋ ๊ฐ ๎ฅ๎จ๎ ๎ต๎ฒ ์ธ ํธ๋ฆฌ ๊ตฌ์กฐ์ด๋ค.
2-3 ํธ๋ฆฌ 2-3 ํธ๋ฆฌ: ํธ๋ฆฌ ๋ค์ ์ธ ๊ฐ์ง ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํธ๋ฆฌ ์กฐ๊ฑด 1. ๋ชจ๋ ์ค๊ฐ๋ ธ๋๋ค์ ์์ ์๊ฐ 2 ๋๋ 3์ด๋ค. ์กฐ๊ฑด 2. ๋ชจ๋ ๋จ๋ง๋ ธ๋๊ฐ ๊ฐ์ ๋ ๋ฒจ์ ๋ ๋ฒจ ์๋ค. ์กฐ๊ฑด 3. ๋ค์ ์ฌ๋ผ์ด๋์ ์๋ ํํ ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค. ๋ง์กฑ ์์์ด ๋์ธ ๋ ธ๋๋ฅผ 2-๋ ธ๋๋ผ ๋ ธ๋ ํ๊ณ , ์์์ด ์ ์ธ ๋ ธ๋๋ฅผ 3-๋ ธ๋๋ผ ๋ ธ๋ ํ๋ค. 2-3 ํธ๋ฆฌ๋ ์ด์ง ํธ๋ฆฌ๋ ์๋๋ค. ํ์ง๋ง ์ด์ง ํธ๋ฆฌ๋ 2-3 ํธ๋ฆฌ์์ 3-๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ๋ก ๋ณผ ์ ์๋ค. ๋ฐ๋ผ์ 2-3 ํธ๋ฆฌ๋ ๊ฐ์ ๋์ด์ ํฌํ ์ด์ง ํธ๋ฆฌ๋ณด๋ค๋ ๋ง์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค. ์ฆ, ๋์ด๊ฐ h์ด๋ฉด ์ต์ํ 2h+1-1 ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค. n ๋ ธ๋๋ฅผ ๊ฐ์ง 2-3 ํธ๋ฆฌ์ ๋์ด๋ ๊ฐ์ ๊ฐ์์ ๋ ธ๋๋ก ๋ง๋ค ์ ์๋ ์์ ์ด์ง ํธ๋ฆฌ์ ๋์ด์ธ โฃโข log 2 n โฆโฅ ๋ณด๋ค ํด ์ ์๋ค.
- 179 -
2-3 ํธ๋ฆฌ๋ ๋ค์ ์ธ ๊ฐ์ง ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํ๋ค. z ์ฒซ์งธ, ๋ชจ๋ ์ค๊ฐ๋ ธ๋๋ค์ ์์ ์๊ฐ 2 ๋๋ 3์ด๋ค. ์ด ๋ ์์ ์๊ฐ 2์ธ ๋ ธ๋๋ฅผ 2-๋ ธ๋ ๋ผ ํ๊ณ , ์์ ์๊ฐ 3์ธ ๋ ธ๋๋ฅผ 3-๋ ธ๋๋ผ ํ๋ค. 3-๋ ธ๋๊ฐ ์กด์ฌํ ์ ์์ผ๋ฏ๋ก 2-3 ํธ๋ฆฌ ๋ ์ด์ง ํธ๋ฆฌ๊ฐ ์๋ ์ ์๋ค. z ๋์งธ, ๋ชจ๋ ๋จ๋ง๋ ธ๋๋ค์ด ๊ฐ์ ๋ ๋ฒจ์ ์์นํ๋ค. z ์ ์งธ, ์์ ์๊ฐ ๋์ธ ๊ฒฝ์ฐ์๋ ๋ ธ๋์ ์๋ ๊ฐ์ ์ผ์ชฝ ๋ถ๋ถํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด ๋ค ํฌ๊ณ , ์ค๊ฐ ๋ถ๋ถํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ์์์ผ ํ๋ค. ์์ ์๊ฐ ์ ์ธ ๊ฒฝ์ฐ์ ๋ ๋ ธ๋์ ์๋ ์์ ๊ฐ์ ์ผ์ชฝ ๋ถ๋ถํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ํฌ๊ณ , ์ค๊ฐ ๋ถ๋ถํธ ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ์์์ผ ํ๋ค. ๋ํ ๋ ธ๋์ ์๋ ํฐ ๊ฐ์ ์ค๊ฐ ๋ถ๋ถํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ํฌ๊ณ , ์ค๋ฅธ์ชฝ ๋ถ๋ถํธ๋ฆฌ์ ์๋ ๋ ธ๋๋ค์ ๊ฐ๋ณด๋ค๋ ์์์ผ ํ๋ค. ์์ ์ธ๊ธํ ๋ฐ์ ๊ฐ์ด 2-3 ํธ๋ฆฌ๋ ์ด์ง ํธ๋ฆฌ๋ ์๋๋ค. ํ์ง๋ง 2-3 ํธ๋ฆฌ์์ 3-๋ ธ๋๋ค์ ๋ชจ๋ ์ ๊ฑฐํ๋ฉด ์ด์ง ํธ๋ฆฌ๊ฐ ๋๋ค. ๋ฐ๋ผ์ ๊ฐ์ ๋์ด์ ํฌํ ์ด์ง ํธ๋ฆฌ๋ณด๋ค๋ 2-3 ํธ๋ฆฌ๊ฐ ๋ง ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค. ๊ทธ๋ฐ๋ฐ ๋์ด๊ฐ ๎ฌ ์ธ ํฌํ ์ด์ง ํธ๋ฆฌ๋ ๎ต๎ฌ ๎ ๎ด ๎ ๎ด ๊ฐ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ฏ๋ก ๋ ์ด๊ฐ ๎ฌ ์ธ 2-3 ํธ๋ฆฌ๋ ๎ต๎ฌ ๎ ๎ด ๎ ๎ด ๊ฐ๋ณด๋ค๋ ๋ง์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ค. ๋ค์ ๋งํ๋ฉด ๎ฒ ๊ฐ์ ๋ ธ๋๋ก ๋ง ๋ค ์ ์๋ ์์ ์ด์ง ํธ๋ฆฌ์ ๋์ด๋ ๎ฅ๎จ๎ ๎ต๎ฒ ์ด๋ฏ๋ก ๎ฒ ๊ฐ์ ๋ ธ๋๋ก ๋ง๋ค ์ ์๋ 2-3 ํธ๋ฆฌ ์ ๋์ด๋ ๎ฅ๎จ๎ ๎ต๎ฒ ๋ณด๋ค๋ ์๋ค.
2-3 ํธ๋ฆฌ โ ๊ณ์ 2-3 ํธ๋ฆฌ์ ํํ S
S
L
empty 2-3 tree
TL
TR
TL < S < TR TL: 2-3 ํธ๋ฆฌ TR: 2-3 ํธ๋ฆฌ
TL
TM
TR
TL < S < TM TM < L < TR TL: 2-3 ํธ๋ฆฌ TM: 2-3 ํธ๋ฆฌ TR: 2-3 ํธ๋ฆฌ
- 180 -
class Tree23Node{ Object small; Object large; Tree23Node left; Tree23Node mid; Tree23Node right; }
2-3 ํธ๋ฆฌ์ ์ 50
20
10
15
90
65
30
45
55
60
70
75
72
120
80
100
150
์ํ: 3-๋ ธ๋์ธ ๊ฒฝ์ฐ
์ํ: 2-๋ ธ๋์ธ ๊ฒฝ์ฐ
์ํ: ๋จ๋ง ๋ ธ๋์ธ ๊ฒฝ์ฐ
inorder(left subtree) visit the small item inorder(middle subtree) visit the large item inorder(right subtree)
inorder(left subtree) visit the small item inorder(right subtree)
visit the item(s)
2-3 ํธ๋ฆฌ์์ ๊ฒ์ 2-3 ํธ๋ฆฌ์์ ๊ฒ์์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ๊ฒ์๊ณผ ์ ์ฌํ๋ค. ์ฐจ์ด์ . ์ฐจ์ด์ . ํ ๋ ธ๋์์ ๋น๊ตํด์ผ ํ๋ ๊ฐ์ด ๋ ๊ฐ์ผ ์ ์๋ค. 2-3 ํธ๋ฆฌ์ ๋์ด๊ฐ ์ต์ ๋์ด์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ณด๋ค๋ ์๊ฑฐ๋ ๊ฐ์ผ๋ฏ๋ก ๋ณด๋ค ํจ์จ์ ์ด๋ผ๊ณ ์๊ฐํ ์ ์๋ค. ๊ทธ๋ฌ๋ ํ ๋ ธ๋์์ ๋น๊ตํด์ผ ํ๋ ๊ฒ์ด ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ณด๋ค ๋ง์ ์ ์์ผ๋ฏ๋ก ํฌํ/์์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๊ฐ 2-3 ํธ๋ฆฌ๋ณด๋ค๋ ๋ ์ข๋ค. ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๊ท ํ์ ์ ์งํ๋ ๊ฒ์ ์ฝ์ง ์์ผ๋ฏ๋ก ํ๊ท ์ ์ผ๋ก๋ 2-3 ํธ๋ฆฌ๊ฐ ๋ ์ฐ์ํ๋ค. ์ฐ์ํ๋ค
2-3 ํธ๋ฆฌ์์ ๊ฒ์์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ๊ฒ์๊ณผ ์ ์ฌํ๋ค. ์ฐจ์ด์ ์ 3-๋ ธ๋๊ฐ ์กด์ฌํ ์ ์์ผ๋ฏ๋ก ์ด๋ฐ ๋ ธ๋์์๋ ๋ ๊ฐ์ ๊ฐ๊ณผ ๋ชจ๋ ๋น๊ตํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ฐ์ํ๋ค. ์์ ์ค๋ช ํ ๋ฐ์ ๊ฐ์ด 2-3 ํธ๋ฆฌ์ ๋์ด๋ ์ต์ ๋์ด์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ณด๋ค๋ ์๊ฑฐ๋ ๊ฐ๋ค. ๋ฐ๋ผ์ 2-3 ํธ๋ฆฌ์์ ๊ฒ์์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ๊ฒ์๋ณด๋ค ํจ์จ์ ์ด๋ผ๊ณ ์๊ฐํ ์ ์๋ค. ํ์ง๋ง ํ ๋ ธ ๋์์ ๋น๊ตํด์ผ ํ๋ ๊ฒ์ด ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ณด๋ค ๋ง์ ์ ์์ผ๋ฏ๋ก ํฌํ/์์ ์ด์ง ๊ฒ์ ํธ ๋ฆฌ๊ฐ ์ฑ๋ฅ์ ๋ ์ฐ์ํ๋ค. ๊ทธ๋ฌ๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ๋ ์ฝ์ ๋ ์์์ ๋ฐ๋ผ ํจ์จ์ฑ์ด ๋จ์ด์ง ์ ์์ผ๋ฏ๋ก ํ๊ท ์ ์ผ๋ก๋ 2-3 ํธ๋ฆฌ๊ฐ ํจ์จ์ ์ด๋ค.
- 181 -
2-3 Tree: Search boolean search(Object item){ if(item == null) throw new NullPointerException(โโฆโ); if(isEmpty()) throw new TreeUnderflowException(โโฆโ); Comparable o = (Comparable)item; Tree23Node loc = root; while(loc!=null){ int comp = o.compareTo(loc.small); if(comp<0) loc = loc.left; else if(comp==0) return true; if(loc.large==null) loc = loc.middle; else{ comp = o.compareTo(loc.large); if(comp<0) loc = loc.middle; else if(comp==0) return true; else loc = loc.right; } } return false; }
2-3 Tree: Insert 2-3 ํธ๋ฆฌ์์ ์ฝ์ ์ ํญ์ ๋จ๋ง ๋ ธ๋์์ ์ด๋ฃจ์ด์ง๋ค. ๋จผ์ ํค ๊ฐ์ด ์ฝ์ ๋ ๋จ๋ง๋ ธ๋๋ฅผ ์ฐพ๋๋ค. ๋จ๋ง๋ ธ๋๊ฐ 2-node์ด๋ฉด ๊ทธ ๋ ธ๋์ ์ฝ์ ํ๋ค. ๋จ๋ง๋ ธ๋๊ฐ 3-node์ด๋ฉด ๋ ธ๋๋ฅผ ๋ถํ ํด์ผ ํ๋ค. 3-node์ ์๋ ๋ ๊ฐ์ ๊ธฐ์กด ํค ๊ฐ๊ณผ ์ ํค ๊ฐ์ ๋น๊ตํ์ฌ S, M, L์ ๊ฒฐ์ ํ๋ค. ๊ทธ ๋ค์์ ๋ค์๊ณผ ๊ฐ์ด ๋ถํ ๋๋ค. M S
M
L S
L
์ฆ, M์ ๋ถ๋ชจ ๋ ธ๋์ ์ฝ์ ๋๋ค. ์ด ๋ ๋ถ๋ชจ ๋ ธ๋ ์ญ์ 3-node์ด๋ฉด ๋ ๋ค์ ๋ถํ ๋์ด์ผ ํ๋ค. ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ ๋ฃจํธ๊ฐ ๋ถํ ๋๋ฉด ํธ๋ฆฌ์ ๋์ด๊ฐ ํ๋ ์ฆ๊ฐ ํ๋ค.
2-3 ํธ๋ฆฌ์์ ์ฝ์ ์ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ํญ์ ๋จ๋ง๋ ธ๋์์ ์ด๋ฃจ์ด์ง๋ค. ๋ฐ๋ผ์ ๋จผ์ ํค ๊ฐ์ด ์ฝ์ ๋ ๋จ๋ง๋ ธ๋๋ฅผ ์ฐพ์์ผ ํ๋ค. ์ด ๋ ธ๋๊ฐ 2-๋ ธ๋์ด๋ฉด ์ด ๋ ธ๋์ ํค ๊ฐ์ ์ ์ ํ๊ฒ ์ฝ์ ํจ์ผ๋ก์จ ์ฝ์ ์ด ์๋ฃ๋๋ค. ํ์ง๋ง ์ด ๋ ธ๋๊ฐ 3-๋ ธ๋์ด๋ฉด ์ด ๋ ธ๋์ ์ฝ์ ํ ๊ณต ๊ฐ์ด ์์ผ๋ฏ๋ก ์ด ๋ ธ๋๋ฅผ ๋ถํ ํด์ผ ํ๋ค. ๋ ธ๋์ ๋ถํ ์ ๊ธฐ์กด์ ๋ ธ๋์ ์๋ ๋ ๊ฐ์ ๊ฐ๊ณผ ์ ๊ฐ์ ์ ๋ ฌํ์ฌ ๊ทธ ์ค์ ์ค๊ฐ ๊ฐ์ ๋ถ๋ชจ๋ ธ๋๋ก ์ฌ๋ฆฌ๊ณ ๋๋จธ์ง ๋ ๊ฐ์ ๊ฐ์ ๊ธฐ์กด ๋ ธ๋์ ์์นํ๊ฒ ๋๋ค. ์ค๊ฐ ๊ฐ์ ๋ถ๋ชจ๋ ธ๋๋ก ์ฝ์ ํ ๋ ๋ถ๋ชจ๋ ธ๋ ์ญ์ 3-๋ ธ๋์ด๋ฉด ์ด ๋ ธ๋ ์ญ์ ๋ถํ ๋์ด์ผ ํ๋ค. ์ด ๊ณผ์ ์ ๋ฐ๋ณตํ์ฌ ๋ฃจํธ๊ฐ ๋ถํ ๋๋ฉด ํธ๋ฆฌ์ ๋์ด๊ฐ ํ๋ ์ฆ๊ฐํ๊ฒ ๋๋ค.
- 182 -
2-3 Tree: Insert โ ๊ณ์ ๋ ธ๋๊ฐ ๋ถํ ๋์์ ๋ ๊ทธ ๋ ธ๋์ ๋ถ๋ชจ๊ฐ 2-node์ธ ๊ฒฝ์ฐ SP
case i-1. M
SP
Z
M
S S
Z
L
L SP
case i-2. SP A
M
M A S
L
S
L
2-3 Tree: Insert โ ๊ณ์ ๋ ธ๋๊ฐ ๋ถํ ๋์์ ๋ ๋ถ๋ชจ ๋ ธ๋๊ฐ 3-node์ธ ๊ฒฝ์ฐ SP
LP
2
1
M
SP
1
LP
SP
2
M
1
LP
2
M
case i-4. S
case i-3.
L
S
SP
LP
L
S
M
M
S
case i-5.
L
1
LP
SP
2
1
LP
S
L
L
SP
2
1
M
2
S
L
2-3 ํธ๋ฆฌ์์ ๋ ธ๋์ ๋ถํ ์ ํฌ๊ฒ ๋ค์ฏ ๊ฐ์ง ๊ฒฝ์ฐ๋ก ๋๋์ด ์๊ฐํด ๋ณผ ์ ์๋ค. ํฌ๊ฒ๋ ๋ถ ํ ๋์์ ๋ ๋ถ๋ชจ๋ ธ๋๊ฐ 2-๋ ธ๋์ธ ๊ฒฝ์ฐ์ ๋ถ๋ชจ๋ ธ๋๊ฐ 3-๋ ธ๋์ธ ๊ฒฝ์ฐ๋ก ๋๋ ์ ์๋ค.
- 183 -
2-3 Tree: Insert โ ๊ณ์ 50 50
50
50
90
split ํ์ 20
30
90
20
50
30
30
20 30 40
90
50
30
90
50
split ํ์ 20
40
90
20
40
60
90
20
40
60 80 90
50 30
20
80
40
60
90
2-3 Tree: Delete 2-3 ํธ๋ฆฌ์์ ์ญ์ ๋ ๋จผ์ ์ญ์ ํ ๊ฐ์ด ํฌํจ๋ ๋ ธ๋๋ฅผ ์ฐพ์์ผ ํ๋ค. ๊ทธ ๋ ธ๋๊ฐ ๋จ๋ง ๋ ธ๋๊ฐ ์๋๋ฉด ๊ทธ ๊ฐ๊ณผ ๊ทธ๊ฒ์ ์ค์ ์์ ์์์ ๋ฐ๋ก ์ ๊ฐ์ ๊ตํํ๋ค. ์ด ๊ฐ์ ํญ์ ๋จ๋ง๋ ธ๋์ ์๋ค. ๋จ๋ง ๋ ธ๋์์ ๊ฐ์ ์ ๊ฑฐํ๋ค. ์ด ๋ ์ด ๋ ธ๋์ ์ ๊ฑฐํ ๊ฐ ์ธ์ ๋ค๋ฅธ ๊ฐ์ด ์์ผ๋ฉด ๊ทธ๊ฒ์ผ๋ก ์ญ์ ๋ ์ข ๋ฃ๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ด ์ ์ผํ ๊ฐ์ด๋ฉด ์ถ๊ฐ์ ์ธ ์์ ์ด ํ์ํ๋ค. 50
20
10
15
90
65
30
45
55
60
70
75
72
120
80
100
150
2-3 ํธ๋ฆฌ์์ ์ญ์ ๋ ์ด์ง ๊ฒ์ ํธ๋ฆฌ์์ ์ญ์ ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ญ์ ํ ๊ฐ์ด ์๋ ๋ ธ๋๋ฅผ ๋จผ์ ์ฐพ์์ผ ํ๋ค. ๊ทธ ๋ ธ๋๊ฐ ๋จ๋ง๋ ธ๋๊ฐ ์๋๋ฉด ์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ทธ ๊ฐ๋ณด๋ค ์์ ๊ฐ ์ค์ ๊ฐ์ฅ ํฐ ๊ฐ์ ์ฐพ์ ๊ทธ ๊ฐ๊ณผ ๊ต์ฒดํ ๋ค์์ ์ค์ ์ญ์ ๋ ๊ต์ฒดํ ๊ฐ์ด ์๋ ๋ ธ๋์์ ์ด๋ฃจ์ด์ง๋ค. ์ด ๋ ธ๋๋ ํญ์ ๋จ๋ง๋ ธ๋์ด๋ค. ๋ฐ๋ผ์ ๋ชจ๋ ์ญ์ ๋ ์ค์ ๋จ๋ง๋ ธ๋์์ ์ด๋ฃจ์ด ์ง๋ค. ์ญ์ ํ ๊ฐ์ด ์๋ ๋จ๋ง๋ ธ๋๊ฐ 3-๋ ธ๋์ด๋ฉด ๊ทธ ๊ฐ์ ๋ ธ๋์์ ์ญ์ ํจ์ผ๋ก์จ ์ญ์ ๋ ์ข ๋ฃ๋๋ค. ํ์ง๋ง ๊ทธ ๋ ธ๋๊ฐ 2-๋ ธ๋์ผ ๋ ๊ฐ์ ์ญ์ ํ๊ฒ ๋๋ฉด ๋น ๋ ธ๋๊ฐ ๋๋ค. ์ด ๊ฒฝ์ฐ์๋
2-3 ํธ๋ฆฌ์ ์กฐ๊ฑด์ ์ ์งํ๋๋ก ํ์ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ค์ ์๋ ๊ฐ๋ค์ ์ฌ๋ฐฐ์นํด์ผ ํ๋ค.
- 184 -
2-3 Tree: Delete โ ๊ณ์ ๋จ๋ง๋ ธ๋์ ์๋ ๊ฐ์ ์ ๊ฑฐํ์์ ๋ ๊ทธ ๋ ธ๋์ ๋ ์ด์ ๊ฐ์ด ์์ผ๋ฉด ๋จผ์ ํ์ ๋ ธ๋๋ฅผ ๊ฒ์ฌํ๋ค. ํ์ ์ค 3-node๊ฐ ์์ผ๋ฉด ๊ทธ๊ฒ์ ์ด์ฉํ์ฌ ๊ฐ์ ์ฌ๋ถ๋ฐฐํ๋ค. ํญ์ ์ผ์ชฝ ํ์ ๋ฅผ ๋จผ์ ์ด์ฉํ๋ค. 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์์ผ๋ฉด ๋ถ๋ชจ๋ ธ๋์ ์๋ ๊ฐ์ ์๋๋ก ๋ด๋ ค ์ธ์ ํ์ ๋ ธ๋๋ค์ ๊ฒฐํฉํ๋ค. ์ด ๋ ๋ถ๋ชจ๋ ธ๋๊ฐ 2-node์ด๋ฉด ์ญ์ ์๊ณ ๋ฆฌ์ฆ์ ๋ฐ๋ณต ์ ์ฉํ๋ค. ๊ฒฝ์ฐ 1. ๋ถ๋ชจ๊ฐ 2-node ๊ฒฝ์ฐ 1-1, 1-2: 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ ๊ฒฝ์ฐ 1-3, 1-4: 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ ๊ฒฝ์ฐ 2. ๋ถ๋ชจ๊ฐ 3-node ๊ฒฝ์ฐ 2-1(a), 2-1(b), 2-1(c): ์ผ์ชฝ ๊ฒฝ์ฐ 2-2(a), 2-2(b), 2-2(c): ์ค๊ฐ ๊ฒฝ์ฐ 2-3(a), 2-3(b), 2-3(c): ์ค๋ฅธ์ชฝ c๋ 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ
์ญ์ ํ ๊ฐ์ด ์๋ ๋จ๋ง๋ ธ๋๊ฐ 2-๋ ธ๋์ด๋ฉด ์ฐ์ ํ์ ๋ ธ๋๋ฅผ ๊ฒ์ฌํ๋ค. ํ์ ๋ ธ๋ ์ค์ 3-๋ ธ๋ ๊ฐ ์์ผ๋ฉด ์ด ๋ ธ๋๋ฅผ ์ด์ฉํ์ฌ ๊ฐ์ ์ฌ๋ถ๋ฐฐํ๋ค. ๊ทธ๋ฐ๋ฐ ํ์ ๋ ธ๋ ์ค์ 3-๋ ธ๋๊ฐ ์์ผ๋ฉด ๋ถ ๋ชจ๋ ธ๋์ ๊ฐ์ ๋ด๋ฆฌ๊ณ ์ธ์ ํ์ ๋ ธ๋์ ๊ฒฐํฉํ๊ฒ ๋๋ค. ์ด ๋ ๋ถ๋ชจ๋ ธ๋๊ฐ 2-๋ ธ๋์ด๋ฉด ์ด ๊ณผ ์ ์ ๋ค์ ๋ฐ๋ณตํด์ผ ํ๋ฉฐ, ๊ฒฐ๊ตญ ๋ฃจํธ์ ์๋ ๊ฐ์ ๋ด๋ฆฌ๊ฒ ๋๋ฉด ํธ๋ฆฌ์ ๋์ด๊ฐ ํ๋ ๊ฐ์ํ ๊ฒ ๋๋ค.
2-3 Tree: Delete โ ๊ณ์ ๊ฒฝ์ฐ 1-1, 1-2: 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ P S
L
1
3
2
P
L S
4
1
-
P 2
3
4
S S
L
2
1
P 4
3
1
L 2
3
4
๊ฒฝ์ฐ 1-3, 1-4: 3-node์ธ ํ์ ๋ ธ๋๊ฐ ์๋ ๊ฒฝ์ฐ -
P S 1
2
3
S P 1
2
-
P 3
1
S 2
P 3
1
S 2
3
์ ์ฌ๋ผ์ด๋์์๋ ์ญ์ ์ ๊ฒฐ๊ณผ๋ก ๋ ธ๋๊ฐ ๋น ๋ ธ๋๊ฐ ๋์์ ๋, ๊ทธ๊ฒ์ ๋ถ๋ชจ๋ ธ๋๊ฐ 2-๋ ธ๋ ์ธ ๊ฒฝ์ฐ์ ์ด๋ฃจ์ด์ง๋ ๊ณผ์ ์ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ๋น ๋ ธ๋๊ฐ ๋๋ ๋ ธ๋๊ฐ ๋จ๋ง๋ ธ๋์ผ ์ ์๊ณ , ์ด ๊ฒฝ์ฐ์๋ ์ซ์๋ก ํ์๋์ด ์๋ ๋จ๋ง๋ ธ๋๋ค์ ์๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. ํ์ ๋ ธ๋๊ฐ 2-๋ ธ๋ ์ด๊ณ ๋ถ๋ชจ๋ ธ๋๋ 2-๋ ธ๋์ธ ๊ฒฝ์ฐ์๋ ์ญ์ ๊ฒฐ๊ณผ ๋ถ๋ชจ๋ ธ๋๋ ๋น ๋ ธ๋๊ฐ ๋๋ค.
- 185 -
-
1
S
L
A
B
2
1
2
1
2
3
3
4
C
5
6
1
2
3
A
C
4
S
5
1
4
3
-
3
4
3
1
4
2
C
3
4
5
4
1
5
B
2
B
3
B
6
S
2
1
3
4
C
A
L
3
4
5
6
S -
4
L
2
1
L
A
B
C
A
-
S
A
2
C
L
B
L
B
2
S
S
B
L
L
3
1
4
S
L
B
A
C
A
A
2
1
B
S
-
B
L
A
S
L
S
C
4
3
S
-
A
A
5
B 2
1
3
L
4
5
์ ์ฌ๋ผ์ด๋์์๋ ์ญ์ ์ ๊ฒฐ๊ณผ ๋น ๋ ธ๋๊ฐ ๋๋ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๊ฐ 3-๋ ธ๋์ธ ๊ฒฝ์ฐ์ ์ญ์ ๊ณผ์ ์ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ์ ์ฌ๋ผ์ด๋์์๋ ์ด ์ฌ์ฏ ๊ฐ์ง ๊ฒฝ์ฐ๋ฅผ ๋ณด์ฌ์ฃผ๊ณ ์๋ค. ์ด ์ธ์ ๋น ๋ ธ๋๊ฐ ๋ถ๋ชจ๋ ธ๋์ ์ค๊ฐ์์์ธ ์ธ ๊ฐ์ง ๊ฒฝ์ฐ๋ ์ด ์ฌ๋ผ์ด๋์ ์๋ต๋์ด ์๋ค. ๋น ๋ ธ๋์ ํ ์ ๋ ธ๋ ์ค์ 3-๋ ธ๋๊ฐ ์์ผ๋ฉด ์ด๊ฒ์ ์ด์ฉํ์ฌ ๊ฐ๋ค์ ์ฌ๋ถ๋ฐฐํ๊ฒ ๋๋๋ฐ ๋ ๊ฐ์ ํ์ ๋ ธ๋ ๊ฐ ๋ชจ๋ 3-๋ ธ๋์ด๋ฉด ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ฅผ ์ฌ์ฉํ๋ค. ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ ๊ฐ์ฅ ์ผ์ชฝ ์ ์๋ ํ์ ๋ ธ๋๋ฅผ ์ ์ธํ๊ณ ๋ ๋ ธ๋์ ์ผ์ชฝ์ ์๋ ๋ ธ๋๋ฅผ ๋งํ๋ค.
2-3 ํธ๋ฆฌ์ ๊ตฌํ๋ AVL ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ญ์ ํ ๊ฐ์ ์ฐพ์๊ฐ๊ฑฐ๋ ์ฝ์ ํ ๋ ธ๋๋ฅผ ์ฐพ์๊ฐ ๋ ์คํ์ ์ฌ์ฉํ์ฌ ๋ฃจํธ๋ถํฐ ๋จ๋ง๋ ธ๋๊น์ง ๊ฒฝ๋ก์ ์๋ ๋ ธ๋๋ค์ ์ฐจ๋ก๋ก ์คํ์ pushํ๋ค. ๊ทธ ๋ค์ ์ด ์คํ์ ์ด์ฉํ์ฌ ํ์ํ ๋ถํ ๋๋ ์ญ์ ์ ํ์ํ ์ฌ์กฐ์ ์ ์ํํ๋ค.
13.3. 2-3-4 ํธ๋ฆฌ
2-3-4 ํธ๋ฆฌ 2-3-4 ํธ๋ฆฌ: ๋ชจ๋ ์ค๊ฐ๋ ธ๋๋ค์ ์์ ์๊ฐ 2, 3, 4์ด๊ณ , ๋ชจ๋ ๋จ๋ง๋ ธ๋๊ฐ ๊ฐ์ ๋ ๋ฒจ์ ์๋ ํธ๋ฆฌ์ด๋ค. S
S
L
S
M
L
empty 2-3-4 tree
TL
TR
TL < S < TR TL: 2-3-4 ํธ๋ฆฌ TR: 2-3-4 ํธ๋ฆฌ
TL
TM
TL < S < TM TM < L < TR TL, TM, TR: 2-3-4 ํธ๋ฆฌ
TR
TL
TML TMR
TR
TL < S < TML TML < M < TMR TMR < L < TR TL, TML, TML, TR: 2-3-4 ํธ๋ฆฌ
2-3-4 ํธ๋ฆฌ๋ 2-3 ํธ๋ฆฌ๋ฅผ ํ์ฅํ์ฌ 2-๋ ธ๋, 3-๋ ธ๋ ๋ฟ๋ง ์๋๋ผ 4-๋ ธ๋๊ฐ ์กด์ฌํ ์ ์๋ ํธ
- 186 -
๋ฆฌ์ด๋ค. ์ด์ฒ๋ผ 2-3 ํธ๋ฆฌ๋ ํ ๋ ธ๋์ ์์ ์ ์๋ ๊ฐ์ ์๋ฅผ ๋๋ ค ๋ค์ํ ํธ๋ฆฌ๋ฅผ ๋ง๋ค ์ ์๋ค. ์ค์ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ์ฌ์ฉํ๋ ์์ธ๊ตฌ์กฐ๋ ์ด๋ฐ ํํ์ ํธ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค. ํ ๋ ธ๋ ์ ์์ ์ ์๋ ๊ฐ์ ์๊ฐ ๋ง์ผ๋ฉด ๋ง์์๋ก ํธ๋ฆฌ์ ๋์ด๋ ๊ฐ์ํ๋ค. ๋ํ ํธ๋ฆฌ์ ๋์ด๊ฐ ๊ฐ์ํ๋ฉด ํ ์๋ก ๊ฒ์์ ํฅ์๋ ์ ์๋ค. ๋ฌผ๋ก ํ ๋ ธ๋์์ ๋น๊ตํด์ผ ํ๋ ์ ๋ณด๊ฐ ๋ง์์ง ์ ์์ง๋ง ๊ฐ๋ค์ด ๋ ธ๋์ ์ ๋ ฌ๋์ด ์ ์ฅ๋๋ฏ๋ก ๋ ธ๋ ๋ด์์ ๋น๊ต๋ ์ด์ง ๊ฒ์์ ํ ์๋ ์ ๋ค.
2-3-4 ํธ๋ฆฌ์ ์ 50
30
15
20
65 75 90
55
45
60
70
72
์ํ: 4-๋ ธ๋์ธ ๊ฒฝ์ฐ
100 120 150
80
์ํ: 3-๋ ธ๋์ธ ๊ฒฝ์ฐ 2-๋ ธ๋์ธ ๊ฒฝ์ฐ ๋จ๋ง ๋ ธ๋์ธ ๊ฒฝ์ฐ ร 2-3 ํธ๋ฆฌ์ ๋์ผ
inorder(left subtree) visit the small item inorder(middle left subtree) visit the middle item inorder(middle right subtree) visit the large item inorder(right subtree)
2-3-4 ํธ๋ฆฌ: ์ฝ์ 2-3-4 ํธ๋ฆฌ์์ ์ฝ์ ์ ํญ์ ๋จ๋ง ๋ ธ๋์์ ์ด๋ฃจ์ด์ง๋ค. ์ฝ์ ํ ๋ ธ๋๋ฅผ ์ฐพ์๊ฐ๋ ๋์ 4-๋ ธ๋๋ฅผ ๋ง๋๋ฉด ๋จผ์ ๋ถํ ํ๋ค. insert(15) insert(20) insert(90)
insert(50) 40 10 40
40
40
80
10
80
10
50
80
10 15 20
50 80 90
insert(70)
insert(60) 40
10 15 20
80
50
40
90
10 15 20
80
50
40
60
90
10 15 20
80
50 60 70
90
2-3-4 ํธ๋ฆฌ์์ ์ฝ์ ์ 2-3 ํธ๋ฆฌ์ ์ ์ฌํ๋ค. ์ฐจ์ด์ ์ 2-3-4 ํธ๋ฆฌ์์๋ ์ฝ์ ํ ๋ ธ๋๋ฅผ ์ฐพ ์๊ฐ๋ ๋์ 4-๋ ธ๋๋ฅผ ๋ง๋๋ฉด ๋จผ์ ๋ถํ ํ๋ค. ์ ์ฌ๋ผ์ด๋์์ ์ฒ์ 3๊ฐ์ ๊ฐ์ด ์ฝ์ ๋๋ฉด ํธ๋ฆฌ์ ์๋ ์ ์ผ ๋ ธ๋๊ฐ 4-๋ ธ๋๊ฐ ๋๋ค. ๊ทธ ๋ค์์ ๋ ๋ค๋ฅธ ๊ฐ์ ์ฝ์ ํ๊ณ ์ ํ๋ฉด ์ด ๋ ธ๋ ๊ฐ ๋จผ์ ๋ถํ ๋๋ค. 4-๋ ธ๋๊ฐ ๋ถํ ๋ ๋์๋ ์ค๊ฐ๊ฐ์ด ๋ถ๋ชจ๋ ธ๋๋ก ์ฌ๋ผ๊ฐ๊ณ , ์ผ์ชฝ๊ฐ์ผ๋ก๋ง ๊ตฌ ์ฑ๋ ๋ ธ๋์ ์ค๋ฅธ์ชฝ๊ฐ์ผ๋ก๋ง ๊ตฌ์ฑ๋ ๋ ธ๋๊ฐ ์๋กญ๊ฒ ๋ง๋ค์ด์ง๋ค.
- 187 -
2-3-4 ํธ๋ฆฌ: ์ฝ์ ์ insert(65) 40 60 80
10 15 20
50
70
40 60 80
90
10 15 20
50
65
70
60
90
60
insert(55) 40
10 15 20
80
50
65
70
40
10 15 20
90
80
50
55
65
70
90
ร Splitํ ๋์๋ ํญ์ ์ค๊ฐ ๊ฐ์ด ๋ถ๋ชจ๋ ธ๋๋ก ์ฌ๋ผ๊ฐ๋ค.
2-3-4 ํธ๋ฆฌ: ์ญ์ 2-3-4 ํธ๋ฆฌ์์ ์ญ์ ๋ ๋จผ์ ์ญ์ ํ ๊ฐ์ด ํฌํจ๋ ๋ ธ๋๋ฅผ ์ฐพ์์ผ ํ๋ค. ๊ทธ ๋ ธ๋๊ฐ ๋จ๋ง๋ ธ๋๊ฐ ์๋๋ฉด ๊ทธ ๊ฐ๊ณผ ๊ทธ๊ฒ์ ์ค์ ์์ ์์์ ๋ฐ๋ก ์ ๊ฐ์ ๊ตํํ๋ค. ์ด ๊ฐ์ ํญ์ ๋จ๋ง๋ ธ๋์ ์๋ค. ์ฆ, ์ ๊ฑฐ๋ ํญ์ ๋จ๋ง๋ ธ๋์์ ์ด๋ฃจ์ด์ง๋๋ก ํ๋ค. ์ด ๋ ์ด ๋ ธ๋๊ฐ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋์ด๋ฉด ๊ฐ์ ์ ๊ฑฐํ ๋ค์์ ์ข ๋ฃํ๋ค. ๋ฐ๋๋ก ์ด ๋ ธ๋๊ฐ 2-๋ ธ๋์ด๋ฉด ์ถ๊ฐ ์์ ์ด ํ์ํ๋ค. ์ด๋ฐ ๋ถํธํจ์ ํด์ํ๊ธฐ ์ํด ์ญ์ ํ ๊ฐ์ด ํฌํจ๋ ๋ ธ๋๋ฅผ ์ฐพ์ ๋ ๋ง๋๊ฒ ๋๋ ๋ชจ๋ 2-๋ ธ๋๋ฅผ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋๋ก ๋ฐ๊พผ๋ค. split์ ๋ฐ๋ ๊ณผ์ ์ ์ํํ๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ชจ๋ ์ ๊ฑฐ๋ ํ ํจ์ค์ ๋๋ผ ์ ์๋ค.
2-3-4 ํธ๋ฆฌ์์ ์ญ์ ๋ 2-3 ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ์ญ์ ํ ๊ฐ์ด ํฌํจ๋ ๋ ธ๋๋ฅผ ๋จผ์ ์ฐพ์์ผ ํ ๋ฉฐ, ์ด ๋ ธ๋๊ฐ ์ค๊ฐ๋ ธ๋์ด๋๋ผ๋ 2-3 ํธ๋ฆฌ์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฒฐ๊ตญ์ ์ญ์ ๋ ๋จ๋ง๋ ธ๋์์ ์ด๋ฃจ ์ด์ง๋ค. ์ญ์ ๊ฐ ์ด๋ฃจ์ด์ง ๋จ๋ง๋ ธ๋๊ฐ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋์ด๋ฉด ๊ฐ์ ์ ๊ฑฐํจ์ผ๋ก์จ ์ญ์ ๋ ์ ๋ฃ๋๋ค. ํ์ง๋ง ์ญ์ ๊ฐ ์ด๋ฃจ์ด์ง ๋จ๋ง๋ ธ๋๊ฐ 2-๋ ธ๋์ด๋ฉด ๋น ๋ ธ๋๊ฐ ๋๋ฏ๋ก 2-3 ํธ๋ฆฌ์ ๋ง์ฐฌ ๊ฐ์ง๋ก ์ถ๊ฐ ์์ ์ ํด์ผ ํ๋ค. ๋ณด๋ค ์ญ์ ๋ฅผ ์์ํ๊ฒ ํ๊ธฐ ์ํด 2-3-4 ํธ๋ฆฌ์์๋ ์ฝ์ ๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ์ญ์ ํ ๋ ธ๋๋ฅผ ์ฐพ์๊ฐ๋ฉด์ ๋ง๋๊ฒ ๋๋ ๋ชจ๋ 2-๋ ธ๋๋ฅผ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋๋ฅผ ๋ฏธ ๋ฆฌ ๋ฐ๊พผ๋ค. ์ด๋ ๊ฒ ํ๋ฉด ์ญ์ ํ ๋จ๋ง๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ ํญ์ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋๊ฐ ๋๋ฏ๋ก ์ญ์ ์ ๋ฐ๋ผ ์ฐ์์ ์ผ๋ก ๋ฃจํธ๊น์ง ๋ค์ ์ฌ๋ผ๊ฐ๋ฉด์ ์ถ๊ฐ ์์ ์ ํ์ง ์์๋ ๋๋ค.
- 188 -
2-3-4 ํธ๋ฆฌ: ์ญ์ โ ๊ณ์ 2-๋ ธ๋๋ฅผ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋๋ก ๋ฐ๊พธ๋ ๋ฐฉ๋ฒ ํ์ฌ ๋ ธ๋๊ฐ P์ด๊ณ ์ญ์ ํ ๊ฐ์ด ์๋ ๋ ธ๋๊น์ง ๊ฒฝ๋ก ์์ ์๋ ๋ค์ ์์ ๋ ธ๋๋ฅผ C๋ผ ํ๊ณ , C์ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ฅผ R์ด๋ผ ํ์. P
P R
P
20
40
R R
C
40
?
C
10
20
40
R 10
?
C
?
15
20 30
40
?
20
30
R
C
15
10
30
30
C
10
2-3-4 ํธ๋ฆฌ์์ ์ญ์ ๋ฅผ ํ ๋ ๋จผ์ ๋ฃจํธ๋ถํฐ ํ์์ ํ๋ฉด์ ์ญ์ ํ ๊ฐ์ด ๋ค์ด์๋ ๋ ธ๋๋ฅผ ์ฐพ๋๋ค. ๊ทธ ๊ฒฝ๋ก ์์ ์๋ ๋ ธ๋๊ฐ 2-๋ ธ๋๊ฐ ์๋๋ฉด ์ถ๊ฐ ์์ ์์ด ๋ค์ ๋ ธ๋๋ก ์ด๋ํ๋ค. ์ด ๋ ํ์ฌ ๋ ธ๋๋ฅผ P๋ผ ํ๊ณ ์ฐพ์๊ฐ ๊ฒฝ๋ก ์์ ์๋ P์ ์์ ๋ ธ๋๋ฅผ C๋ผ ํ์. C ๋ ธ๋๊ฐ
2-๋ ธ๋์ด๊ณ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๊ฐ 2-๋ ธ๋์ธ ๊ฒฝ์ฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋ณํฉ๋๋ค. ์ฌ๊ธฐ์ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ 2-3 ํธ๋ฆฌ์์ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋ ๊ฐ๋ ๊ณผ ๊ฐ๋ค. ์ฒซ์งธ, P๊ฐ 2-๋ ธ๋์ธ ๊ฒฝ์ฐ๋ P, C, ๊ทธ๋ฆฌ๊ณ C์ ํ์ ๋ ธ๋๊ฐ ๋ณํฉ๋์ด 4-๋ ธ๋๊ฐ ๋๋ค. ๋์งธ, P๊ฐ 3-๋ ธ๋์ธ ๊ฒฝ์ฐ๋ C๋ P ๋ ธ๋์ ์๋ ํ๋์ ๊ฐ๊ณผ ํ์ ๋ ธ๋๋ฅผ ํจ๊ป ๋ณํฉํ์ฌ 4๋ ธ๋๊ฐ ๋๊ณ , P ๋ ธ๋๋ 2-๋ ธ๋๊ฐ ๋๋ค.
C ๋ ธ๋๊ฐ 2-๋ ธ๋์ด๊ณ ๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๊ฐ 3-๋ ธ๋ ๋๋ 4-๋ ธ๋์ธ ๊ฒฝ์ฐ๋ ๋ค์๊ณผ ๊ฐ์ด ๋ณ ํฉ๋๋ค. ํ์ ๋ ธ๋ ๊ฐ ์ค ํ๋๊ฐ P ๋ ธ๋๋ก ์ฌ๋ผ๊ฐ๊ณ P ๋ ธ๋์ ์๋ ๊ฐ์ด C ๋ ธ๋๋ก ๋ด๋ ค C ๋ ธ๋๊ฐ 3-๋ ธ๋๊ฐ ๋๋ค.
2-3-4 ํธ๋ฆฌ: ์ญ์ ์ 60
40 60 80 delete(55)
40
80 10 15 20
50
65
70
90
๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ฅผ ์ฐพ์์ผ ํ๋ค. 10 15 20
50
delete(50)
55
65
70
90
๊ฐ์ฅ ๊ฐ๊น์ด ํ์ ๋ ธ๋๋ ๊ฐ์ฅ ์ผ์ชฝ ๋ ธ๋๋ฅผ ์ ์ธํ๊ณ ๋ ์์ ์ ์ผ์ชฝ ํ์ ๋ฅผ ๋งํ๋ฉฐ, ๊ฐ์ฅ ์ผ์ชฝ ๋ ธ๋๋ ์์ ์ ์ค๋ฅธ์ชฝ ๋ ธ๋๋ฅผ ๋งํ๋ค.
20 60 80 20 60 80
10
15
40
50
65
70
90 10
- 189 -
15
40
65
70
90
2-3-4 ํธ๋ฆฌ: ์ญ์ ์ โ ๊ณ์ delete(65)
delete(60)
20 60 80
10
15
40
70
10
20 15
10
40
70
10
15
delete(90)
15 40 80
delete(40)
90
90
20 60 80
40
15
10
20
90
10
40
15
70 80 90
20
70
70
15 40 80
10
20
20
60 40
70
20
80
10 15 40
70
80 20
70
- 190 -
80
10
15
70
80
90