CS
ํ (Heap) ๋?ํน์ํ ํธ๋ฆฌ ๊ธฐ๋ฐ ๋ฐ์ดํฐ ๊ตฌ์กฐํ์ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํ๊ธฐ ์ํ ์์ ์ด์ง ํธ๋ฆฌ ํํ์ ์๋ฃ๊ตฌ์กฐ์ต๋ ํ (Max Heap)๊ณผ ์ต์ ํ(Min Heap) ์ด 2๊ฐ์ง๊ฐ ์กด์ฌํ๋ค.์ต๋ ํ (Max Heap)๋ถ๋ชจ์ ๋
ธ๋๊ฐ ํญ์ ์์์ ๋
ธ๋๋ณด๋ค ํฐ ๊ตฌ์กฐํ์ชฝ ๋
ธ๋๋ง ๊ณ์ ์งํ๋์๋ ์๋๋ค.์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ํ์ ํธ๋ฆฌ์๋ ๊ฐ์ ์์
์ ์ํํด์ผํ๋ค.๋ถ๋ชจ์ ๊ฐ๋ณด๋ค ์์์ ๊ฐ์ด ํฌ๋ฉด ์๋๋ค.์ต์ ํ(Min Heap)๋ถ๋ชจ์ ๋
ธ๋๊ฐ ํญ์ ์์์ ๋
ธ๋๋ณด๋ค ์์ ๊ตฌ์กฐํ์ชฝ ๋
ธ๋๋ง ๊ณ์ ์งํ๋์๋ ์๋๋ค.์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ํ์ ํธ๋ฆฌ์๋ ๊ฐ์ ์์
์ ์ํํด์ผํ๋ค.๋ถ๋ชจ์ ๊ฐ๋ณด๋ค ์์์ ๊ฐ์ด ์์ผ๋ฉด ์๋๋ค.์ฅ๋จ์ ์ฅ์ ์ต๋๊ฐ ๋๋ ์ต์๊ฐ์ ๋น ๋ฅด๊ฒ ์ฐพ๊ณ ์ฝ์
ํ ์ ์์.์ฐ์ ์์ ํ๋ ์์
์ค์ผ์ค๋ง์์ ํ์ฉํ๊ธฐ ์ข์.๋จ์ ์ค๊ฐ ์์์ ..
CS
ํด์ ํ
์ด๋ธ (Hash Table) ๋?ํค-๊ฐ ์์ ๋น ๋ฅด๊ฒ ์ฝ์
, ์กฐํ, ์ ๊ฑฐํ๋ ๋ฐ ์ฌ์ฉ๋๋ ๋ฐ์ดํฐ ๊ตฌ์กฐ ์ฅ๋จ์ ์ฅ์ ํ๊ท ์ ์ผ๋ก O(1)์ ์๊ฐ์ ๊ฒ์, ์ฝ์
, ์ญ์ ๊ฐ ๊ฐ๋ฅํด ๋น ๋ฆ.ํฐ ๋ฐ์ดํฐ๋ฅผ ๊ด๋ฆฌํ๊ธฐ์ ์ ๋ฆฌํ๋ฉฐ, ์ค๋ณต ๋ฐ์ดํฐ ๋ฐฉ์ง์ ์ ์ฉ.๋จ์ ์ถฉ๋ ๋ฐ์ ์ ์ฑ๋ฅ์ด ์ ํ๋ ์ ์์.ํด์ ํจ์์ ๋ฐ๋ผ ์ฑ๋ฅ์ด ๋ฌ๋ผ์ง ์ ์์ผ๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ฑ์ด ๋จ์ด์ง ์ ์์.๊ตฌํvector๋ฅผ ์ฌ์ฉํ ๊ตฌํ#include #include #include class HashTable{private: int BUCKET; std::vector > table; public: HashTable(int b) { this->BUCKET = b; table.resize(BUCKET); } ~HashTable() {}; // ์ ์ผํ ์ธ๋ฑ์ค..
CS
ํธ๋ผ์ด (Trie) ๋?๋ฌธ์์ด์ ์ ์ฅํ๊ณ , ํจ์จ์ ์ผ๋ก ํ์ํ๊ธฐ ์ํ ํธ๋ฆฌ ํํ์ ์๋ฃ๊ตฌ์กฐtree ํํ์ ์๋ฃ๊ตฌ์กฐ์ ๋ณด ๊ฒ์ ๊ฐ์ ๋ถ์ผ์์ ํ์ฉ๋๋ค.์์ ๊ฐ์ ๊ทธ๋ฆผ์ฒ๋ผ ๋น ๋ฅด๊ฒ ๋จ์ด๋ฅผ ์ฐพ๋ ๊ฒ์ ํจ์จ์ ์ผ๋ก ๋์ํ ์ ์๋ค. ์ฅ๋จ์ ์ฅ์ ๋ฌธ์์ด ๊ฒ์์ ํจ์จ์ ์ด๋ฉฐ, ์ ๋์ฌ ๊ฒ์์ O(m) ์๊ฐ์ ์ํ ๊ฐ๋ฅ (m์ ๋ฌธ์์ด ๊ธธ์ด).์๋ ์์ฑ ๊ธฐ๋ฅ ๊ตฌํ์ ์ ์ฉ.๋จ์ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ฉฐ, ์์ ๋
ธ๋๊ฐ ๋ง์์ง์๋ก ์ฑ๋ฅ์ด ์ ํ๋ ์ ์์.๊ตฌํclass TrieNode๋ฅผ ์ฌ์ฉํ ๊ตฌํ#include #include #include class TrieNode{private:public: TrieNode *child[26]; bool wordEnd; TrieNode() { wordEnd = false; for(int i = 0;..
CS
๊ทธ๋ํ (Graph) ๋?๊ทธ๋ํ๋ ์ ์ (vertex)๊ณผ ๊ฐ์ (edge)๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐํธ๋ฆฌ (Tree) ์ ๋ฌด์จ ์ฐจ์ด๊ฐ ์๋๊ณ ์๊ฐํ ์ ์๋๋ฐ,๊ทธ๋ํ์ ๊ฒฝ์ฐ์๋ ํธ๋ฆฌ์ ๋ค๋ฅด๊ฒ ์ ์ ๋ง๋ค ๊ฐ์ ์ด ์์ ์๋ ์๊ณ ๋ถ๋ชจ ์์๊ฐ๋
์ด ์กด์ฌํ์ง ์๋ ๋ฑ ์ฐจ์ด์ ์ด ์กด์ฌํ๋ค.์งํ์ฒ ๋
ธ์ ๋ ๋ฑ์ ์ต๋จ๊ฒฝ๋ก๋ฅผ ์ฐพ๊ฑฐ๋ sns์์๋ ๊ณตํต๋ ์น๊ตฌ๋ฅผ ์ฐพ๋ ๋ฑ์ ํ์ฉ๋๋ค.์ฅ๋จ์ ์ฅ์ ๋ณต์กํ ๊ด๊ณ๋ฅผ ๋ชจ๋ธ๋งํ ์ ์์ (์์
๋คํธ์ํฌ, ๊ฒฝ๋ก ํ์ ๋ฑ)๋ค์ํ ์๊ณ ๋ฆฌ์ฆ์ ํตํด ์ต๋จ ๊ฒฝ๋ก, ์ฐ๊ฒฐ์ฑ ๋ฑ์ ์ฐพ์ ์ ์์.๋จ์ ๊ตฌํ๊ณผ ์ฐ์ฐ์ด ๋ณต์กํ๊ณ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ํผ.์ํ์ด ๋ฐ์ํ ๊ฒฝ์ฐ ์ฒ๋ฆฌ๊ฐ ์ด๋ ค์ธ ์ ์์.๊ตฌํ๋ฅผ ์ฌ์ฉํ ๊ตฌํ#include #include class Graph{private: int V; std::vector > adjMatri..
CS
ํธ๋ฆฌ (Tree) ๋?ํธ๋ฆฌ๋ ๊ณ์ธต์ ์ธ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ๋ก, ๋ถ๋ชจ์ ์์ ๋
ธ๋ ๊ฐ์ ๊ด๊ณ๋ฅผ ๋ํ๋ธ๋ค. ๋ฐ์ดํฐ ๊ตฌ์กฐํ๊ฐ ์ฉ์ดํด ํ์ผ ์์คํ
, ๊ณ์ธต์ ๋ฐ์ดํฐ ์ ์ฅ ๋ฑ์ ์ฌ์ฉ ๊ฐ๋ฅ.์ฅ๋จ์ ์ฅ์ ๋ฐ์ดํฐ ๊ฒ์, ์ฝ์
, ์ญ์ ๊ฐ ํจ์จ์ (ํนํ ์ด์ง ํ์ ํธ๋ฆฌ์ ๊ฒฝ์ฐ).๋ฐ์ดํฐ ๊ตฌ์กฐํ๊ฐ ์ฉ์ดํด ํ์ผ ์์คํ
, ๊ณ์ธต์ ๋ฐ์ดํฐ ์ ์ฅ ๋ฑ์ ์ฌ์ฉ ๊ฐ๋ฅ.๋จ์ ๊ท ํ์ด ๋ง์ง ์์ ๊ฒฝ์ฐ ์ฑ๋ฅ ์ ํ ๊ฐ๋ฅ.๊ตฌํ์ด ๋ณต์กํ๊ณ ๋
ธ๋ ์ถ๊ฐ ์ ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋ ๋ฐ์ํธ๋ฆฌ (Tree)๋ ๋์ถฉ๋ณด๋ฉด ๋งํฌ๋๋ฆฌ์คํธ (Linked List)๋ ๊ตฌ์กฐ๊ฐ ๋น์ทํ๋ค๊ณ ์๊ฐํ ์๋ ์๋๋ฐ.ํธ๋ฆฌ (Tree)์ ๊ฒฝ์ฐ์๋ ํ๋์ ๋ถ๋ชจ๊ฐ ์ฌ๋ฌ๊ฐ์ ์์์ ๊ฐ์ง๊ณ ์๊ณ , ์ต์์์ ๋
ธ๋์ ๊ฒฝ์ฐ์๋ ๋ถ๋ชจ๊ฐ ๋ฐ๋ก ์๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.๊ตฌํ#include ์ ํ์ฉํ ๋ค์ค๊ณ์ธต ํธ๋ฆฌ๊ตฌํ#in..
CS
๋งํฌ๋๋ฆฌ์คํธ (Linked list) ๋?์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๊ฐ ๋
ธ๋๊ฐ ๋ฐ์ดํฐ์ ๋ค์ ๋
ธ๋์ ์ฃผ์๋ฅผ ํฌํจํ์ฌ ์์ฐจ์ ์ผ๋ก ์ฐ๊ฒฐ๋ ์๋ฃ๊ตฌ์กฐ๋์ ์ผ๋ก ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์๋ค.๊ธฐ์กด์ ์ผ๋ก๋ ํ์ฌ์ ๋
ธ๋๊ฐ ๋ค์ ๋
ธ๋๋ง์ ์ฐธ์กฐํ๋ ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Singly Linked List) ๋ถํฐ ์ด์ ๋
ธ๋์ ๋ค์ ๋
ธ๋ ๋ชจ๋๋ฅผ ์ฐธ์กฐํ๋ ์๋ฐฉํฅ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Doubly Linked List) ๋ฑ์ผ๋ก ๋ค์ํ๊ฒ ํ์ฅ์ด ์ด๋ฃจ์ด์ง ์ ์๋ค.์ฅ๋จ์ ์ฅ์ ๋์ ์ผ๋ก ํฌ๊ธฐ๋ฅผ ์กฐ์ ํ ์ ์๋ค.๋ฐฐ์ด๊ณผ ๋ฌ๋ฆฌ ์ฝ์
์ญ์ ์ ์ฉ์ดํ๋ค.๋จ์ ์์์ ์ผ๋ก ํน์ ๋ฐ์ดํฐ์ ์ ๊ทผ์ด ๋ถ๊ฐ๋ฅํ๋ค.์ถ๊ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๋น์ฉ์ด ๋ ๋ค. ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Singly Linked List)์ฅ์ :๊ฐ ๋
ธ๋๊ฐ ๋ค์ ๋
ธ๋๋ง์ ์ฐธ์กฐ๋ next๋ง ๊ฐ์ง๊ณ ์๊ธฐ๋๋ฌธ์ ์๋ฑกํฅ์ ๋นํด ๋ฉ๋ชจ๋ฆฌ์ฌ์ฉ๋์ด ์ค์ด๋ ๋ค..
CS
ํ (Queue) ๋?ํ๋ FIFO(First In, First Out) ๊ตฌ์กฐ๋ก, ๋จผ์ ๋ค์ด์จ ๋ฐ์ดํฐ๊ฐ ๋จผ์ ๋๊ฐ๋ ์๋ฃ๊ตฌ์กฐ์คํ๊ณผ๋ ๋ค๋ฅด๊ฒ ๋จผ์ ๋ค์ด์จ๊ฒ์ด ๋จผ์ ๋๊ฐ๋ FIFO ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.์ฅ๋จ์ ์ฅ์ ๋ฐ์ดํฐ์ ์ฝ์
๊ณผ ์ญ์ ๊ฐ O(1) ์๊ฐ์ผ๋ก ์ด๋ฃจ์ด์ ธ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌ๊ฐ ๋๋ค.๋จ์ ์ค๊ฐ๊ณผ ๋ง์ง๋ง์ ์๋ ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ ค๊ณ ํ๋ฉด ๋นํจ์จ์ ์ด๋ค.๊ตฌํ#include ์ฌ์ฉ#include #include using namespace std;int main(void) { queue q; q.push(1); q.push(2); q.push(3); cout deque๋ฅผ ํ์ฉํ ๊ตฌํ#ifndef CUSTOMQUEUE_HPP_#define CUSTOMQUEUE_HPP_#include #include template class Cu..
CS
์คํ (Stack) ์ด๋?์์๊ฐ ๋ณด์กด๋๋ ์ ํ ๋ฐ์ดํฐ ๊ตฌ์กฐ์คํ์ LIFO(Last In, First Out) ๊ตฌ์กฐ๋ก, ๋ง์ง๋ง์ ๋ค์ด๊ฐ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋จผ์ ๋์ค๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ผ๊ธฐํ๋ค.์์ธ ์ ์๋ ํ๋
ธ์ด ํ์ ์์๋ก ์๊ฐํ๋ฉด ๋๋ค.์ฅ๋จ์ ์ฅ์ ๋ฐ์ดํฐ์ ์ฝ์
๊ณผ ์ญ์ ๊ฐ O(1) ์๊ฐ์ผ๋ก ์ด๋ฃจ์ด์ ธ ๋น ๋ฅด๊ฒ ์ฒ๋ฆฌ๊ฐ ๋๋ค.๋จ์ ์ค๊ฐ๊ณผ ๋ง์ง๋ง์ ์๋ ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ ค๊ณ ํ๋ฉด ๋นํจ์จ์ ์ด๋ค.๊ตฌํ#include ์ฌ์ฉ#include #include using namespace std;int main(void) { stack s; s.push(1); s.push(2); s.push(3); cout ์ ์ ํ ๋น ๋ฐฉ์์ผ๋ก ๊ตฌํ#ifndef CUSTOMSTACK_HPP#define CUSTOMSTACK_HPP#define MAX_SIZE ..
CS
๋ฐฐ์ด (Array)์ด๋?๊ฐ์ฅ ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ๊ตฌ์กฐ๋ฅผ ์ด์ผ๊ธฐํ๋ค.๋์ผํ ํ์
์ ๋ฐ์ดํฐ๋ฅผ ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์์น์ ์ ์ฅํ๋ค.์ฅ๋จ์ ์ฅ์ ์ธ๋ฑ์ค๋ฅผ ํตํด ๊ฐ ์์์ O(1) ์๊ฐ์ ์ ๊ทผ ๊ฐ๋ฅํ๋ค.๊ตฌํ์ด ๊ฐ๋จํ๊ณ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ์ด ํจ์จ์ ์ด๋ค.๋จ์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด์๊ธฐ๋๋ฌธ์ ํฌ๊ธฐ๋ฅผ ๋ณ๊ฒฝํ๊ธฐ์ํด์๋ ์๋ก์ด ๋ฐฐ์ด์ ์์ฑํด์ผํ๋ค.์ค๊ฐ์ ์์๋ฅผ ์ฝ์
ํ๊ฑฐ๋ ์ญ์ ํ ๊ฒฝ์ฐ์๋ ํด๋น ์์ ์ด์ธ์ ๋ชจ๋ ์์๋ฅผ ์ด๋ํด์ผํ๋ฏ๋ก ๋นํจ์จ์ ์ด๋ค.๊ตฌํ#include int main(void) { // stack int number[5] = {1, 2, 3, 4, 5}; char s[5] = {'a', 'b', 'c', 'd', 'e'}; // heap int* arr = new int[5]; arr[0] = 1; arr[1] = 2; delete arr..