์ ์
๊ฐ๋ฐ์ ๊ธฐ์ ๋ฉด์ : C++ ์ ๋ ฌ ์ด์ ๋ฆฌ (๋ฒ๋ธ, ์ฝ์
, ์ ํ, ํต, ํ, ๋ณํฉ)
ํ์ดํธ๋ณด๋๋ ์ข
์ด๋ ๋น์ฅฌ์ผ ์คํ๋์ค์ ์์ฑํ๋ฉด์ ์ค๋ช
ํ ์ ์์ด์ผ ํฉ๋๋ค. ๋ฒ๋ธ, ์ฝ์
, ์ ํ ์๊ณ ๋ฆฌ์ฆ์ ๋ชจ๋ ๊ธฐ๋ณธ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก, ๋๊ท๋ชจ ๋ฐ์ดํฐ์
์ ๋ํด์๋ ๋นํจ์จ์ ์ผ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ฐ๋จํ ์ฌ์ฉ ์ฌ๋ก๋ ์์ ๋ฐ์ดํฐ์
์๋ ์ฌ์ ํ ์ ์ฉํ ์ ์์ต๋๋ค. ๋ฐ์ดํฐ๊ฐ ์ด๋ฏธ ๋ถ๋ถ์ ์ผ๋ก ์ ๋ ฌ๋์ด ์๊ฑฐ๋, ๋ฐ์ดํฐ์ ์์ด ์ ์ ๋๋ ์ฝ์
์ ๋ ฌ์ด ๋ค๋ฅธ ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋นํด ๋ ๋น ๋ฅผ ์ ์์ต๋๋ค. ํฉ๋ณ ์ ๋ ฌ์ ๋ชจ๋ ๊ฒฝ์ฐ์์ O(NlogN) ์ ์๊ฐ ๋ณต์ก๋๋ฅผ ์ ์งํ์ง๋ง, ์ถ๊ฐ ๋ฉ๋ชจ๋ฆฌ ์๊ตฌ์ ์บ์ ํจ์จ ๋ฌธ์ ๋ก ์ธํด ํ๊ท ์ ์ธ ์ฑ๋ฅ์ด ํต ์ ๋ ฌ๋ณด๋ค ๋๋ฆด ์ ์์ต๋๋ค. ํฉ๋ณ ์ ๋ ฌ๊ณผ ํต ์ ๋ ฌ์ ๋ ๋ค ํจ์จ์ ์ธ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ด์ง๋ง, ์๋ ๋ฐฉ์์ ๋ช ๊ฐ์ง ์ค์ํ ์ฐจ์ด์ ์ด ์์ต๋๋ค. ์๋ ์๋ฆฌ: ํฉ๋ณ ์ ๋ ฌ์ ๋ฐฐ์ด์ ๋ฐ์ผ๋ก ๋๋๊ณ ..
์ ์
๊ฐ๋ฐ์ ๊ธฐ์ ๋ฉด์ : C++ 05 (์์ฝ๋ฉ: Heapify, ์ต๋ํ, ์ด์งํ์)
์๋
ํ์ธ์, ์ซ๋๋ฏธ์
๋๋ค. ์์ฝ๋ฉ์ ์ฒ์์ด๋ผ์์ ... ํ๋ฆฐ ๋ด์ฉ์ด ์๋ค๋ฉด ๋๊ธ๋ก ์๋ ค์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค (_ _ ) ๐ฃ๏ธ Heapify ์ฝ๋๋ฅผ ์์ฑํด๋ณด์ธ์ #include using namespace std; void swap(int& a, int& b) { int temp = a; a = b; b = temp; } int num = 9; int heap[9] = {7, 6, 5, 8, 3, 5, 9, 1, 6}; int main() { for (int i = 1; i < num; i++) { int c = i; do { int root = (c - 1) / 2; if (heap[root] < heap[c]) { swap(heap[root], heap[c]); } c = root; } while (c..
์ ์
๊ฐ๋ฐ์ ๊ธฐ์ ๋ฉด์ : C++ 04 (C, C#, Java์์ ์ฐจ์ด์ )
๐ฃ๏ธ C++๊ณผ C์์ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ง์์ ์์ด ์ด๋ค ์ฃผ์ ์ฐจ์ด์ ์ด ์๋์? C++์ ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์์น๋ค์ ์ง์ ์ ์ผ๋ก ์ง์ํ๋ ๋ฐ๋ฉด, C๋ ์ ์ฐจ ์งํฅ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก, ์ฃผ๋ก ์์ฐจ์ ์ธ ์ ๊ทผ ๋ฐฉ์์ ์ด์ ์ ๋ง์ถฅ๋๋ค. C์์๋ ๊ตฌ์กฐ์ฒด(struct)๋ฅผ ์ฌ์ฉํ์ฌ ๊ด๋ จ ๋ฐ์ดํฐ๋ฅผ ๊ทธ๋ฃนํํ ์ ์์ง๋ง, ๋ฉ์๋๋ฅผ ํฌํจํ ์๋ ์์ต๋๋ค. C์์๋ ์์์ด๋ ํด๋์ค ๊ธฐ๋ฐ์ ์ถ์ํ๋ฅผ ์ง์ํ์ง ์์ต๋๋ค. ์ด๋ ์ฝ๋์ ์ฌ์ฌ์ฉ์ฑ๊ณผ ํ์ฅ์ฑ์ ์ ํํฉ๋๋ค. ๋ํ C++์ ๊ฐ์ฒด ์ค์ฌ, namespace, ์ค๋ฒ๋ผ์ด๋ฉ, ์์ธ์ฒ๋ฆฌ, ์ ๋ค๋ฆญ ํ๋ก๊ทธ๋๋ฐ ์ฌ์ฉ ๊ฐ๋ฅํฉ๋๋ค. ๐ฃ๏ธ C++๊ณผ Java์์ ์ด๋ค ์ฃผ์ ์ฐจ์ด์ ์ด ์๋์? Java ๋ ๋ณด๋ค ์์ ํ๊ณ ํด๋์ฑ์ด ๋์ ํ๋ก๊ทธ๋๋ฐ์ ์ํด ์ค๊ณ๋ ๋ฐ๋ฉด, C++์ ์ฑ๋ฅ๊ณผ ์ ์์ค์ ์์คํ
..