๋ชฉ๋ก์ ์ฒด ๊ธ (1110)
KoreanFoodie's Study
๊ธฐ์ ๋ฉด์ ๊ณผ ์ฝ๋ฉํ ์คํธ ์ค๋น๋ฅผ ์ํด ๊ผญ ์์์ผ ํ ๊ธฐ์ด ์๊ณ ๋ฆฌ์ฆ ๊ด๋ จ ๊ฐ๋ ๋ค๊ณผ ์ฝ๋๋ฅผ ์ ๋ฆฌํ๊ณ ์์ต๋๋ค. ๊ฐ ์ฃผ์ ๋ค์ GeeksForGeeks ์ Top 10 algorithms in Interview Questions ๊ธ์์ ๋ฐ์ทํ์์ต๋๋ค. ๋ฌธ์ ๋งํฌ๋ ์ ๋ชฉ์ ๋งํฌ๋ก ๊ฑธ์ด๋์์ต๋๋ค. BFS (Breadth First Search) BFS ๋ ๋์ด ์ฐ์ ํ์์ผ๋ก, ํ(Queue) ์๋ฃ๊ตฌ์กฐ ํ์ ์ฌ์ฉํ์ฌ ๋ฐฉ๋ฌธ ์ฒดํฌ๋ฅผ ์งํํ๋ค. ๊ตฌ์ฒด์ ์ธ ์ฝ๋๋ ๋ค์๊ณผ ๊ฐ๋ค. #include #include #include using namespace std; class Graph { int N; list* g; public: Graph(int n) : N(n) { g = new list[n]; } void addEdge(int..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ํ ํ๋ฆฟ ํด๋์ค ์ธ์คํด์ค๋ ๊ฐ์ ํ์ ์ผ๊น? ํ ํ๋ฆฟ ํด๋์ค๋ก ๋ง๋ ๋ ํด๋์ค์์ ์ธ์๋ง ๋ฐ๊พผ๋ค๋ฉด, ํด๋น ์ธ์คํด์ค๋ค์ ๊ฐ์ ํ์ ์ผ๊น? ๋ค์ ์ฝ๋๋ฅผ ๋ณด์. #include #include template class Array { T data[N]; public: Array() {} Array(T (&arr)[N]) { for (int i = 0; i < N; ++i) { data[i] = arr[i]; } } T* get_array() { return data; } int size() { return N; } void print_all() { for (int i = 0; i < N; ++i..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! ๊ฐ๋ณ ๊ธธ์ด ํ ํ๋ฆฟ C++ ํ ํ๋ฆฟ์ ์ด์ฉํ๋ฉด ํ์ด์ฌ์ฒ๋ผ ์์์ ๊ฐฏ์์ ์ธ์๋ฅผ ๋ฐ๋ ํจ์๋ฅผ ๊ตฌํํ ์ ์๋ค. #include template void print(T arg) { std::cout
๋ฐ์ผํ๋ก ์์ฝ๋๋์ด๋ค. ์ ๋ช ํ๊ณ ๋ง์๋ ๊ณณ์ ๋ฐฉ๋ฌธํ๊ธฐ ์ํด์๋ ์ฌ์ ์์ ์ด ๊ฑฐ์ ํ์๊ฐ ๋ ์๋๊ฐ ์ด๋ ธ๋ค. ๋ฌผ๋ก ๋๋ฌด ์ฅ์ฌ๊ฐ ์ ๋์, ๊ตณ์ด ์์ฝ ๋ฐ์ ๋ฐ์ง ์๋ ์์์ ๋ค๋ ๋ถ์ง๊ธฐ์๋ค. ๊ทธ๋ฐ ๊ณณ๋ค์ ์ถ์ด ๊ฒจ์ธ๋ ๋กฑํจ๋ฉ์ ๋ถ์ฌ ์ก์ผ๋ฉฐ ๊ฐ์ด ์จ ์น๊ตฌ๋ ์ฐ์ธ๋ค๊ณผ ํญ๊ท ๋์ด๋ฅผ ํ ์ค๋น๋ฅผ ํด์ผํ๋ค. ์๋ฒ์ง๋ ์์นญ ๋ฏธ์๊ฐ์ด๊ธฐ์ ๋ง์ง์ ์ฐพ์๊ฐ์๋ ํธ์ด๋ค. ํฌ์ฅ๋ ์์ฃผ ํด ์ค์๊ณ . ์์นญ ๋ฏธ์๊ฐ์ธ ์๋ฒ์ง. ํ์ง๋ง ๋ด๊ฐ ์๊ฐํ๊ธฐ์, ์๋ฒ์ง๋ ํผ(ๆทท)์๊ฐ์ ๊ฐ๊น๋ค. ๋ญ๋ ์ง ๋น๋น๊ณ ์์ด ๋์๋๊น. ์ ๋ฌธ ์ฉ์ด๋ก ์ฐ๊น ๋ฌต๋๋ค๊ณ ํ๋๊ฐ? ๋ง์ง์ ์ธ๊ณ๋ ๋ํนํ๋ค. ์๋๋ ๊ณณ์ ์๋๊ณ , ์๋๋ ๊ณณ์ ์๋๋ ๋ฒ. ๋๋ฌด๋๋ ๋น์ฐํ ๋ง์ด์ง๋ง, ์์์ ์ ๊ฒฝ์ฐ ๊ทธ ํธ์ฐจ๊ฐ ์ ๋ฒ ํฌ๋ค. ๋ฐ๋ก ์์ง์ ๋ถ์ด ์์ด๋ ๋ฌธ์ ์ฑ์๋ฅผ ์ด๋ฃจ๋ ์ง๊ณผ, ํ๋ฆฌ๋ง ๋ ๋ฆฌ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! C++ ํ ํ๋ฆฟ ๋์ ์๋์ ๊ฐ์ ๋ฒกํฐ ํด๋์ค๋ฅผ ๋ง๋ค์๋ค๊ณ ํ์. class Vector { int* data; int capacity; int length; public: Vector(int n) : data(new int[n]), capacity(n), length(0) {} void push_back(int input); void remove(int index); int size() { return length; } void print_data() { for (int i = 0; i < n; ++i) { std::cout
๋ง์์ด ๋ฐ๋ปํ๋ค๋ ๊ฒ์ ์ด๋ป๊ฒ ์ ์๋ด๋ฆฌ๋ฉด ์ข์๊น. ๊ทธ๋ฅ, ์จ๊ธฐ๋ฅผ ์ค๊ฐ์ผ๋ก ๋๋ผ๋ฏ ๋ฐ์คํ ๋ง์์ด๋ผ๋ ๋์ ์์ฐ์ค๋ฝ๊ฒ ๋ฐ์๋ค์ด๋ฉด ์๋๋ ๊ฑธ๊น. ๋ฐ๋ปํ ๋ง์์ด๋ผ๋ ๋ ์์ ์ ์ฒด๋ฅผ ๊ผฌ์ง๊ผฌ์งํ๊ฒ ํ๊ณ ๋ค์ด ๊ฒฐ๋ก ์ ๋ด๋ ค์ผ ์ง์ฑ์ด ํ๋ฆฌ๋ ์ฌํ๋ ์ฌํ ๋์ ์ฑ๊ฒฉ์ด์ฌ. ์ด์ฉ๋ฉด ๋๋ ๋ฐ๋ปํ ๋ง์์ ๊ฐ์ง๊ธฐ์ ์ด๋ฏธ ํ๋ฆฐ ์ด๋ช ์ ํ๊ณ ๋ ๊ฑด ์๋๊น ์ถ๊ธฐ๋ ํ๋ค. ๊ทธ๋ฌ๋ ํ๊ณ ๋ ํ์ ๋ฐ์, ๋ ธ๋ ฅ์ผ๋ก ๊ทน๋ณตํ ์ ์๋ค๊ณ ๋ฏฟ๋ ๋์ด๊ธฐ์ ์์ง ์ผ๋ง์ ํฌ๋ง์ ๋จ์ ์์ง ์์๊น. ์ฌ๋์ ๋ณํ๋ค. ์ด์ ๊ธ์์๋ ๊ทธ ์ฃผ์ ๋ฅผ ๋ค๋ฃฌ ์ ์ด ์๊ณ ์์ผ๋ก๋ ์ฌ๋์ด ๋ณํ๋ค๋ ๋์ ์๊ฐ์ ๋ฐ๋์ง ์์ ๊ฒ์ด๋ค. ์ฌ๋์ ๋์์์ด ๋ณํ๋ค. ๋ฌผ๋ก ๋ณ๋ชจํ๋ ์๊น์๋ ๊ฐ๊ธฐ ๋ค๋ฅด๋ค. ๋ง์น ๋จน๊ตฌ๋ฆ์์ ๋ฐ์ณ๋์จ ๋น๋ฐฉ์ธ์ด ์๋ก ๋ค๋ฅธ ๋ฌด๋ฌ์ ๊ฒฐ์ ์ ์ด๋ฃจ๋ฏ์ด. ๊ทธ๋ ๋ค๋ฉด ๋๋ ์ด๋จ๊น..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! fstream ํ์ผ ์คํธ๋ฆผํด๋์ค fstream์ ์์๋ฐ์ istream๊ณผ ostream์ ์ ์ถ๋ ฅ ํด๋์ค๋ก ์ฌ์ฉํ์. std::ifstream in("test.txt"); std::string s; if (in.is_open()) { in >> s; std::cout
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! C++ ์ ์ถ๋ ฅ ๋ผ์ด๋ธ๋ฌ๋ฆฌ C++ ์ ์ถ๋ ฅ ํด๋์ค๋ ios_base๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ํ๋ฉฐ, ์คํธ๋ฆผ์ ์ ์ถ๋ ฅ ํ์ ๊ด๋ จ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค(์ ๋ฐ๋, 10์ง์/16์ง์ ๋ฑ ๊ฒฐ์ ). ios ํด๋์ค์์๋ ์ค์ ๋ก ์คํธ๋ฆผ ๋ฒํผ๋ฅผ ์ด๊ธฐํํ๊ณ ์ ์ถ๋ ฅ ์์ ์ ์ํ๋ฅผ ์ฒ๋ฆฌํ๋ค(ํ์ผ์ ๋์ ๋๋ฌํ์ ๊ฒฝ์ฐ eof ํจ์ ํธ์ถ, good ํจ์ ํธ์ถ๋ก ์ ์ถ๋ ฅ ์์ ์ฒดํฌ) istream ํด๋์ค istream์ ์ค์ ๋ก ์ ๋ ฅ์ ์ํํ๋๋ฐ, operator>>๊ฐ istream ํด๋์ค์ ์ ์๋ ์ฐ์ฐ์์ด๋ค. ๋ํ cin์ istream ํด๋์ค์ ๊ฐ์ฒด ์ค ํ๋์ด๋ค. cin์ ์ํฐ๋ ๊ณต๋ฐฑ์ ์ ๋ ฅ ์์ ๋ฌด์ํด ๋ฒ๋ฆฐ๋ค. ๋ํ, opera..
'์คํ์ด๋๋งจ : ๋ ธ ์จ์ด ํ'์์ ๋ฅํฐ ์คํธ๋ ์ธ์ง๋ ์คํ์ด๋๋งจ์๊ฒ ์ด๋ฐ ๋์ฌ๋ฅผ ๋์ง๋ค. "The problem is you trying to live two different lives. The longer you do it, the more dangerous it becomes!" ์คํ์ด๋๋งจ์ ์ฐธ ์์ฌ์ด ๋ง๋ค. ์์ฌ์ด ์๋ ์ฌ๋์ด ์ธ์์ ์ด๋ ์๊ฒ ๋๋ง๋, ๊ทน์ค์ ํผํฐ ํ์ปค๋ ์ฒ ๋ถ์ง๋ผ๋ ์ปจ์ ๋ต๊ฒ ์ํ๋ ๊ฒ์ ์์ ๊ณจ๋ผ๊ฐ์ง๋ ค๊ณ ํ๋ ์์ด๊ฐ์ ๋ฉด๋ชจ๋ฅผ ๋ณด์ฌ์ค๋ค. ๊ทธ๋์ ํฐ ์ด๋ฅธ์ด์, ๋ง์น ์๋ถ๊ฐ์ ์กด์ฌ์ธ ๋ฅํฐ ์คํธ๋ ์ธ์ง์๊ฒ ๋ผ๋ฅผ ์ฐ๊ธฐ๋ ํ๋ค. "๋ฌธ์ ๋ ๋๊ฐ ๋ ๊ฐ์ง ๋ค๋ฅธ ์ถ์ ๋์์ ์ด๋ ค๊ณ ํ๋ ๋ฐ์ ์๋๊ฑฐ์ผ." ๋ฅํฐ ์คํธ๋ ์ธ์ง๋ก์์ ์ถ์ ์ด๊ธฐ ์ํด ์คํฐ๋ธ์ด๋ผ๋ ์ถ์ ํฌ๊ธฐํ๋ ๊ทธ์ด๊ธฐ์, ๋ฅํฐ ์คํธ๋ ์ธ์ง๋ ์คํ..
๋ชจ๋์ ์ฝ๋๋ฅผ ์ฐธ๊ณ ํ์ฌ ํต์ฌ ๋ด์ฉ์ ๊ฐ์ถ๋ฆฌ๊ณ ์์ต๋๋ค. ์์ธํ ๋ด์ฉ์ ๋ชจ๋์ ์ฝ๋์ ์น์ด๋จน๋ C++ ๊ฐ์ข๋ฅผ ์ฐธ๊ณ ํด ์ฃผ์ธ์! vitrual ์๋ฉธ์์ ๋ฉ๋ชจ๋ฆฌ ๋์ ์ฌ์ค virtual ์๋ฉธ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ ๋, ๋ฉ๋ชจ๋ฆฌ ๋์(memory leak)์ ๋ง๊ธฐ ์ํด์์ด๋ค. ๋ค์ ์์ ์ฝ๋๋ฅผ ๋ณด์. class parent { public: parent() { std::cout