KH_C++
deque, map ๋ณธ๋ฌธ
๐deque
deque - (double ended queue) ์ปจํ ์ด๋์ ๋งจ ์๊ณผ ๋งจ ๋ค์์ ์ฝ์ /์ ๊ฑฐ๋ฅผ ๋น ๋ฅด๊ฒ ํ ์ ์๋ค๋ ๊ฒ์ด ๋ํ์ ํน์ง์ด๋ค. ์คํ(LIFO)๊ณผ ํ(FIFO)๋ฅผ ํฉ์ณ๋์ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ๋ฉด ๋ ๊ฒ ๊ฐ๋ค.
๐deque ์ ํค๋ํ์ผ
#include <deque>
๐deque ์ ํน์ง (๋ค๋ฅธ ์๋ฃ๊ตฌ์กฐ๋ค๊ณผ์ ๋น๊ต)
- vector ์ฒ๋ผ ์์๋ค์ [] ์ธ๋ฑ์ค๋ฅผ ์ฌ์ฉํ์ฌ Random Access ๊ฐ ๊ฐ๋ฅํ๋ค.
- stack ๊ณผ queue ์ ์ฐจ๋ณํ๋ ๊ฐ์
- vector ์ฒ๋ผ ์์๋ค์ ์ด๋ค ์์๋ก๋ ์๋ก๋ ๋ค ์์๋ค์ ์ํํ ์ ์๋ค.
- vector ๊ฐ capacity ๊ฐ ๊ณ ๊ฐ๋๋ฉด ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ์ ์ด์์ ์ฌํ ๋น ๋ฐ๋ ๊ฒ๊ณผ ๋ฌ๋ฆฌ deque ๋ ์ผ์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ chunk ๋จ์๋ก ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ฅ๋๋ค.
- vector ๋ณด๋ค ํ์ฅ ๋น์ฉ์ด ์ ๊ฐ๋๋ค.
- vector ์ ๋ฌ๋ฆฌ ์ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ์๋๋ค.
- ๋ฐ๋ผ์ vector์ ๋ฌ๋ฆฌ ํฌ์ธํฐ ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ๋ค.
- list ์ฒ๋ผ ์ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด ์๋๋ค.
- stack, vector, list ์ฒ๋ผ ๋งจ ๋ค์์ ์ฝ์
/์ ๊ฑฐ ํ๋ ๊ฒ์ด ๋น ๋ฅด๋ค.
- queue ์ ์ค์ง ๋งจ ์์์๋ง ์ ๊ฑฐ๊ฐ ๊ฐ๋ฅํ์ง๋ง deque ๋ ๋งจ ๋ค์์๋ ์ ๊ฑฐ๊ฐ ๊ฐ๋ฅ
- stack ๊ณผ queue ๊ฐ deque ๋ก ๊ตฌํ ๊ฐ๋ฅํ ์ด์ .
- queue, list ์ฒ๋ผ ๋งจ ์์์ ์ฝ์
/์ ๊ฑฐ ํ๋ ๊ฒ์ด ๋น ๋ฅด๋ค.
- vector ์ ์ฐจ๋ณํ๋ ๊ฐ์
- stack ์ ์ค์ง ๋งจ ๋ค์์๋ง ์ ๊ฑฐ๊ฐ ๊ฐ๋ฅํ์ง๋ง deque ๋ ๋งจ ์์์๋ ์ ๊ฑฐ๊ฐ ๊ฐ๋ฅ
- stack ๊ณผ queue ๊ฐ deque ๋ก ๊ตฌํ ๊ฐ๋ฅํ ์ด์ .
- list ์ ๋ฌ๋ฆฌ ๋งจ ๋ค, ๋งจ ์์ด ์๋ ์ค๊ฐ ์์๋ฅผ ์ฝ์ /์ ๊ฑฐ ํ๋ ๊ฒ์ ๋๋ฆฌ๋ค.
๐ deque์ push_front( ) ์ pop_front( )๋ฅผ ์ง์
: vector์ ๊ฒฝ์ฐ push_back( ) , pop_back( ) ๋ค์์ ์ฝ์ , ์ญ์ ๋ง์ ์ ๊ณตํ๋ค. ํ์ง๋ง, deque๋ 'double-ended queue'์์ ๋ถ์ฌ์ง ์ด๋ฆ๋ต๊ฒ ์ปจํ ์ด๋ ์์ชฝ ๋์์ ์์๋ฅผ ๋ชจ๋ ์ฝ์ , ์ญ์ ๊ฐ ๊ฐ๋ฅํ๋ค.
๐. vector์ capacity( ) ์ reserve( ) : deque ๊ฐ์ ๊ฒฝ์ฐ์๋ ์ด๋ฐ ํจ์๊ฐ ํ์์๊ธฐ ๋๋ฌธ์ ์ง์ํ์ง ์๊ณ ์๋ ๊ฒ์ธ๋ฐ ์ด์ ๋ฅผ ์๋ ค๋ฉด ๊ฐ ํ์์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ๊ด๋ฆฌ ํ๊ณ ์๋์ง ์ ํ์๊ฐ ์๋ค.
๐ vector์ ๊ฒฝ์ฐ์๋ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ๋ค.
ex) ์๋ฅผ ๋ค์ด 10MB์ vector๋ ์ฐ์๋ 10MB์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ค.
->ํ์ง๋ง ๊ฒฝ์ฐ์ ๋ฐ๋ผ์ ์ฐ์๋๊ฒ์ด ์๋๋ผ 10MB๋ฅผ ์์ ๋ธ๋ก์ผ๋ก ์ฌ๋ฌ๊ฐ ๋๋์ด์ ์ฌ์ฉํ๋ ๊ฒ์ด ์ฑ๋ฅ์ด ๋ ์ข์ ์๋ ์๋ค.
๐ deque์ ๊ฒฝ์ฐ ์์ ๋ฉ๋ชจ๋ฆฌ ๋ธ๋ญ์ ์ฐ๊ฒฐํ์ฌ ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์ฑํ๋ค.
๐ Map
MAP์ ๋ ธ๋๊ฐ KEY: VALUE ์์ผ๋ก ์ด๋ฃจ์ด์ง ํธ๋ฆฌํ์์ ๊ตฌ์กฐ์ด๋ฉฐ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค.
MPA์ First, Second๊ฐ ์๋ Pair๊ฐ์ฒด๋ก ์ ์ฅ๋๋ฉฐ First-key , Second-value๋ก ์ ์ฅ๋๋ ํ์์ ๊ฐ์ง๊ณ ์๋ค.
C++์ STL MAP์ ๊ธฐ๋ฅ์ ์๊ฐ๋ณต์ก๋ O(log N)์ธ ๋ ๋๋ธ๋ํธ๋ฆฌ๋ก ๊ตฌ์ฑ๋์ด ์๋ค.
๐map์ ๊ธฐ๋ณธํจ์
๐Map์ ํค๋ํ์ผ
#include<map>;
๐Map์ ๊ธฐ๋ณธ ํ
map<key, value> m;
map์ ์๋ฃ๋ฅผ ์ ์ฅํ ๋ ๋ด๋ถ์์ ์๋์ผ๋ก ์ ๋ ฌํ๊ฒ ๋๋ค. ์ฌ๊ธฐ์ map์ key๋ฅผ ๊ธฐ์ค์ผ๋ก ์ ๋ ฌํ๊ฒ ๋๋ฉฐ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ฒ ๋๋ค.
๋ง์ฝ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ์ ํ๋ค๋ฉด
map<int, int,greater> m; ์ ์ธ ์ดํ ๋ฐ์ดํฐ์ ๋ง์ด๋์ค๋ฅผ ๋ถ์ฌ ์ฝ์ ํ๋ฉด ๋ด๋ฆผ์ฐจ์ ์ ๋ ฌ์ด ๋๋ค.
๐map ์ ์ธํ๊ธฐ
map<key type, value type>์ด ๊ธฐ๋ณธ ๊ตฌ์กฐ์ด๋ฉฐ ์ ์ธ์
map<string, int> m;
๐map search ํ๊ธฐ ( ๋ฐ์ดํฐ ํ์ธ )
iterator๋ฅผ ์ฌ์ฉํ์ฌ map์ ๋ฐ์ดํฐ๋ฅผ ํ์ธํ๊ฒ ๋๋ค.
๋ฐ์ดํฐ๋ฅผ ๋๊น์ง ์ฐพ์ง ๋ชปํ์ ๊ฒฝ์ฐ, iterator๋ map.end()๋ฅผ ๋ฐํํ๋ค.
#include <iostream>
#include <map>
#include <string>
map<string, int> m;
if(m.find("Alice") != m.end())
{
cout<<"find"<<endl;
}
else
cout<<"not find"<<endl;
๐map์ ๋ฐ์ดํฐ ์ฝ์
-์์์๋ ๋งํ์ง๋ง map์ ๋ฐ์ดํฐ์ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ insert๋ฅผ ์งํํ ๋ key๊ฐ ์ค๋ณต์ด ๋๋ค๋ฉด insert๊ฐ ์ํ๋์ง ์๋๋ค.
m.insert({"cam", 300});
๐๋ฐ๋ณต๋ฌธ ๋ฐ์ดํฐ ์ ๊ทผ ( first, second)
์ธ๋ฑ์ค ๊ธฐ๋ฐ ๋ฐ๋ณต๋ฌธ
( ์ธ๋ฑ์ค ๊ธฐ๋ฐ์ iterator๋ฅผ ํ์ฉํ์ฌ begin() ๋ถํฐ end()๊น์ง ์กฐํํ๋๊ฒ )
for( auto iter = m.begin(); iter!= m.end(); iter++)
{
cout<< iter->first <<" "<< iter->second <<endl;
}
cout<< endl;
๋ฒ์ ๊ธฐ๋ฐ ๋ฐ๋ณต๋ฌธ ํ์ฉ
for(auto iter:m)
{
cout<<iter.first<<""<iter.second<<endl;
}
๐map์์ ๋ฐ์ดํฐ ์ญ์
map์์ ๋ฐ์ดํฐ ์ญ์ ํ๊ธฐ ์ํด ํ์ฉํ๋ ํจ์๋ erase์ clear์ด๋ค
ํน์ ์์น์ ์์ ์ญ์
m.erase(m.begin()+2);
key๊ฐ์ ๊ธฐ์ค์ผ๋ก ์์ ์ญ์
m.erase("alice");
map์ ๋ชจ๋ ๋ฐ์ดํฐ ์ญ์
erase ํจ์๋ก ๋ชจ๋ ์์ ์ญ์ (map์ begin()๋ถํฐ end()๊น์ง )
m.erase(m.begin(), m.end());
clear ํจ์๋ก ๋ชจ๋ ์์ ์ญ์
m.clear();
'C++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฒกํฐ(Vector) (0) | 2022.12.16 |
---|---|
ํ๋ ฌ(MATRIX) (1) | 2022.12.15 |
๋นํธ ์ฐ์ฐ์, ์ํํธ ์ฐ์ฐ์ (0) | 2022.12.14 |
์ผ๊ฐ๋น, ์ผ๊ฐํจ์ (0) | 2022.12.07 |
์๋์ฐ ํ๋ก์์ , ์๋์ฐ ๋ฉ์ธ์ง, ๋ฉ์์ง ํ, ๋ฉ์์ง ๋ฃจํ (0) | 2022.12.05 |