[C/C++] C++ STL Container [2]
์ปจํ ์ด๋(Container)?
C++ STL ์ปจํ
์ด๋๋ ๊ฐ์ ํ์
์ ๊ฐ์ฒด๋ค์ ์ ์ฅํ๊ณ ๊ด๋ฆฌํ ์ ์๊ฒ ํ๋ค. template์ ์ฌ์ฉํ์ฌ ์ ๋ค๋ฆญํ๊ฒ ๊ตฌํ๋์ด ์๊ธฐ ๋๋ฌธ์ ํน์ ํ ์๋ฃํ์ ์์กดํ์ง ์๋๋ค.
์ฐ๊ด ์ปจํ ์ด๋
vector, list์ ๊ฐ์ ์ํ์ค ์ปจํ ์ด๋๋ ์ํ๋ ์กฐ๊ฑด์ ํด๋นํ๋ ๋ฐ์ดํฐ๋ฅผ ๋น ๋ฅด๊ฒ ์ฐพ์ ์ ์๋ค๋ ๋จ์ ์ด ์๋ค. ์ฐ๊ด ์ปจํ ์ด๋๋ Key โ Value ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ์ปจํ ์ด๋๋ก, ์์๋ค์ ๋ํ ๋น ๋ฅธ ์ ๊ทผ์ ์ ๊ณตํ๋ค.
1. ๋งต (map)
ํค๋ํ์ผ <map>, namespace std
template <typename Key, typename Value> class map;
ํน์ง
- ๋ ธ๋ ๊ธฐ๋ฐ์ด๋ค.
class Node
{
public:
Node* _left;
Node* _right;
pair<int, string> _data;
};
- data์ ์๋ฃํ์ด pair๋ผ pair๋ก ์ฝ์ ํด์ผ ํ๋ค.
int main()
{
map<int, int> m1;
m1.insert(pair<int, int>(2, 5));
m1.erase(2);
return 0;
}
- Red-Black Tree(์๊ฐ ๊ท ํ ์ด์ง ํ์ ํธ๋ฆฌ)๋ก ๊ตฌํ๋์ด ์๋ค. ๋๋ฌธ์ ์ฝ์ , ์ญ์ , ๊ฒ์ ๋ชจ๋ O(logN). ์ต์ ์ ๊ฒฝ์ฐ์๋ O(logN)๋ ์งํด.
- key ์ค๋ณต ์ ๋๊ณ , ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํ์ฌ ์ ์ฅ.
- ์ ๋ ฌ์ ์ ์งํ๊ธฐ ์ํ ์ถ๊ฐ์ ์ธ ์์ ์ด ํ์ํด์ ์์์ ์ฝ์ /์ญ์ ๊ฐ ๋น๋ฒํ ๊ฒฝ์ฐ ์ฑ๋ฅ์ด ์ ํ๋๋ค.
์ฝ๋
#include<iostream>
#include<map>
using namespace std;
int main()
{
map<int, int> m1;
for (int i = 0; i < 100; i++)
{
m1.insert(pair<int, int>(i, i*2));
}
m1.erase(2); // key๊ฐ 2์ธ ๋
ธ๋ ์ ๊ฑฐ
map<int,int>::iterator findIt = m1.find(2); // key๊ฐ 2์ธ ๋
ธ๋ ์ฐพ๊ธฐ : ๋ชป ์ฐพ์
if (findIt != m1.end())
{
cout << "์ฐพ์" << endl;
}
else { cout << "๋ชป ์ฐพ์" << endl; }
findIt = m1.find(4); // key๊ฐ 4์ธ ๋
ธ๋ ์ฐพ๊ธฐ : ์ฐพ์
if (findIt != m1.end())
{
cout << "์ฐพ์" << endl;
}
else { cout << "๋ชป ์ฐพ์" << endl; }
for (map<int, int>::iterator it = m1.begin(); it != m1.end(); ++it)
{
pair<const int, int>& p = (*it);
int key = it->first;
int value = it->second;
cout << key << " " << value << endl;
}
m1.insert(make_pair(1, 4)); // ์ด๋ฏธ ์๋ key๋ผ๋ฉด value ์์ ์ ๋จ. return ํด์ฃผ๋ pair.second๊ฐ false.
// ์์ผ๋ฉด ์ถ๊ฐ, ์์ผ๋ฉด ์์ ํด ์ฃผ๋ ์ฝ๋
map<int, int>::iterator findIt2 = m1.find(1);
if (findIt2 != m1.end())
{
findIt2->second = 4;
}
else
{
m1.insert(make_pair(1, 4));
}
// ์ฌ์ค ์ด๊ฑด ์ด๋ฐ ์์ผ๋ก ์ ๊ณต๋๋ค.
m1[1] = 4;
// ์ด๋ ๊ฒ ํด๋ key = 1000์ธ ๊ฐ์ด ์ถ๊ฐ๋๋ฏ๋ก ์ฃผ์ํด์ผ ํ๋ค..
cout << m1[1000] << endl;
return 0;
}
2. ํด์๋งต (unordered map)
ํค๋ํ์ผ <unordered_map>, namespace std
template <typename Key, typename Value> class unordered_map;
ํน์ง
- Hash Table ๊ธฐ๋ฐ (map์ Red-black Tree)
- Key ์ค๋ณต ์ ๋๊ณ , ์ ๋ ฌ๋์ง ์๊ณ ๋๋คํ๊ฒ ์ ์ฅ๋๋ค.
- insert, erase, find ๋ชจ๋๊ฐ O(1).
- (์ค์) ์ฝ์ , ์ญ์ , ๊ฒ์ ์ ํด์ ์ถฉ๋์ด ์ผ์ด๋์ O(N)๊น์ง๋ ๊ฑธ๋ฆด ์ ์๋ค. ์์ ์ ์ธ ์๋๊ฐ ์ค์ํ ์์ ์ด๋ผ๋ฉด ํญ์ O(logN)์ธ map์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ ์๋ ์๋ค. ์ต์ ํ๊ฐ ์ค์ํ๋ค๋ฉด ํด์ ํจ์๋ฅผ ์ ์ง์ unordered map ์ฌ์ฉ.
- ์ง์ ๋ง๋ ํด๋์ค๋ฅผ ๋ฃ์ผ๋ ค๋ฉด ํด์ ํจ์๋ฅผ ์ง์ ๋ง๋ค์ด์ผ ํ๋ค. C++ STL์์ int, string ๋ฑ ๊ธฐ๋ณธ์ ์ธ ํ์ ๋ค์ ๋ํ ํด์ ํจ์๋ฅผ ์ ๊ณตํ๊ธฐ ๋๋ฌธ์ ์ด๋ฅผ ์ ํ์ฉํด์ ๋ง๋ค๋ฉด ๋๋ค.
- Bucket์ ๋๋ ค์ผ ํ๋ ๊ฒฝ์ฐ์ ํด์ ํจ์๋ฅผ ๋ฐ๊ฟ์ผ ํด์ ๊ธฐ์กด ์์๋ค์ ๋ชจ๋ ๋ค์ insert ํด์ค์ผ ํ๋, O(N)์ด ๊ฑธ๋ฆฌ๋ rehash ์์ ์ด ์คํ๋๋ค. (์ฝ๊ฐ ๋ฒกํฐ capacity ๋๋ฆฌ๋ ๋๋)
- Hash Table ์ฌ์ฉ์ผ๋ก ์ธํด ๋น๊ต์ ๋ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฆฌ๊ณ , ํด์ ์ถฉ๋๋ก ์ธํด O(N)์ด ๊ฑธ๋ฆด ์ ์์์ ์ฃผ์ํด์ ์ฌ์ฉํ์.
unordered_multimap
Key ์ค๋ณต ๊ฐ๋ฅํ unordered_map์ unordered_multimap์ด๋ค. Key์ ๋ํ Value๋ฅผ ๊ฐ์ ธ์ค๋ฉด iterators(์ฃผ์ ๋ฒ์)๋ก ์ค๋ค.
Leave a comment