๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

๐Ÿ“ ์•Œ๊ณ ๋ฆฌ์ฆ˜/Code Tree

[์ฝ”๋“œํŠธ๋ฆฌ] Tree Map

SW์ค‘์‹ฌ๋Œ€ํ•™ ์‚ฌ์—…๋‹จ์—์„œ CodeTree์™€ ํ•จ๊ป˜ ์‹ค์‹œํ•œ ์ฝ”๋”ฉํ…Œ์ŠคํŠธ ๋Œ€๋น„ ์บ ํ”„์— ์ฐธ์—ฌํ•˜์—ฌ ๊ณต๋ถ€ํ•œ ๋‚ด์šฉ์„ ์ •๋ฆฌํ•˜์˜€์Šต๋‹ˆ๋‹ค.

 

* ์ฐธ๊ณ  : python๊ณผ c++, java ๋“ฑ ์–ธ์–ด๋ณ„๋กœ ์„ค๋ช…์ด ๋‹ค๋ฅธ ๋ถ€๋ถ„ ์กด์žฌ! ํ•„์ž๋Š” c++ ์‚ฌ์šฉ.

 

xxilliant ์ œ์ž‘

map STL

C++์—์„œ๋Š” map์ด๋ผ๋Š” STL์„ ์ด์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

map์€ TreeMap ์ž๋ฃŒ๊ตฌ์กฐ๋กœ ๋˜์–ด์žˆ์œผ๋ฉฐ, TreeMap์˜ ๊ฒฝ์šฐ ๊ท ํ˜• ์žกํžŒ ์ด์ง„ํŠธ๋ฆฌ ๊ตฌ์กฐ๋กœ ๋ฐ์ดํ„ฐ๋“ค์„ ๊ด€๋ฆฌํ•ด์ฃผ๋Š” ์ž๋ฃŒ๊ตฌ์กฐ ์ž…๋‹ˆ๋‹ค.

 

TreeMap์€ ๊ฐ ๋…ธ๋“œ์— (key, value) ์Œ ํ˜•ํƒœ๋กœ ๋“ค์–ด๊ฐ€ ์žˆ์–ด, key๋ฅผ ๊ธฐ์ค€์œผ๋กœ ๋…ธ๋“œ์˜ ์œ„์น˜๊ฐ€ ๊ฒฐ์ •๋˜๊ณ  ๊ฐ key์— ๋Œ€ํ•œ value๊ฐ’์„ ์ €์žฅํ•˜๋Š” ํ˜•ํƒœ์ž…๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ TreeMap์—์„œ ๋ชจ๋“  ํ•จ์ˆ˜์˜ ์‹œ๊ฐ„๋ณต์žก๋„๊ฐ€ ์ „๋ถ€ ์ž…๋‹ˆ๋‹ค.

#include <map> ํ—ค๋”์™€, map<K, V> name; ํ˜•ํƒœ์˜ ์„ ์–ธ์ด ํ•„์š”ํ•ฉ๋‹ˆ๋‹ค.

๋˜, map์€ ์›๋ž˜ std::map์œผ๋กœ ์“ฐ์—ฌ์•ผ ํ•˜๋ฏ€๋กœ using name space std;๋ฅผ ๋ฏธ๋ฆฌ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.

 

์ •์ˆ˜๋ฅผ ๊ด€๋ฆฌํ•  map์€ ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์„ ์–ธํ•ด ๋ณผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

#include <iostream>
#include <map>

using namespace std;

int main() {
    map<int, int> m;
    return 0;
}
 

map<int, int> m;๋กœ ์„ ์–ธ๋˜์–ด ์‚ฌ์šฉ๋  ๋•Œ๋ฅผ ์˜ˆ๋กœ ์„ค๋ช…ํ•ด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

  1. m.insert({K, V}) ํ˜น์€ m[K] = V

treemap์— ์Œ(K, V)๋ฅผ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

{K, V}๋Š” ์‹ค์ œ std::pair๋ผ๋Š” c++์—์„œ ์ œ๊ณตํ•˜๋Š” ์Œ์˜ ํƒ€์ž…์ž…๋‹ˆ๋‹ค. pair๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์ด ์ด์šฉ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

    pair<int, int> p;         // pairํ˜• ๋ณ€์ˆ˜ ์„ ์–ธ
    p = make_pair(1, 5);      // (1, 5)์Œ ์„ ์–ธ. p = {1, 5}๋„ ๊ฐ€๋Šฅ
    cout << p.first << endl;  // ์ฒซ ๋ฒˆ์งธ ๊ฐ’(key) access
    cout << p.second << endl; // ๋‘ ๋ฒˆ์งธ ๊ฐ’(value) access 

    p.first = 10;             // ์ฒซ ๋ฒˆ์งธ ๊ฐ’ ๋ณ€๊ฒฝ
    p.second = 15;            // ๋‘ ๋ฒˆ์งธ ๊ฐ’ ๋ณ€๊ฒฝ
 
  1. m.erase(K)

ํ˜„์žฌ treemap์— ๋“ค์–ด์žˆ๋Š” ๋ฐ์ดํ„ฐ ์ค‘ key๊ฐ€ K์ธ ์Œ์„ ์ œ๊ฑฐํ•ฉ๋‹ˆ๋‹ค.

  1. m.find(K) ํ˜น์€ m[K]

ํ˜„์žฌ treemap์— key๊ฐ€ K์ธ ์Œ์ด ์žˆ๋Š”์ง€๋ฅผ ํ™•์ธํ•ฉ๋‹ˆ๋‹ค. m.find(K) ์ด์šฉ์‹œ ๋งŒ์•ฝ ์žˆ๋‹ค๋ฉด ํ•ด๋‹น iterator๋ฅผ ๋ฐ˜ํ™˜ํ•˜๋ฉฐ, ์—†๋‹ค๋ฉด m.end()๊ฐ’์„ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค. ๋”ฐ๋ผ์„œ ๊ฐ’์ด ์žˆ๋‹ค๋ฉด m.find(K) != m.end(), ์—†๋‹ค๋ฉด m.find(K) == m.end()๋ฅผ ๋งŒ์กฑํ•  ๊ฒƒ์ž…๋‹ˆ๋‹ค.

์ด๋•Œ, ์›์†Œ๋Š” pair ํƒ€์ž…์ด๊ธฐ ๋•Œ๋ฌธ์— ๋‹ค์Œ๊ณผ ๊ฐ™์ด ๊ฐ’์— ์ ‘๊ทผํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

cout << (m.find(K))->first << endl;     // key๊ฐ€ K์ธ ์›์†Œ์˜ key ์กฐํšŒ
cout << (m.find(K))->second << endl;    // key๊ฐ€ K์ธ ์›์†Œ์˜ value ์กฐํšŒ
cout << (*m.find(K)).first << endl;     // key๊ฐ€ K์ธ ์›์†Œ์˜ key ์กฐํšŒ
cout << (*m.find(K)).second << endl;    // key๊ฐ€ K์ธ ์›์†Œ์˜ value ์กฐํšŒ
 

๊ฐ’๋งŒ ์กฐํšŒํ•˜๊ณ  ์‹ถ์€ ๊ฒฝ์šฐ๋ผ๋ฉด ๋ฐฐ์—ด์—์„œ ์ธ๋ฑ์Šค๋ฅผ ์ด์šฉํ•˜๋“ฏ์ด m[K] ํ˜•ํƒœ๋กœ๋„ ์ด์šฉ ๊ฐ€๋Šฅํ•ฉ๋‹ˆ๋‹ค.

cout << m[K] << endl;                   // key๊ฐ€ K์ธ ์›์†Œ์˜ value ์กฐํšŒ
 
  1. iterator๋ฅผ ์ด์šฉํ•œ treemap์„ key ๊ธฐ์ค€ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ˆœํšŒ

 

C++์—์„œ๋Š” vector, stack๋“ฑ์˜ ์ปจํ…Œ์ด๋„ˆ๋“ค์„ iterator๋ผ๋Š” ๋ฐ˜๋ณต์ž๋ฅผ ์ด์šฉํ•ด ์ˆœํšŒ๊ฐ€ ๊ฐ€๋Šฅํ•˜๋‹ค๊ณ  ํ–ˆ์Šต๋‹ˆ๋‹ค. ๊ทธ ์ค‘์—์„œ๋„ treemap์„ iterator๋ฅผ ์ด์šฉํ•˜์—ฌ ์ˆœํšŒํ•˜๊ฒŒ ๋˜๋ฉด, ์ž๋™์œผ๋กœ key ๊ธฐ์ค€ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ˆœํšŒ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

 

map์„ iterator๋ฅผ ์ด์šฉํ•ด ์ˆœํšŒํ•˜๋Š” ์ฝ”๋“œ๋Š” ๋‹ค์Œ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

#include <iostream>
#include <map>

using namespace std;

int main() {
    map<int, int> m;            // ์ •์ˆ˜ ์Œ์„ ๊ด€๋ฆฌํ•  treemap์„ ์„ ์–ธํ•ฉ๋‹ˆ๋‹ค.
    m.insert({5, 6});           
    m.insert({2, 2});           
    m.insert({10, 1});          

    // Iterator๋ฅผ ์ด์šฉํ•œ map ์ปจํ…Œ์ด๋„ˆ ๋‚ด์˜ ์›์†Œ๋“ค ์ˆœํšŒ
    map<int, int>::iterator it;
    // key ๊ธฐ์ค€ ์˜ค๋ฆ„์ฐจ์ˆœ์œผ๋กœ ์ˆœํšŒํ•˜๊ฒŒ ๋˜๋ฏ€๋กœ
    // (2, 2), (5, 6), (10, 1) ์ˆœ์œผ๋กœ ์ถœ๋ ฅ๋ฉ๋‹ˆ๋‹ค.
    for(it = m.begin(); it != m.end(); it++) {
        cout << (it -> first) << " " << (it -> second) << endl;
    }    
    return 0;
}
 

๋งŒ์•ฝ ์ˆœํšŒ ์ „์— map์ด ๋น„์–ด์žˆ๋Š”์ง€๋ฅผ ์•Œ๊ณ ์‹ถ๋‹ค๋ฉด, empty()ํ•จ์ˆ˜๋‚˜ size()๊ฐ€ 0์ธ์ง€๋ฅผ ํ™•์ธํ•˜๋ฉด ๋ฉ๋‹ˆ๋‹ค.

 

 

์ถœ์ฒ˜ ์ฝ”๋“œํŠธ๋ฆฌ