Linked List - Data-Structure-Study/java-datastructure GitHub Wiki
List
Dion๐ฑ
๋ฐฐ์ด์ ๋จ์
- ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๊ณ ์ ๋์ด ์๋ค.
- ๊ทธ๋ ๋ค๊ณ ์์ฒญ ํฐ ๋ฐฐ์ด์ ์ ์ธํ ์๋ ์๋ค.
- ๋ง์ฝ, ๊ทธ ํฌ๊ธฐ๋ณด๋ค ๋ ํฐ ๊ณต๊ฐ์ ์๊ตฌํ๋ค๋ฉด?
- ๋ฉ๋ชจ๋ฆฌ์ ๋ญ๋น๊ฐ ๋ ์๋ ์๋ค.
๋ฐฐ์ด์ ๋จ์ ์ ๋ณด์ํ ์๋ ์์๊น?
- ๋ฐ์ดํฐ ์งํฉ์ ๋ณด๊ดํ๋ ๊ธฐ๋ฅ์ ๊ฐ์ง๋ฉด์, ์ ์ฐํ๊ฒ ํฌ๊ธฐ๋ฅผ ๋ฐ๊ฟ ์ ์๋ ์๋ฃ๊ตฌ์กฐ
๋ฐฐ์ด์ ๋จ์ ์ ๋ณด์ํ ์๋ฃ๊ตฌ์กฐ์ ์ด๋ฆ์ List๋ผ๊ณ ํ์!!
Linked List
๋ฆฌ์คํธ๋ฅผ ๊ตฌํํ๋ ์ฌ๋ฌ ๊ฐ์ง ๊ธฐ๋ฒ ์ค์์๋ ๊ฐ์ฅ ๊ฐ๋จํ ๋ฐฉ๋ฒ
๋งํฌ๋ ๋ฆฌ์คํธ๋ ์ด๋ป๊ฒ ์๊ฒผ์๊น?
- ๋ฆฌ์คํธ ๋ด์ ๊ฐ ์์๋ ๋ ธ๋(Node)๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- ๋งํฌ๋ ๋ฆฌ์คํธ์ ์ด๋ฆ์ '๋ ธ๋๋ฅผ ์ฐ๊ฒฐ(Link)ํด์ ๋ง๋๋ ๋ฆฌ์คํธ'๋ผ์ ๋ถ์ฌ์ง ์ด๋ฆ
- ๋งํฌ๋ ๋ฆฌ์คํธ์ ๋ ธ๋๋ ๋ฐ์ดํฐ๋ฅผ ๋ณด๊ดํ๋ ํ๋์, ๋ค์ ๋ ธ๋์์ ์ฐ๊ฒฐ๊ณ ๋ฆฌ ์ญํ ์ ํ๋ ํฌ์ธํฐ๋ก ์ด๋ฃจ์ด์ง๋ค.
- ๋ฆฌ์คํธ์ ๋งจ ์ฒ์ ๋ ธ๋๋ฅผ Head ๋ ธ๋๋ผ๊ณ ํ๊ณ , ๋งจ ๋ง์ง๋ง ๋ ธ๋๋ฅผ Tail ๋ ธ๋๋ผ๊ณ ํ๋ค.
๋งํฌ๋ ๋ฆฌ์คํธ์ ์ฅ์
- ๋ฐ์ดํฐ๊ฐ ๋์ด๋ ๋ ๋ง๋ค ๋ ธ๋๋ฅผ ๋ง๋ค์ด์ Tail์ ๋ถ์ด๋ฉด ๋๋ค.
- ์ค๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ผ์๋ฃ๊ฑฐ๋, ์ค๊ฐ์ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ์๋ ๋จ์ํ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๋ง ๋ฐ๊พธ์ด์ฃผ๋ฉด ๋๊ธฐ ๋๋ฌธ์ ์ฝ์ , ์ญ์ ๊ฐ ๋ฐฐ์ด์ ๋นํด ์ฝ๋ค.
๋๋ต์ ์ธ Node์ ๊ตฌ์กฐ
public class Node {
private int data;
private Node nextNode;
}
๋งํฌ๋ ๋ฆฌ์คํธ์ ์ฃผ์ ์ฐ์ฐ
- ๋ ธ๋ ์์ฑ/์๋ฉธ(GC๊ฐ ์์์ ํด์ค)
- ๋ ธ๋ ์ถ๊ฐ
- ๋ ธ๋ ํ์
- ๋ ธ๋ ์ญ์
- ๋ ธ๋ ์ฝ์
๋ ธ๋์ ์์ฑ/์๋ฉธ, ์ถ๊ฐ, ์ญ์ , ์ฝ์ ์ ๋งํฌ๋ ๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ถํ๊ธฐ ์ํ ์ฐ์ฐ
๋ฆฌ์คํธ ํ์์ ๊ตฌ์ถ๋์ด ์๋ ๋งํฌ๋ ๋ฆฌ์คํธ์ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ๊ธฐ ์ํ ์ฐ์ฐ
ํ์์ฐ์ฐ์ ๋ฆฌ์คํธ๊ฐ ๊ฐ๊ณ ์๋ ์ฝ์ ์ค์ ํ๋์!
๋งํฌ๋ ๋ฆฌ์คํธ์ ๋จ์
- ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ ค๋ ํฌ์ธํฐ ๋๋ฌธ์ ๊ฐ ๋ ธ๋๋ง๋ค ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ถ๊ฐ๋ก ํ์ํ๊ฒ ๋จ.
- ํน์ ์์น์ ์๋ ๋
ธ๋๋ฅผ ์ป๋๋ฐ ๋๋ ๋น์ฉ์ด ํฌ๋ฉฐ, ์๋๋ ๋๋ฆผ.
- ๋ฐฐ์ด์ ์์์๊ฐ
- ๋งํฌ๋ ๋ฆฌ์คํธ๋ ์ต์ ์ ๊ฒฝ์ฐ O(n)์.
๋งํฌ๋ ๋ฆฌ์คํธ์ ์ฅ์
- ์๋ก์ด ๋ ธ๋์ ์ถ๊ฐ/์ฝ์ /์ญ์ ๊ฐ ์ฝ๊ณ ๋น ๋ฆ.
- ํ์ฌ ๋ ธ๋์ ๋ค์ ๋ ธ๋๋ฅผ ์ป์ด์ค๋ ์ฐ์ฐ์ ๋ํด์ ๋น์ฉ์ด ๋ฐ์ํ์ง ์์.
๋งํฌ๋ ๋ฆฌ์คํธ์ ์ฌ์ฉ์ฒ
๋ ์ฝ๋์ ์ถ๊ฐ/์ฝ์ /์ญ์ ๊ฐ ์ฆ๊ณ , ์กฐํ๋ ๋๋ฌธ ๊ณณ
๋๋ธ ๋งํฌ๋ ๋ฆฌ์คํธ(Doubly Linked List)
๋งํฌ๋ ๋ฆฌ์คํธ์ ํ์ ๊ธฐ๋ฅ์ ๊ฐ์ ํ ์๋ฃ๊ตฌ์กฐ
Sinlgy Linked List์๋ ๋ค๋ฅด๊ฒ ์๋ฐฉํฅ์ผ๋ก ํ์์ด ๊ฐ๋ฅํ๋ค.
Hamill๐
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Linked List)
-
Basic concepts and nomenclature (๊ธฐ๋ณธ ๊ฐ๋ ๊ณผ ๋ช ๋ช ๋ฒ)
- Each record of a linked list is often called an 'element' or 'node' ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๊ฐ ๋ ์ฝ๋๋ฅผ ํํ '์์(์๋ฆฌ๋จผํธ)' ๋๋ '๋ ธ๋'๋ผ ๋ถ๋ฅธ๋ค
- The field of each node that contains the address of the next node is usually called the 'next link' or 'next pointer'. ๋ค์ ๋ ธ๋์ ์ฃผ์๋ฅผ ํฌํจํ๋ ๊ฐ ๋ ธ๋์ ํ๋๋ฅผ ๋ณดํต '๋ค์ ๋งํฌ(๋ฅ์คํธ ๋งํฌ)' ๋๋ '๋ค์ ํฌ์ธํฐ(๋ฅ์คํธ ํฌ์ธํฐ)'๋ผ๊ณ ๋ถ๋ฅธ๋ค.
- The remaining fields are known as the 'data', 'information', 'value', 'cargo', or 'payload' fields. ๋๋จธ์ง ํ๋๋ 'data', 'infomation', 'value', 'cargo(๋ฐฐ์ ํ๋ฌผ)' ๋๋ 'payload(์ ๋ฃ ํ์ค ๋๋ ์ ์ก๋๋ ๋ฐ์ดํฐ)' ํ๋๋ก ์๋ ค์ ธ ์๋ค
- The 'head' of a list is its first node. The 'tail' of a list may refer either to the rest of the list after the head, or to the last node in the list. ๋ฆฌ์คํธ์ ์ฒซ ๋ฒ์งธ ๋ ธ๋๋ 'head(ํค๋)'๋ค. ๋ฆฌ์คํธ์ 'tail(๊ผฌ๋ฆฌ)'๋ ํค๋ ๋ค์ ์๋ ๋ฆฌ์คํธ์ ๋๋จธ์ง ๋ถ๋ถ ๋๋ ๋ชฉ๋ก์ ๋ง์ง๋ง ๋ ธ๋๋ฅผ ๋ํ๋ผ ์ ์๋ค.
-
์ข ๋ฅ
-
Singly linked list
- Singly linked lists contain nodes which have a data field as well as 'next' field, which points to the next node in line of nodes. ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ฐ์ดํฐ ํ๋๋ฟ๋ง ์๋๋ผ (๋ ธ๋ ๋ผ์ธ์) ๋ค์ ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ 'next' ํ๋๊ฐ ์๋ ๋ ธ๋๊ฐ ํฌํจ๋์ด ์๋ค.
- Operations that can be performed on singly linked lists include insertion, deletion and traversal. ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ์ํํ ์ ์๋ ์์ ์๋ ์ฝ์ , ์ญ์ ๋ฐ ํก๋จ์ด ํฌํจ๋ฉ๋๋ค.
A singly linked list whose nodes contain two fields: an integer value and a link to the next node ์ ์ ๊ฐ๊ณผ ๋ค์ ๋ ธ๋์ ๋ํ ๋งํฌ 2๊ฐ์ ํ๋๋ฅผ ํฌํจํ๋ ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ
-
Doubly linked list
- In a 'doubly linked list', each node contains, besides the next-node link, a second link field pointing to the 'previous' node in the sequence. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๊ฐ ๋ ธ๋๋ ๋ค์ ๋ ธ๋ ๋งํฌ ์ธ์ ์์์์ '์ด์ ' ๋ ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ 2 ๋ฒ์งธ ๋งํฌ ํ๋๋ฅผ ํฌํจํ๋ค.
- The two links may be called 'forward('s') and 'backwards', or 'next' and 'prev'('previous') ์ด ๋ ๋งํฌ๋ 'forward(์ ๋ฐฉ)'๊ณผ 'backwards(ํ๋ฐฉ)' ๋๋ 'next(๋ค์)'๊ณผ 'prev(previous ์ด์ )'์ผ๋ก ๋ถ๋ฆด ์ ์๋ค
A doubly linked list whose nodes contain three fields: an integer value, the link forward to the next node, and the link backward to the previous node ์ ์ ๊ฐ, ๋ค์ ๋ ธ๋๋ก ํฅํ๋ ๋งํฌ, ์ด์ ๋ ธ๋๋ก ๊ฐ๋ ๋งํฌ 3 ๊ฐ์ ํ๋๊ฐ ํฌํจ๋ ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ
- Many modern operating systems use doubly linked lists to maintain references to active processes, threads, and other dynamic objects. ๋ง์ ํ๋ ์ด์ ์ฒด์ ๋ active processes, ์ค๋ ๋ ๋ฐ ๊ธฐํ ๋์ ๊ฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋ฅผ ์ ์งํ๊ธฐ ์ํด ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํฉ๋๋ค.
-
Multiply linked list
-
Circular linked list
-
Sentinel nodes
-
Empty lists
-
Hash linking
-
List handles
-
Combining alternatives
-
-
Tradeoffs
- As with most choices in computer programming and design, no method is well suited to all circumstances. ์ปดํจํฐ ํ๋ก๊ทธ๋๋ฐ๊ณผ ๋์์ธ์์ ๋๋ถ๋ถ์ ์ ํ์ด ๊ทธ๋ ๋ฏ์ด ์ด๋ค ๋ฐฉ๋ฒ๋ ๋ชจ๋ ์ํฉ์ ์ ๋ง์ง ์๋๋ค.
- A linked list data structure might work well in one case, but cause problems in another. ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ ํ ๊ฒฝ์ฐ์๋ ์ ์๋ํ์ง๋ง ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ ๋ฌธ์ ๋ฅผ ์ผ์ผํฌ ์ ์๋ค
- This is a list of some of the common tradeoffs involving linked list structures. ์ด๊ฒ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ๊ตฌ์กฐ์ ๊ด๋ จ๋ ์ผ๋ฐ์ ์ธ ํธ๋ ์ดํธ ์คํ์ ๋ชฉ๋ก์ ๋๋ค.
- Linked lists vs. dynamic arrays
- Singly linked linear lists vs. other lists
- Doubly linked vs. singly linked
- Double-linked lists require more space per node (unless one uses XOR-linking), and their elementary operations are more expensive; but they are often easier to manipulate because they allow fast and easy sequential access to the list in both directions ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ ๋ ธ๋ ๋น ๋ ๋ง์ ๊ณต๊ฐ์ ํ์๋ก ํ๋ฉฐ (XOR ๋งํฌ๋ฅผ ์ฌ์ฉํ์ง ์๋ ํ), ๊ธฐ๋ณธ ์์ ์ ๋ ๋น์ธ์ง๋ง, ์๋ฐฉํฅ์ผ๋ก ๋ฆฌ์คํธ์ ๋น ๋ฅด๊ณ ์ฝ๊ฒ ์์ฐจ์ ์ผ๋ก ์ ๊ทผํ ์ ์๊ธฐ ๋๋ฌธ์ ์กฐ์ํ๊ธฐ๊ฐ ๋ ์ฌ์ด ๊ฒฝ์ฐ๊ฐ ๋ง๋ค.
- In a doubly linked list, one can insert or delete a node in a constant number of operations given only that node's address. ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์๋ ํด๋น ๋ ธ๋์ ์ฃผ์๋ง ์ฃผ์ด์ง ์ผ์ ํ ์์ ์์ ๋ ธ๋๋ฅผ ์ฝ์ ํ๊ฑฐ๋ ์ญ์ ํ ์ ์๋ค.
- To do the same in a singly linked list, one must have the address of the pointer to that node, which is either the handle for the whole list (in case of the first node) or the link field in the previous node. ๋จ์ผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๋์ผํ ์์ ์ ์ํํ๋ ค๋ฉด ํด๋น ๋ ธ๋์ ๋ํ ํฌ์ธํฐ์ ์ฃผ์๋ฅผ ๊ฐ์ง๊ณ ์์ด์ผ ํ๋ฉฐ, ์ด ์ฃผ์๋ ์ ์ฒด ๋ฆฌ์คํธ์ ํธ๋ค(์ฒซ ๋ฒ์งธ ๋ ธ๋์ ๊ฒฝ์ฐ) ๋๋ ์ด์ ๋ ธ๋์ ๋งํฌ ํ๋ ์ค ํ๋์ฌ์ผ ํ๋ค.
- Some algorithms require access in both directions. On the other hand, doubly linked lists do not allow tail-sharing and cannot be used as persistent data structure. ์ผ๋ถ ์๊ณ ๋ฆฌ์ฆ์ ์๋ฐฉํฅ์ผ๋ก ์ ๊ทผํด์ผ ํ๋ค. ๋ฐ๋ฉด์ ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ tail-sharing์ ํ์ฉํ์ง ์์ผ๋ฉฐ ์๊ตฌ์ ์ธ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ก ์ฌ์ฉํ ์ ์๋ค.
- Circularly linked vs. linearly linked
- Using sentinel nodes
-
์ฌ์ฉํ๋ ์ด์
- Array(๋ฐฐ์ด)์ ๋นํด ๋ฐ์ดํฐ์ ์ถ๊ฐ/์ฝ์ ๋ฐ ์ญ์ ๊ฐ ์ฉ์ดํ๋ ์์ฐจ์ ์ผ๋ก ํ์ํ์ง ์์ผ๋ฉด ํน์ ์์น์ ์์์ ์ ๊ทผํ ์ ์์ด ์ผ๋ฐ์ ์ผ๋ก ํ์ ์๋๊ฐ ๋จ์ด์ง๋ค.
- ์ฆ ํ์ ๋๋ ์ ๋ ฌ์ ์์ฃผํ๋ฉด ๋ฐฐ์ด์, ์ถ๊ฐ/์ญ์ ๊ฐ ๋ง์ผ๋ฉด ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ ๋ฆฌํ๋ค.
-
์ด๋์ ์ฌ์ฉํ๋์ง
-
์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ : ์์ธํธ์ค ๋ฌธ์
1๋ฒ๋ถํฐ N๋ฒ๊น์ง N ๋ช ์ ์ฌ๋์ด ์์ ์ด๋ฃจ๋ฉด์ ์์์๊ณ , ์์ ์ ์ K(โค N)๊ฐ ์ฃผ์ด์ง๋ค. ์ด์ ์์๋๋ก K ๋ฒ์งธ ์ฌ๋์ ์ ๊ฑฐํ๋ค. ํ ์ฌ๋์ด ์ ๊ฑฐ๋๋ฉด ๋จ์ ์ฌ๋๋ค๋ก ์ด๋ฃจ์ด์ง ์์ ๋ฐ๋ผ ์ด ๊ณผ์ ์ ๊ณ์ํด ๋๊ฐ๋ค. ์ด ๊ณผ์ ์ N ๋ช ์ ์ฌ๋์ด ๋ชจ๋ ์ ๊ฑฐ๋ ๋๊น์ง ๊ณ์๋๋ค. ์์์ ์ฌ๋๋ค์ด ์ ๊ฑฐ๋๋ ์์๋ฅผ (N,K) - ์์ธํธ์ค ์์ด์ด๋ผ๊ณ ํ๋ค. ์๋ฅผ ๋ค์ด (7,3) - ์์ธํธ์ค ์์ด์ <3,6,2,7,5,1,4>์ด๋ค. N๊ณผ K๊ฐ ์ฃผ์ด์ง๋ฉด (N,K)-์์ธํธ์ค ์์ด์ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค
-
-
์๊ฐ๋ณต์ก๋์ ๊ณต๊ฐ๋ณต์ก๋
- Singly-Linked List, Doubly-Linked List
- ์๊ฐ ๋ณต์ก๋
- Acess : O(n)
- Search : O(n)
- Insertion : O(1)
- Deletion : O(1)
- ๊ณต๊ฐ ๋ณต์ก๋
- O(n)
- ์๊ฐ ๋ณต์ก๋
- Singly-Linked List, Doubly-Linked List
-
lynn๐ฆ
๋ฆฌ์คํธ
๋ฆฌ์คํธ๋ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์๋ฏธํ ๊น?
- ๋ฆฌ์คํธ โ ์ฐ๊ฒฐ ๋ฆฌ์คํธ
- ๋ฆฌ์คํธ์ ์ข
๋ฅ
- ์์ฐจ ๋ฆฌ์คํธ : ๋ฐฐ์ด์ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋ ๋ฆฌ์คํธ
- ์ฐ๊ฒฐ ๋ฆฌ์คํธ : ๋ฉ๋ชจ๋ฆฌ์ ๋์ ํ ๋น์ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ๋ ๋ฆฌ์คํธ
๋ฆฌ์คํธ ์๋ฃ๊ตฌ์กฐ๋ ๋ฐ์ดํฐ๋ฅผ ๋๋ํ ์ ์ฅํ๋ค. ๊ทธ๋ฆฌ๊ณ ์ค๋ณต๋ ๋ฐ์ดํฐ์ ์ ์ฅ์ ๋ง์ง ์๋๋ค.
๋ฐฐ์ด์ ์ฅ์ ๊ณผ ๋จ์
- ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ฆฌ์คํธ์ ๋จ์
- ๋ฐฐ์ด์ ๊ธธ์ด๊ฐ ์ด๊ธฐ์ ๊ฒฐ์ ๋์ด์ผ ํ๋ค. ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํ๋ค.
- ์ญ์ ์ ๊ณผ์ ์์ ๋ฐ์ดํฐ์ ์ด๋(๋ณต์ฌ)๊ฐ ๋งค์ฐ ๋น๋ฒํ ์ผ์ด๋๋ค.
- ๋ฐฐ์ด ๊ธฐ๋ฐ ๋ฆฌ์คํธ์ ์ฅ์
- ๋ฐ์ดํฐ์ ์ฐธ์กฐ๊ฐ ์ฝ๋ค. ์ธ๋ฑ์ค ๊ฐ์ ๊ธฐ์ค์ผ๋ก ์ด๋๋ ํ ๋ฒ์ ์ฐธ์กฐ๊ฐ ๊ฐ๋ฅํ๋ค.
์ฐ๊ฒฐ ๋ฆฌ์คํธ
-
๋ฐฐ์ด์ ๋จ์
- ํฌ๊ธฐ๊ฐ ์ ํด์ ธ ์๋ค. (์ฒ์์ ํฌ๊ธฐ๋ฅผ ์ด๊ธฐํํด์ผํจ) - ๋ํผ์
- ์ด๊ธฐํ ๋ ํฌ๊ธฐ๋งํผ ์ฐ์ง ์์ผ๋ฉด ๋จ๋ ๊ณต๊ฐ์ด ์๊ธด๋ค - ๋ํผ์
- ์ฒ์์ ์ค์ ๋ ํฌ๊ธฐ ์ด์์ ๊ฐ์ ๋ฃ์ ์ ์๋ค
๋ฉ๋ชจ๋ฆฌ์ ํน์ฑ์ด ์ ์ ์ด์ด์(๊ธธ์ด์ ๋ณ๊ฒฝ์ด ๋ถ๊ฐ๋ฅํด์) ๋ฉ๋ชจ๋ฆฌ์ ๊ธธ์ด๋ฅผ ๋ณ๊ฒฝํ๋ ๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค.
์ด๋ฐ ๋ฐฐ์ด์ ๋จ์ ์ ๋ณด์ํ๊ธฐ ์ํด ๋ฑ์ฅํ ๊ฒ์ด '๋์ ์ธ ๋ฉ๋ชจ๋ฆฌ์ ๊ตฌ์ฑ'์ด๋ค.
-
์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๊ธฐ๋ณธ ์๋ฆฌ
ํ์ํ ๋๋ง๋ค ๋ฐ๊ตฌ๋์ ์ญํ ์ ํ๋ ๊ตฌ์กฐ์ฒด ๋ณ์๋ฅผ ํ๋์ฉ ๋์ ํ ๋นํด์ ์ด๋ค์ ์ฐ๊ฒฐํ๋ค.
โ ํ์ํ ๋๋ง๋ค ๋ฐ๊ตฌ๋๋ฅผ ํ๋์ฉ ๋ง๋ จํด์ ๊ทธ๊ณณ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์ด๋ค์ ๋ฐฐ์ด์ฒ๋ผ ์๋ก ์ฐ๊ฒฐํ๋ค.
๊ทธ๋์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ํํ๋ ์๋์ ๊ฐ๋ค๊ณ ํ ์ ์๋ค.
- Node ๋ฐ์ดํฐ๋ฅผ ๋ด๋ ๋ฐ๊ตฌ๋๋ณด๋ค๋ ์ฐ๊ฒฐ์ด ๊ฐ๋ฅํ ๊ฐ์ฒด๋ผ๋ ์ฌ์ค์ ์ค์ ์ ๋์ด ์ง์ ์ด๋ฆ '๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ์ฅ์'์ '๋ค๋ฅธ ๋ณ์๋ฅผ ๊ฐ๋ฆฌํค๊ธฐ ์ํ ์ฅ์' ๊ตฌ๋ถ๋์ด ์์
๋๋์
Hamill
์ผํฌ์์ด๋น์ ์ํ๋๋ ์กฐ๊ธ ๋นจ๋ฆฌํ ์ ์์ด์ ์ข์๋ค.
๊ตฌํํ๋ฉด์ ๊ณ์ ์๊ฐ๋ณต์ก๋์ ๊ณต๊ฐ๋ณต์ก๋๋ฅผ ์๊ฐํ๋๊น ์ฝ๊ฒ ์ํ์ง์ง ์์ ๊ฒ ๊ฐ๋ค.
Lynn
์ผํฌ์์ด๋น์ ์ด์ฌํํ๋๋, ๊ตฌํ์ ํ์ง ๋ชปํ๊ณ , ๊ฐ๋
๋ ์ด์ค๊ฐํ๊ฒ ์ตํ ๊ฒ ๊ฐ๋ค.
๊ทธ๋๋ ์ค๋ ๋๋ปํ๋๋ฐ, ์คํฐ๋๋ฅผ ํด์ ์ต์ง๋ก ๊ณต๋ถ๋ฅผ ํ๋ค.
Dion
์ด์ ๊ณผ์์ ํ๋๋... ๋ฐฐ๊ฐ ์ํ ์ด์. ๊ฐ์ดํด์ ์ข ๋ ๊ณต๋ถ์ ์ง์คํ ์ ์์๊ณ , ์๋ก ๊ณต๋ถํ ๋ด์ฉ์ ๋๋๋ ๊ณผ์ ์ ํตํด์ ๊ทธ๋ฅ ๋์ด๊ฐ๋ ๋ถ๋ถ์ ๋ค์ ์๊ฐํ ์ ์์์ด์.