โ๏ธ ์ด๋ฒ ์๊ฐ์๋ Set๊ณผ Queue ์ธํฐํ์ด์ค์ ์ด๋ฅผ ๊ตฌํํ ํด๋์ค์ ๋ํด์ ์์๋ณด๊ณ , ๊ฐ ํด๋์ค ๋ณ๋ก ์ด๋ป๊ฒ ํด๋น ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌํํ๋์ง, ํน์ง์ ๋ฌด์์ธ์ง ์์๋ณด๋ ์๊ฐ์ ๊ฐ์ ธ๋ณด๋ ค ํ๋ค.
Set
์ํ์์์ ์งํฉ์ ๊ฐ๋ ๊ณผ ๋์ผํ๊ฒ ์ค๋ณต ์งํฉ์ ์ ์ธํ๊ณ ์งํฉ ๋ด ์กด์ฌํ๋ ์์๋ค์ ์๋ก ๋ค๋ฅด๋ฉฐ, ๊ฐ์ ์์๊ฐ ์ฌ๋ฌ ๊ฐ ์กด์ฌ ํ ์ ์๋ค. ์ด๋ฅผ ๋ฐํ์ผ๋ก Set ์๋ฃ๊ตฌ์กฐ๋ ๊ฐ์ฒด ๋ด์ ๋ด๊ธด ๋ฐ์ดํฐ์ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค.
๋ํ, Set ์๋ฃ๊ตฌ์กฐ๋ ์์์ ์๊ด์์ด ๋ฐ์ดํฐ๋ฅผ ๋ด๋๋ค. ๋๋ฌธ์ ํน์ ์์์ ์กด์ฌํ๋ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด์ด ์ฌ์ฉํ ๋ ์ฌ์ฉํ๊ธฐ ๋ณด๋ค๋ ํน์ ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๊ฑฐ๋ ํด๋น ๊ฐ์ฒด ๋ด์ ๋ฐ์ดํฐ๊ฐ ์ผ๋ง๋ ์กด์ฌํ๋์ง ํ์ธํ๊ธฐ ์ํด ์ฃผ๋ก ์ฌ์ฉ๋๋ค.
์ด๋ฌํ Set ์ธํฐํ์ด์ค๋ Collection ์ธํฐํ์ด์ค๋ฅผ ํ์ฅํ์ฌ ๋ฉ์๋๋ฅผ ๋ช ์ธํ๊ณ ์์ผ๋ฉฐ, ์ด๋ฅผ ๊ตฌํํ ํด๋์ค๋ ๋ํ์ ์ผ๋ก HashSet, LinkedHashSet, TreeSet ํด๋์ค๊ฐ ์กด์ฌํ๋ค.
Set ๋ฝ์๋จน๊ธฐ
๐ ๊ฐ์ฒด ๋ด ์กด์ฌํ๋ ๋ฐ์ดํฐ์ ์ค๋ณต์ ํ์ฉํ์ง ์๋๋ค.
๐ ์์์ ์๊ด์์ด ๋ฐ์ดํฐ๋ฅผ ๋ด์ง๋ง, ํน์ ํด๋์ค๋ ์์ ๋ฐ ์ ๋ ฌ์ ์ง์ํ๋ค.
๐ ๋ํ์ ์ผ๋ก HashSet, LinkedHashSet, TreeSet ํด๋์ค๊ฐ ์๋ค.
HashSet
HashSet ํด๋์ค๋ List ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค์ ๋น์ทํ๊ฒ Serializable, Cloneable ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๊ณ , AbstractSet ํด๋์ค๋ฅผ ํ์ฅํ๋ค.
์ด๋ ์์ ๋ฐฐ์ ๋ ๊ฒ ์ฒ๋ผ ์ง๋ ฌํ๋ฅผ ํตํด ์ธ๋ถ ์๋ฒ๋ก ํด๋น ๊ฐ์ฒด๋ฅผ ์ ์กํ๊ฑฐ๋ ํ์ผ๋ก ์ ์ฅํ๊ณ , ํด๋น ํด๋์ค๋ก ์์ฑ๋ ๊ฐ์ฒด๋ ํด๋ก ์ด ๊ฐ๋ฅํ๋ค๋ ๊ฒ์ ์๋ฏธํ๋ฉฐ, AbsctractSet ํด๋์ค๋ฅผ ํตํด Set ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋ ํด๋์ค๋ค์ ๊ณตํต์ ์ธ ๋ฉ์๋๋ฅผ ์์๋ฐ์ ์ต์ํ์ ๋ฉ์๋๋ง ๊ตฌํํ์ฌ ์ค๋ณต ์์๋ค์ ์ ๊ฑฐํ์์ ๋ปํ๋ค.
// ๊ธฐ๋ณธ ์์ฑ์
public HashSet() {
map = new HashMap<>();
}
public HashSet(Collection<? extends E> c) {
map = new HashMap<>(Math.max((int) (c.size()/.75f) + 1, 16));
addAll(c);
}
public HashSet(int initialCapacity, float loadFactor) {
map = new HashMap<>(initialCapacity, loadFactor);
}
public HashSet(int initialCapacity) {
map = new HashMap<>(initialCapacity);
}
์์ ์ฝ๋์ ์ด๋ฆ์ ํตํด HashSet ํด๋์ค๋ ๋ด๋ถ์ ์ผ๋ก HashMap ๊ฐ์ฒด๋ฅผ ์์ฑํ์ฌ ํด์ ์๊ณ ๋ฆฌ์ฆ์ ์ด์ฉํด ๊ตฌํํ ๊ฒ์ ์ ์ ์๋ค.
์์ฑ์์ ๋งค๊ฐ ๋ณ์๋ก ๋ค์ด๊ฐ๋ initalCapacity๋ ๋ฆฌ์คํธ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ํด๋์ค ๋ด์์ ์์ฃผ ์ ํด์ ์๊ณ ์๋ฏ, ๊ฐ์ฒด๊ฐ ์ฒ์ ์ ์ธ๋๊ณ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋ ๋์ ๊ธธ์ด ํน์ ํฌ๊ธฐ๋ฅผ ์๋ฏธํ๋ค.
๊ทผ๋ฐ loadFactor ๋ผ๋ ๋งค๊ฐ ๋ณ์๋ฅผ ์ธ์๋ก ๋ฐ๋ ์์ฑ์๊ฐ ์กด์ฌํ๋๋ฐ loadFactor๋ ๋ฌด์์ ์ฌ์ฉํ๋ ๊ฒ์ผ๊น?
LoadFactor
LoadFactor(์ดํ ๋ก๋ํฉํฐ)๋ (๋ฐ์ดํฐ์ ๊ฐ์) / (์ ์ฅ ๊ณต๊ฐ) ์๋ฏธํ๋ฉฐ ๊ธฐ๋ณธ์ ์ผ๋ก 0.75f ๊ฐ์ ๊ฐ์ง๋๋ฐ, ์ด๋ ์ฒ์ ๋ฉ๋ชจ๋ฆฌ์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ์ 75%๊ฐ ์ฑ์ ์ก์ ๋ ํด๋น ๊ฐ์ฒด์ ํฌ๊ธฐ๋ฅผ ๋๋ฆฌ๊ณ , ๊ธฐ์กด ๊ฐ์ฒด ๋ด์ ๋ฐ์ดํฐ๋ฅผ ๋ค์ ์ ๋ฆฌํด์ผ ํ๋ Rehash ์์ ์ ์ํํ๋ค.
๋๋ฌธ์ ๋ก๋ ํฉํฐ๋ผ๋ ๊ฐ์ด ํฌ๋ฉด ํด ์๋ก Rehash ์์ ์ ์ํํ๊ธฐ ์ ๊น์ง ์ฌ์ฉ ๊ฐ๋ฅํ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ง์์ง์ง๋ง, ๋ฐ์ดํฐ๋ฅผ ์ฐพ์์ค๋ ์๊ฐ์ ๊ทธ๋งํผ ์ฆ๊ฐํ๋ค.
์ด๋ป๊ฒ ๋์ผํ ๊ฐ์ฒด์ธ์ง ํ์ธํ๊ณ ์ ๊ฑฐํ ๊น?
// HashMap.put(K key, V value)
public V put(K key, V value) {
// 1) hash() > Key๋ก ๋ฐ์์จ ๊ฐ์ฒด์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ๋นํธ์ฐ์ฐ
// 2) putVal() > Value๋ก ๋ฐ์์จ ๊ฐ์ฒด๋ฅผ Node์ ์ ์ฅ >
// ํด๋น ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ ํ ์ ์๋ค๋ฉด null ๋ฐํ
return putVal(hash(key), key, value, false, true);
}
// HashSet.add(E e)
public boolean add(E e) {
// putVal() ๋ฉ์๋์ ๋ฆฌํด๊ฐ์ด null์ผ ๊ฒฝ์ฐ ๋ฐ์ดํฐ ์ค๋ณต์ผ๋ก Set ๊ฐ์ฒด์ ๋ด์ ์ ์๋ค.
return map.put(e, PRESENT)==null;
}
// HashSet ๋ฐ์ดํฐ ์ ์ฅ ๋ก์ง ํ์
ํ๊ธฐ
public class HashSetTest {
public static void main(String[] args) {
Object[] objArray = {"1", new Integer(1), "2", "2", "3", "4", "4", "4"};
HashSet<Object> hashSet = new HashSet<>();
for (Object obj : objArray) {
System.out.println("ํ์ฌ ๊ฐ : " + obj + " / Set์ ๋ด๊ฒผ๋์? " + hashSet.add(obj));
}
System.out.println(hashSet);
}
}
/*
ํ์ฌ ๊ฐ : 1 / ํ ๋น ์ฌ๋ถ true
ํ์ฌ ๊ฐ : 1 / ํ ๋น ์ฌ๋ถ true
ํ์ฌ ๊ฐ : 2 / ํ ๋น ์ฌ๋ถ true
ํ์ฌ ๊ฐ : 2 / ํ ๋น ์ฌ๋ถ false
ํ์ฌ ๊ฐ : 3 / ํ ๋น ์ฌ๋ถ true
ํ์ฌ ๊ฐ : 4 / ํ ๋น ์ฌ๋ถ true
ํ์ฌ ๊ฐ : 4 / ํ ๋น ์ฌ๋ถ false
ํ์ฌ ๊ฐ : 4 / ํ ๋น ์ฌ๋ถ false
[1, 1, 2, 3, 4]
*/
์์ ์ฝ๋๋ฅผ ์ดํด๋ณด์.
HashSet ํด๋์ค์์๋ ๋ค๋ฅธ Collection ํด๋์ค๋ค๊ณผ ๋น์ทํ๊ฒ add() ๋ฉ์๋๋ฅผ ์ด์ฉํด ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ฒด์ ๋ด์ ์ ์๋ค.
์ด ๋, HashSet์ ๊ธฐ๋ณธ ์์ฑ์์ ์ํด HashMap ๊ฐ์ฒด๋ฅผ ๋ด๋ถ์ ์์ฑํ๊ฒ ๋๊ณ , add() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ฉด์ ์์ฑ๋ HashMap ๊ฐ์ฒด์ put() ๋ฉ์๋๋ฅผ ํธ์ถํ๋๋ฐ, put() ๋ฉ์๋๋ HashMap ๋ด๋ถ์ ์ ์๋ putVal() ๋ฉ์๋์ hash() ๋ฉ์๋๋ฅผ ํธ์ถํ๋ค.
HashMap ํด๋์ค์ hash() ๋ฉ์๋๋ put() ๋ฉ์๋์์ ๋ฐ์์จ Key ๊ฐ์ฒด์ hashcode() ๋ฉ์๋๋ฅผ ํธ์ถํ์ฌ ๋นํธ์ฐ์ฐ์ ๊ฒฐ๊ณผ๊ฐ์ ๋ฐํํ๋ค.
์ด ๋ ๋ฐํ๋ ๊ฐ์ ๊ธฐ์ค์ผ๋ก putVal() ๋ฉ์๋ ๋ด๋ถ์์ value ๋ฐ์ดํฐ์ ์ค๋ณต์ ํ์ธํ๊ณ ์ค๋ณต๋์ง ์๋๋ค๋ฉด Node๋ฅผ ์์ฑ, ์ค๋ณต๋๋ค๋ฉด null์ ๋ฐํํ๋ค.
์ฌ๊ธฐ์ ๋ฐํ๋ ๊ฐ์ด null์ด๋ผ๋ฉด HashSet ๊ฐ์ฒด์ ๋ด๊ธธ ๋ฐ์ดํฐ๋ ์ค๋ณต์ผ๋ก ์ธํด ๋ด๊ธฐ์ง ๋ชปํ๊ณ , null์ด ์๋๋ผ๋ฉด ๊ฐ์ฒด์ ๋ด๊ธธ ๊ฒ์ด๋ค.
์ฆ, HashMap์ ๋ด๋ถ ๋ฉ์๋์ ์ํด equals(), hashcode()๋ฅผ ํธ์ถํ์ฌ ํด๋น ๊ฐ์ฒด๊ฐ ์กด์ฌํ๋์ง ํ์ธํ๊ธฐ์ ์ค๋ณต์ ์ ๊ฑฐ ํ ์ ์๋ค.
โ๏ธ ํด๋น ๋ถ๋ถ์ ๋ ์์ธํ ์ดํดํ๊ธฐ ์ํด์๋ HashMap๊ณผ HashTable, Hash ์๊ณ ๋ฆฌ์ฆ์ ๋ํด ๊ณต๋ถํด๋ณด์!
TreeSet
TreeSet ํด๋์ค๋ HashSet๊ณผ ๋ฌ๋ฆฌ ์ด์ง ํ์ ํธ๋ฆฌ๋ฅผ ์ด์ฉํด์ ๊ตฌํ๋์ด ์๋ ํด๋์ค์ด๋ค. ๋๋ฌธ์ ๋ฒ์ ํ์๊ณผ ์ ๋ ฌ์ ์ ๋ฆฌํ๋ฐ, ์์ ํด๋์ค ๋ค์ด์ด๊ทธ๋จ์ ์ดํด๋ณด๋ฉด HashSet ํด๋์ค์ ๋ฌ๋ฆฌ SortedSet ์ธํฐํ์ด์ค๋ฅผ ํ์ฅํ NavigableSet ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ ๊ฒ์ ํ์ธ ํ ์ ์๋ค.
TreeSet ํด๋์ค๋ ์ด์ง ํ์ ํธ๋ฆฌ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ธฐ ๋๋ฌธ์ ๋ฒ์ ํ์๊ณผ ์ ๋ ฌ์ ์ ๋ฆฌํ๋ค๊ณ ํ๋๋ฐ ์ ์ ๋ฆฌํ๊ฑธ๊น?
Binary Tree
์ด์ง ํธ๋ฆฌ๋ ์์์ ์ธ Root ๋ ธ๋๋ฅผ ์ ์ธํ ๋ ธ๋์ ์ต๋ 2๊ฐ์ ํ์ ๋ ธ๋๋ฅผ ๊ฐ์ง๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ์๋ฃ ๊ตฌ์กฐ์ด๋ค. ์ผ๋ฐ์ ์ธ ์ด์ง ํธ๋ฆฌ๋ O(n)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋๋ฐ, ์ด๋ ๋ฃจํธ ๋ ธ๋๋ถํฐ ๋ชจ๋ ํ์ ๋ ธ๋๋ฅผ ์ํํด์ผ ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๐ ์ ์ ์ํ (preorder)
๋ฃจํธ ๋ ธ๋ > ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ > ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ ์์ผ๋ก ์ํํ๋ค.
๐ ์ค์ ์ํ (postorder)
์ผ์ชฝ ์์ ๋ ธ๋ > ๋ถ๋ชจ ๋ ธ๋ > ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋ ์์ผ๋ก ์ํํ๋ค.
๐ ํ์ ์ํ (inorder)
์ผ์ชฝ ์ฌ์ง ๋ ธ๋ > ์ค๋ฅธ์ชฝ ์์ ๋ ธ๋ > ๋ถ๋ชจ ๋ ธ๋ ์์ผ๋ก ์ํํ๋ค.
Bianry Search Tree
์ด์ง ํ์ ํธ๋ฆฌ๋ ์ด์ง ํธ๋ฆฌ์ฒ๋ผ ํ๋์ ๋ ธ๋์ ์ต๋ ๋ ๊ฐ์ ๋ ธ๋๊ฐ ์กด์ฌ ํ ์ ์๋ ๊ฒ์ ๋์ผํ์ง๋ง, ์์ ๋ ธ๋๋ฅผ ์ ํ ๋ ๊ท์น์ด ์กด์ฌํ๋ค.
๋ถ๋ชจ ๋ ธ๋์ ๊ฐ ๋ณด๋ค ํฌ๋ฉด ์ผ์ชฝ์, ์๋ค๋ฉด ์ค๋ฅธ์ชฝ์ ์์ ๋ ธ๋๋ฅผ ์์นํ๋๋ก ํ๋ค. ๋๋ฌธ์ ๋ฐ์ดํฐ๋ฅผ ์กฐํํ๋ ๊ฒ์ ์์ด ๋ถ๋ชจ ๋ ธ๋ ๊ฐ๋ณด๋ค ์๊ฑฐ๋ ํฐ ๊ฒฝ์ฐ์ ๊ธฐ์ค์ผ๋ก ํธ๋ฆฌ๋ฅผ ์ํํ๊ธฐ ๋๋ฌธ์ ํ๊ท ์ ์ผ๋ก O(logN)์ ์๊ฐ ๋ณต์ก๋๋ฅผ ๊ฐ์ง๋ฉฐ, ์ค์ ์ํ๋ฅผ ํตํด ๋ ธ๋๋ฅผ ์ฐพ๋๋ค.
๐ ๋ชจ๋ ๋ ธ๋์ ํค ๊ฐ์ ์ ์ผํ๋ค.
๐ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ ํค ๊ฐ๋ค์ ๋ฃจํธ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ์๋ค.
๐ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ ํค ๊ฐ๋ค์ ๋ฃจํธ ๋ ธ๋์ ํค ๊ฐ๋ณด๋ค ํฌ๋ค.
'Programming > Java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
F017 - Blocking, Non-Blocking / Synchronous, Asynchronous (2) | 2021.06.15 |
---|---|
F016 - File, I/O, Stream (0) | 2021.06.14 |
F014 - List (ArrayList, LinkedList, Vector, Stack) (0) | 2021.05.30 |
F013 - Generic (0) | 2021.05.26 |
F012 - Annotation (0) | 2021.05.24 |