๋ชฉ์ฐจ
์ปฌ๋ ์ ํ๋ ์์ํฌ์ ์ธํฐํ์ด์ค๋ฅผ ์ดํดํ๋ค๋ฉด, ์ด์ ์ค์ ๊ตฌํ์ฒด๋ค์ ์ฐจ์ด๋ฅผ ์ดํด๋ณผ ์ฐจ๋ก์ ๋๋ค.
๊ฐ์ ์ธํฐํ์ด์ค๋ฅผ ๊ตฌํํ๋๋ผ๋ ๋ด๋ถ ๊ตฌ์กฐ์ ์ฑ๋ฅ ํน์ฑ์ด ์์ ํ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ์ํฉ์ ๋ง๋ ์ ํ์ด ์ ๋ง ์ค์ํ์ฃ .
์ด๋ฒ ๊ธ์์๋ List์ ๋ํ ๊ตฌํ์ฒด์ธ ArrayList์ LinkedList, Set์ ๋ํ ๊ตฌํ์ฒด์ธ HashSet๊ณผ TreeSet์ ํน์ง๊ณผ ์ฑ๋ฅ์ ์์ ์ฝ๋์ ํจ๊ป ๋น๊ตํด ๋ณด๊ฒ ์ต๋๋ค.
๐ฆ ArrayList vs LinkedList
ArrayList
ArrayList๋ ๋์ ๋ฐฐ์ด(Dynamic Array) ๊ตฌ์กฐ๋ก, ๋ด๋ถ์ ์ผ๋ก Object ๋ฐฐ์ด์ ์ฌ์ฉํด ์์๋ฅผ ์ ์ฅํฉ๋๋ค.
List<String> arrayList = new ArrayList<>();
arrayList.add("Apple"); // ์ธ๋ฑ์ค 0
arrayList.add("Banana"); // ์ธ๋ฑ์ค 1
arrayList.add("Cherry"); // ์ธ๋ฑ์ค 2
// ์ธ๋ฑ์ค๋ก ๋น ๋ฅธ ์ ๊ทผ
String fruit = arrayList.get(1); // "Banana" - O(1)
ArrayList ๋ด๋ถ ๊ตฌ์กฐ
[Apple] [Banana] [Cherry] [null] [null] [null] ...
0 1 2 3 4 5
โ ArrayList ํน์ง
- ๋น ๋ฅธ ์ธ๋ฑ์ค ์ ๊ทผ (O(1))
- ๋์ ์ถ๊ฐ๋ ๋น ๋ฆ (O(1)), ์ค๊ฐ ์ฝ์ /์ญ์ ๋ ๋๋ฆผ (O(n))
- ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ (๋ฐฐ์ด ๊ธฐ๋ฐ)
LinkedList
LinkedList๋ ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Doubly Linked List) ๊ตฌ์กฐ๋ก, ๊ฐ ๋ ธ๋๊ฐ ์ด์ /๋ค์ ๋ ธ๋๋ฅผ ์ฐธ์กฐํฉ๋๋ค.
List<String> linkedList = new LinkedList<>();
linkedList.add("Apple");
linkedList.add("Banana");
linkedList.add("Cherry");
// ์ฒ์์ด๋ ๋์ ์ถ๊ฐํ๊ธฐ ์ฌ์
linkedList.addFirst("Apricot"); // ๋งจ ์์ ์ถ๊ฐ
linkedList.addLast("Date"); // ๋งจ ๋ค์ ์ถ๊ฐ
LinkedList ๋ด๋ถ ๊ตฌ์กฐ
[Apricot] ↔ [Apple] ↔ [Banana] ↔ [Cherry] ↔ [Date]
โ LinkedList ํน์ง
- ์ ๋ ์ฝ์ /์ญ์ ๋น ๋ฆ (O(1))
- ์ค๊ฐ ์ฝ์ /์ญ์ ๋๋ฆผ (O(n))
- ์ธ๋ฑ์ค ์ ๊ทผ ๋๋ฆผ (O(n))
- ๋ ธ๋ ํฌ์ธํฐ๋ก ์ธํ ๋ฉ๋ชจ๋ฆฌ ์ค๋ฒํค๋ ๋ฐ์
์ธ์ ์ฌ์ฉํ ๊น?
๐ธ ArrayList
- ์ธ๋ฑ์ค ์ ๊ทผ์ด ๋น๋ฒํ ๋
- ๋ฐ์ดํฐ ์ถ๊ฐ/์กฐํ๊ฐ ๋ง๊ณ ์ค๊ฐ ์ฝ์ /์ญ์ ๊ฐ ์ ์ ๋
- ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์ ์ต์ํํด์ผ ํ ๋
๐ธ LinkedList
- ์ ๋ ์ฝ์ /์ญ์ ๊ฐ ์ฆ์ ๋
- Queue, Stack ์๋ฃ๊ตฌ์กฐ๋ก ํ์ฉํ ๋
- ๋ฐ์ดํฐ ํฌ๊ธฐ๊ฐ ์์ฃผ ๋ณํ ๋
๐ HashSet vs TreeSet
HashSet
HashSet์ ํด์ ํ ์ด๋ธ(Hash Table) ๊ธฐ๋ฐ์ผ๋ก ์์๋ฅผ ์ ์ฅํฉ๋๋ค.
Set<String> hashSet = new HashSet<>();
hashSet.add("Banana");
hashSet.add("Apple");
hashSet.add("Cherry");
System.out.println(hashSet); // ์์ ๋ณด์ฅ ์๋จ (ํด์๊ฐ์ ๋ฐ๋ผ ๊ฒฐ์ )
// ์ถ๋ ฅ ์: [Cherry, Apple, Banana]
โ HashSet์ ํน์ง
- ์์ ๋ณด์ฅ ์๋จ: ํด์๊ฐ์ ๋ฐ๋ผ ์ ์ฅ ์์น ๊ฒฐ์
- ๋น ๋ฅธ ์ฑ๋ฅ: ํ๊ท O(1) ์๊ฐ๋ณต์ก๋
- null ํ์ฉ: null ๊ฐ์ ํ๋ ์ ์ฅํ ์ ์์
TreeSet
TreeSet์ Red-Black Tree(์ด์ง ๊ฒ์ ํธ๋ฆฌ์ ํ ์ข ๋ฅ) ๊ตฌ์กฐ๋ก ์์๋ฅผ ์๋ ์ ๋ ฌํฉ๋๋ค.
Set<String> treeSet = new TreeSet<>();
treeSet.add("Banana");
treeSet.add("Apple");
treeSet.add("Cherry");
System.out.println(treeSet); // ์๋ ์ ๋ ฌ๋จ
// ์ถ๋ ฅ: [Apple, Banana, Cherry]
โ TreeSet์ ํน์ง
- ์๋ ์ ๋ ฌ: ์์๋ค์ด ์๋์ผ๋ก ์ ๋ ฌ๋ ์ํ ์ ์ง
- NavigableSet ๊ตฌํ: ๋ฒ์ ๊ฒ์, ๊ทผ์ ๊ฐ ์ฐพ๊ธฐ ๋ฑ ๊ฐ๋ฅ
- null ๋ถ๊ฐ: null ๊ฐ์ ์ ์ฅํ ์ ์์
์ธ์ ์ฌ์ฉํ ๊น?
๐ธ HashSet
- ์์๋ณด๋ค ๋น ๋ฅธ ๊ฒ์์ด ์ค์ํ ๋
- ์ค๋ณต ์๋ ๋ฐ์ดํฐ ๊ด๋ฆฌ
๐ธ TreeSet
- ์ ๋ ฌ์ด ํ์ํ ๋
- ๋ฒ์ ๊ฒ์(๋ถ๋ถ์งํฉ) ๊ธฐ๋ฅ์ด ํ์ํ ๋
โฑ๏ธ ์ฑ๋ฅ๊ณผ ์๊ฐ๋ณต์ก๋
์ฐ์ฐ | ArrayList | LinkedList | HashSet | TreeSet |
์ถ๊ฐ(๋) | O(1) | O(1) | O(1) ํ๊ท | O(log n) |
์ฝ์ /์ญ์ (์ค๊ฐ) | O(n) | O(n) | O(1) ํ๊ท | O(log n) |
๊ฒ์(contains) | O(n) | O(n) | O(1) ํ๊ท | O(log n) |
์ํ | O(n) | O(n) | O(n) | O(n) |
์ ๋ ฌ๋ ์ํ | O(n log n) | O(n log n) | O(n log n) | O(n) |
๐ก Tip
- ๋ฐ์ดํฐ ์์ด ๋ง๊ณ ์์ ์ ์ง๊ฐ ํ์ํ๋ค๋ฉด ArrayList๋ฅผ ๊ณ ๋ คํ์ธ์.
- ์ฝ์ /์ญ์ ๊ฐ ๋น๋ฒํ๋ค๋ฉด LinkedList๊ฐ ์ ๋ฆฌํฉ๋๋ค.
- ์ค๋ณต ์ ๊ฑฐ์ ๋น ๋ฅธ ๊ฒ์์ด ํ์ํ๋ฉด HashSet์ด ์ ํฉํฉ๋๋ค.
- ๋ฐ์ดํฐ ์ ๋ ฌ์ด ํ์ํ๋ฉด TreeSet์ด ์ข์ต๋๋ค.
๐ ๋ง๋ฌด๋ฆฌ
์ด๋ฒ ๊ธ์์๋ Java ์ปฌ๋ ์ ํ๋ ์์ํฌ์์ ์์ฃผ ์ฌ์ฉํ๋ ArrayList, LinkedList, HashSet, TreeSet์ ๊ตฌ์กฐ์ ์ฑ๋ฅ ์ฐจ์ด๋ฅผ ๋น๊ตํด ๋ดค์ต๋๋ค.
์ปฌ๋ ์ ์ ์ ํํ ๋๋ ๋ฐ์ดํฐ์ ์ฌ์ฉ ํจํด(์กฐํ, ์ฝ์ /์ญ์ , ๊ฒ์, ์ ๋ ฌ ์ฌ๋ถ)์ ๊ณ ๋ คํด ์ ์ ํ ๊ตฌํ์ฒด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ ArrayList์ HashSet์ผ๋ก ์์ํด ๋ณด๊ณ , ํน๋ณํ ์๊ตฌ์ฌํญ์ด ์์ ๋ ๋ค๋ฅธ ๊ตฌํ์ฒด๋ก ํ์ฅํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ค์ ๊ธ์์๋ Java์ Map ๊ณ์ด(HashMap, TreeMap, LinkedHashMap)์ ๋น๊ต์ ์ฌ์ฉ๋ฒ์ ๋ค๋ค๋ณด๊ฒ ์ต๋๋ค.
๊ถ๊ธํ ์ ์ด๋ ๋ ์๊ณ ์ถ์ ๋ถ๋ถ์ด ์์ผ๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์ธ์ ๐