๐ง๐ป๐ป ๊ธ์ ์์ํ๊ธฐ์ ์์..
- ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ์์ ์์ฃผ ๋์ค๋ ์ง๋ฌธ์ ๋ชจ์ ํ ๋ฒ์ ์ ๋ฆฌํ ํฌ์คํธ์ ๋๋ค.
- ์ ์ ๊ฐ๋ฐ์ ๊ธฐ์ ๋ฉด์ ์ ์ค๋นํ๋ ์ฌ๋์ผ๋ก, ์ ํํ์ง ์์ ์ ๋ณด๊ฐ ํฌํจ๋ ์ ์์ต๋๋ค. ๋ ์ฌ๋ฐ๋ฅธ ๋ต์ ์๊ณ ์๋ค๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์๋ฉด ๋ฐ์ํ๋๋ก ํ๊ฒ ์ต๋๋ค.
- ํ์๋Java
๊ธฐ๋ฐ์ ๋ฐฑ์๋ ์์ง๋์ด๋ฅผ ๋ชฉํ๋ก ํ๊ณ ์์ต๋๋ค. ๋ฐ๋ผ์ ๊ธ ๋ด๋ถ์Java
ํน์๋ฐฑ์๋
๊ด๋ จ ์ฉ์ด๊ฐ ๋์ฌ ์ ์์ต๋๋ค. Java๋ฅผ ์ฌ์ฉํ์ง ์๋๋ค๋ฉด, ์์ ์ ์ง๋ฌด ์ธ์ด ๋ฐ ํ๋ ์์ํฌ ๊ด์ ์์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ณด๋ ๊ฒ์ ์ถ์ฒํฉ๋๋ค.
๐ง๐ป๐ป ์๋ฃ๊ตฌ์กฐ ๋ฉด์ ์ง๋ฌธ
๐ก Array
์ LinkedList
๊ฐ ๊ฐ๊ฐ ๋ฌด์์ธ์ง, ์ด๋ป๊ฒ ๋ค๋ฅธ์ง ์ค๋ช
ํด์ฃผ์ธ์.
Array
๋ ์์๊ฐ ์๋ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ธฐ ์ํ ์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ฉฐ, ๊ณ ์ ๊ธธ์ด์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ์
๋๋ค. ์์๊ฐ ์๊ธฐ ๋๋ฌธ์ ๊ฐ ๋ฐ์ดํฐ์ ์์๋ฅผ ์๋ฏธํ๋ Index๊ฐ ์กด์ฌํ๋ฉฐ, Index๋ฅผ ํตํด ํด๋น ๋ฐ์ดํฐ์ ์ ๊ทผํ๋ Random Access๋ฅผ ์ง์ํฉ๋๋ค. Index๋ฅผ ํตํด ๊ฐ์ ์์ธํ๋ฉด O(1)์ ์๊ฐ๋ณต์ก๋๊ฐ ์์๋ฉ๋๋ค.
ํ์ง๋ง, ์ค๊ฐ์ ๊ฐ์ ์ฝ์ ํน์ ์ญ์ ์ ๋ํด์ , ๋ค์ ์์๋ค์ ๋ชจ๋ ํ ์นธ์ฉ ๋ฐ๊ฑฐ๋ ๋น๊ฒจ์ผ ํ๋ฏ๋ก Worst Case์ ๊ฒฝ์ฐ O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค.
๊ณ ์ ๊ธธ์ด, ๋๋ฆฐ ์ฝ์ ์ญ์ ์ฐ์ฐ์ ํด๊ฒฐํ๊ธฐ ์ํด์ ๋์จ ์๋ฃ๊ตฌ์กฐ๊ฐ ๋ฐ๋ก LinkedList ์ ๋๋ค.
๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๊ณ ์๋ ๊ฐ ๋ ธ๋๋ฅผ ์๋ก ์ฐ๊ฒฐ ์์ผ ๋ง๋ ์ ํ ์๋ฃ๊ตฌ์กฐ๋ก, ๊ฐ๋ณ ๊ธธ์ด์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค.
์ค๊ฐ์ ๊ฐ์ ์ฝ์ ํ๋ ๊ณผ์ ์์ ๊ธฐ์กด์ ์ฐ๊ฒฐ์ ๋๊ณ , ์๋ก์ด ์ฐ๊ฒฐ์ ๋งบ๋ ๊ณผ์ ๋ง ํ๋ฉด ๋๋ฏ๋ก O(1)์ ์๊ฐ ๋ณต์ก๋, ์ญ์ ํ๋ ๊ณผ์ ์์๋ ๊ธฐ์กด์ ์ฐ๊ฒฐ์ ๋๊ณ ๊ทธ ๋ค์ ๋ ธ๋์ ์ฐ๊ฒฐํ๋ O(1)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค.
๋ฐ๋ฉด ํน์ ๊ฐ์ ์ฐพ๋ ๊ณผ์ ์ ์ฐ๊ฒฐ๋ฆฌ์คํธ ๋ด๋ถ๋ฅผ ๋ชจ๋ ์์ ํ์ํด์ผ ํ๋ฏ๋ก worst case์ ๊ฒฝ์ฐ O(N)์ธ ๋จ์ ์ด ์กด์ฌํฉ๋๋ค.
๐ก LinkedList
๋ฅผ ์์ฝ๋ฉ์ผ๋ก ๊ตฌํํ ์ ์๋์?
class ListNode{
private String data;
public ListNode next;
public ListNode(String data) {
this.data = data;
this.next = null;
}
public String getData() {
return this.data;
}
}
public class LinkedList {
private ListNode head;
public LinkedList() {
head = null;
}
public void insertNode(ListNode preNode, String data) {
ListNode newNode = new ListNode(data);
newNode.next = preNode.next;
preNode.next = newNode;
}
public void insertNode(String data) {
ListNode newNode = new ListNode(data);
if(head == null) {
this.head = newNode;
} else {
ListNode tempNode = head;
while(tempNode.next != null) {
tempNode = tempNode.next;
}
tempNode.next = newNode;
}
}
public void deleteNode(String data) {
ListNode preNode = head;
ListNode tempNode = head.next;
if(data.equals( preNode.getData() )) {
head = preNode.next;
preNode.next = null;
} else {
while(tempNode != null) {
if(data.equals( tempNode.getData() )) {
if(tempNode.next == null) {
preNode.next = null;
} else {
preNode.next = tempNode.next;
tempNode.next = null;
}
break;
} else {
preNode = tempNode;
tempNode = tempNode.next;
}
}
}
}
public void deleteNode() {
ListNode preNode;
ListNode tempNode;
if(head == null) {
return;
}
if(head.next == null) {
head = null;
} else {
preNode = head;
tempNode = head.next;
while(tempNode.next != null) {
preNode = tempNode;
tempNode = tempNode.next;
}
preNode.next = null;
}
}
public ListNode searchNode(String data) {
ListNode tempNode = this.head;
while(tempNode != null) {
if(data.equals(tempNode.getData())) {
return tempNode;
} else {
tempNode = tempNode.next;
}
}
return tempNode;
}
}
๐ก Stack
๊ณผ Queue
์ ๋ํด ์ค๋ช
ํ๊ณ , ๊ฐ๊ฐ ์ด๋์ ์ฌ์ฉ๋์๋์ง ์ค๋ช
ํด์ฃผ์ธ์.
์คํ์, ์ ์ ํ์ถ์ ํน์ฑ์ ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ์ ๋๋ค. ์คํ์ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋ฐฐ์ด / ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ฃผ๋ก ๋ฐฐ์ด์ ํตํด ๊ตฌํํฉ๋๋ค. ์คํ์ด ์ค์ ๋ก ์ฌ์ฉ๋๋ ๋ถ๋ถ์ ๋ธ๋ผ์ฐ์ ์ '๋ค๋ก๊ฐ๊ธฐ' ๊ธฐ๋ฅ์ด๋, ๋ฉ๋ชจ๋ฆฌ ์์ญ์ ์คํ ์์ญ์ ์ฌ์ฉ๋ฉ๋๋ค.
ํ๋, ์ ์ ์ ์ถ์ ํน์ฑ์ ๊ฐ์ง ์๋ฃ๊ตฌ์กฐ์ ๋๋ค. ํ๋ฅผ ๊ตฌํํ๊ธฐ ์ํด์๋ ๋ฐฐ์ด / ์ฐ๊ฒฐ๋ฆฌ์คํธ ์ฌ์ฉ์ด ๊ฐ๋ฅํ๋ฉฐ, ์ฃผ๋ก ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ฅผ ํตํด ๊ตฌํํฉ๋๋ค. ํ๊ฐ ์ค์ ๋ก ์ฌ์ฉ๋๋ ๋ถ๋ถ์ ํ๋ฆฐํฐ ํ, CPU ์ค์ผ์ค๋ง์ Ready Queue ๋ฑ์ ์ฌ์ฉ๋ฉ๋๋ค.
๐ก Stack
ํด๋์ค๋ฅผ ์์ฝ๋ฉ(์ง๋ฌด์ธ์ด)์ผ๋ก ๊ตฌํํ ์ ์๋์?
public class Stack {
int[] array;
private int top;
private int size;
public Stack(int length){
this.array = new int[length];
this.size = length;
this.top = -1;
}
public boolean isEmpty(){
return this.top == -1;
}
public boolean isFull(){
return this.top == size-1;
}
public void append(int value){
if(isFull()){
System.out.println("stack is full");
return;
}
this.array[++this.top] = value;
}
public int pop(){
if(isEmpty()){
System.out.println("stack is empty");
return -1;
}
return this.array[this.top--];
}
public static void main(String[] args) {
Stack stack = new Stack(10);
stack.append(1);
stack.append(2);
stack.append(3);
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
System.out.println(stack.pop());
}
}
๐ก Queue
ํด๋์ค๋ฅผ ์์ฝ๋ฉ(์ง๋ฌด์ธ์ด)์ผ๋ก ๊ตฌํํ ์ ์๋์?
import java.util.LinkedList;
public class Queue {
private LinkedList<Integer> array;
public Queue(){
this.array = new LinkedList<>();
}
public void append(Integer value){
this.array.add(value);
}
public Integer popLeft(){
if(this.array.isEmpty()){
System.out.println("Queue is empty");
return -1;
}
return this.array.removeLast();
}
public static void main(String[] args) {
Queue queue = new Queue();
queue.append(1);
queue.append(2);
System.out.println(queue.popLeft());
System.out.println(queue.popLeft());
System.out.println(queue.popLeft());
}
}
๐ก Priority Queue
๊ฐ ๋ฌด์์ด๊ณ , ์ด๋ป๊ฒ ๊ตฌํํ ์ ์๋์ง ์ค๋ช
ํ ์ ์๋์?
์ ์ ์ ์ถ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ํ์ ๋ค๋ฅด๊ฒ, ์ฐ์ ์์๊ฐ ๋์ ์์๊ฐ ์ฐ์ ์ ์ผ๋ก ๋น ์ ธ๋์ค๊ฒ ๋๋ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
์ฐ์ ์์ ํ๋ ๋ฐฐ์ด, ์ฐ๊ฒฐ๋ฆฌ์คํธ, Heap์ผ๋ก ๊ตฌํํ ์ ์์ผ๋ฉฐ, ์ผ๋ฐ์ ์ธ ๊ฒฝ์ฐ์๋ ์ฝ์ ๊ณผ ์ญ์ ์ฐ์ฐ์ด ๋ชจ๋ O(logN)์ด ๋ณด์ฅ๋ Heap ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํฉ๋๋ค.
๐ก ๊ทธ๋ ๋ค๋ฉด, Heap
์ด ๋ฌด์์ธ์ง , ์ฝ์
๋ฐ ์ญ์ ์ ์ด๋ป๊ฒ ๋์ํ๋์ง ์ค๋ช
ํ ์ ์๋์?
ํ(Heap)์ '์์ ์ด์งํธ๋ฆฌ'๋ฉด์, ๋ชจ๋ ๋ถ๋ชจ๋ ธ๋์ ์์๋ ธ๋ ๊ฐ์ 'ํฌ๊ฑฐ๋ ๊ฐ์' ํน์ '์๊ฑฐ๋ ๊ฐ์'์ ๊ด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ด์งํธ๋ฆฌ๋ ์์๋ ธ๋๋ฅผ ์ต๋ 2๊ฐ๊น์ง ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํ๋ฉฐ, ์์ ์ด์งํธ๋ฆฌ๋ ๋ฆฌํ๋ ธ๋ ๋ ๋ฒจ์ ์ ์ธํ ๋๋จธ์ง ํธ๋ฆฌ๋ ํฌํ ์ด์งํธ๋ฆฌ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ๊ณ , ๋ฆฌํ๋ ธ๋ ๋ ๋ฒจ์ ๋ ธ๋๋ค์ ์ผ์ชฝ ์ธ๋ฑ์ค๋ถํฐ ์ฐจ๋ก๋ก ์ฑ์์ง ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
ํฌํ ์ด์ง ํธ๋ฆฌ๋ ๋ฆฌํ๋ ธ๋๋ค์ ์ ์ธํ ๋๋จธ์ง ๋ ธ๋๋ค์ ๋ชจ๋ ์์์ 2๊ฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ฆฌํ๋ ธ๋๋ค์ ์์์ ๊ฐ์ง ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ฝ์ ๋ฐ ์ญ์ ๋ฅผ ํ๋ฉด Heap์ ๊ตฌ์กฐ๊ฐ ๋ฌด๋์ง๊ฒ ๋๋๋ฐ, ๋ค์ Heap์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ Heapify๋ผ๊ณ ํฉ๋๋ค.
์ฝ์ ์ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ธ๋ ๋ค์ ์ธ๋ฑ์ค์ ์๋ก์ด ๋ ธ๋๋ฅผ ์ง์ด๋ฃ๊ณ Heapify ์ฐ์ฐ์ ํตํด ํ์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค.
์ญ์ ์ ํธ๋ฆฌ์ ๋ฃจํธ๋ ธ๋๋ฅผ ๋ฐํ ๋ฐ ์ ๊ฑฐํ๊ณ , ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง ๋ ธ๋์ ์ ์น๋ฅผ ๋ฆฌํ๋ ธ๋๋ก ์ด๋์ํต๋๋ค. ๊ทธ ํ Heapfiy ์ฐ์ฐ์ ํตํด ๋ค์ ํ์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค.
์ฝ์ ๊ณผ ์ญ์ ์ฐ์ฐ ๋ชจ๋ ํธ๋ฆฌ์ ๋์ด์ ๋ฐ๋ผ ์ฐ์ฐํ์๊ฐ ๊ฒฐ์ ๋๋ฉฐ, worst case์ ์๊ฐ ๋ณต์ก๋๋ ๋ ๋ค O(logN)์ ๋ณด์ฅํฉ๋๋ค.
๐ก ํด์ ํ
์ด๋ธ(Hash Table)
์ ๋ํด์ ์ค๋ช
ํ ์ ์๋์?
ํด์ ํ ์ด๋ธ์ Key-Value ์์ผ๋ก ๊ฐ์ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ๋ก, ๊ฒ์ ์๊ฐ ๋ณต์ก๋๋ก Θ(1)๋ฅผ ๊ฐ๊ณ ์๋ ๊ฒ์ด ํน์ง์ ๋๋ค.
ํด์ ํ ์ด๋ธ์ ์ ๊ทผํ ์ ์๋ Key์, Key์ ๋งคํ๋์ด ์๋ Value๋ก ์ ์ฅ๋์ด ์๋ ๊ฒ์ด ํน์ง์ ๋๋ค.
๐ก ํด์ ํ
์ด๋ธ(Hash Table)
์ ๊ฒ์ ์๊ฐ ๋ณต์ก๋๋ ์ด๋ป๊ฒ O(1)
์ ์ ์งํ ์ ์๋์?
ํด์ ํ ์ด๋ธ์ Key๋ก ์ ๊ทผํ๋ฉด, Hash Function์ Key ๊ฐ์ ์ง์ด ๋ฃ์ด ๋์จ Hash ๊ฐ์ ์ ์ฅ์์ ์ธ๋ฑ์ค๋ก ํ์ฉํฉ๋๋ค. ํด๋น ์ธ๋ฑ์ค์ ๊ฐ์ ์ ์ฅํ๊ธฐ ๋๋ฌธ์, Hash Function์ ์๊ฐ ๋ณต์ก๋๋ฅผ ์ ์ธํ๋ฉด ์๊ฐ ๋ณต์ก๋ O(1)์ ๋ณด์ฅํ ์ ์์ต๋๋ค.
๐ก ๊ทธ๋ ๋ค๋ฉด Hash Collision (ํด์ ์ถฉ๋)
์ ๋ํด ์ค๋ช
ํ ์ ์๋์? ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ด๋ป๊ฒ ๋๋์?
ํด์ ํ ์ด๋ธ์ ์ ๊ทผํ๋ Key ๊ฐ์ ๋ฌดํํ๊ณ , Hash Function์ ํตํด ๋์จ Hash ๊ฐ์ ์ ํํฉ๋๋ค. (๊ฐ์ด ์ ์ฅ๋๋ ๋ฉ๋ชจ๋ฆฌ๋ ํ๊ณ๊ฐ ์์ผ๋ฏ๋ก.)
๋น๋๊ธฐ์ง์ ์๋ฆฌ๋ N+1๋ง๋ฆฌ์ ๋น๋๊ธฐ๊ฐ N๊ฐ์ ๋น๋๊ธฐ ์ง์ ๋ค์ด๊ฐ๋ค๋ฉด, ๋ฐ๋์ ํ๋์ ๋น๋๊ธฐ ์ง์๋ ๋ ๋ง๋ฆฌ ์ด์์ ๋น๋๊ธฐ๊ฐ ๋ค์ด๊ฐ ์๋ค๋ ๊ฒ์ ๋๋ค.
ํด์ ํ ์ด๋ธ์ Key๋ ๋น๋๊ธฐ๊ณ , Hash ์ธ๋ฑ์ค๊ฐ ๋น๋๊ธฐ ์ง์ด๋ผ๊ณ ํ์ ๋, Key๋ ๋ฌดํํ๊ณ Hash ๋ ์ ํํ๋ฏ๋ก ํน์ Hash Index์ ๋ํด์ ๊ฒน์น๋ Key๊ฐ ์กด์ฌํ ์ ๋ฐ์ ์์ต๋๋ค.
์ด๋ ๊ฒ ์๋ก ๋ค๋ฅธ Key์ ๋ํด ๊ฐ์ ํด์๊ฐ์ ๊ฐ๋ ๊ฒฝ์ฐ๋ฅผ ํด์ ์ถฉ๋์ด๋ผ๊ณ ํฉ๋๋ค.
ํด๊ฒฐ ๋ฐฉ๋ฒ์, Chaining ๋ฐฉ์๊ณผ Open Addressing ๋ฐฉ์์ด ์์ต๋๋ค.
- ์ฒด์ด๋(Chaining) : ์ธ๋ฑ์ค์ ๋ฒํท์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๊ตฌํํด, ์ด๋ฏธ ๊ฐ์ด ์กด์ฌํ๋๋ผ๋ ์ฐ๊ฒฐ๋ฆฌ์คํธ์ ํด๋น ๊ฐ์ ์ฝ์ ํ๋ ๋ฐฉ์
- ๊ฐ๋ฐฉ์ฃผ์๋ฒ(Open Addressing) : ํด์ ์ถฉ๋์ด ์ผ์ด๋ ๊ฒฝ์ฐ, ํน์ ํ ๊ฐ๊ฒฉ๋งํผ ์ด๋ ํ ๋น์ด์๋ ์ฃผ์ ๊ฐ์ ์ ์ฅํ๋ ๋ฐฉ์
๐ก ๊ทธ๋ ๋ค๋ฉด, ์ฒด์ด๋ ๋ฐฉ์๊ณผ ๊ฐ๋ฐฉ์ฃผ์๋ฒ์ ์ฅ๋จ์ ์ ๋น๊ตํด์ฃผ์ธ์.
์ฒด์ด๋ ๋ฐฉ์ :
์ฅ์ :
1) ํ์ ๋ ์ ์ฅ์(Bucket)์ ํจ์จ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๋ค.
2) ํด์ ํจ์(Hash Function)์ ์ ํํ๋ ์ค์์ฑ์ด ์๋์ ์ผ๋ก ์ ๋ค.
3) ์๋์ ์ผ๋ก ์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค. ๋ฏธ๋ฆฌ ๊ณต๊ฐ์ ์ก์ ๋์ ํ์๊ฐ ์๋ค.
๋จ์ :
1) ํ Hash์ ์๋ฃ๋ค์ด ๊ณ์ ์ฐ๊ฒฐ๋๋ค๋ฉด(์ ๋ฆผ ํ์) ๊ฒ์ ํจ์จ์ ๋ฎ์ถ ์ ์๋ค.
2) ์ธ๋ถ ์ ์ฅ ๊ณต๊ฐ์ ์ฌ์ฉํ๋ค.
3) ์ธ๋ถ ์ ์ฅ ๊ณต๊ฐ ์์
์ ์ถ๊ฐ๋ก ํด์ผ ํ๋ค.
๊ฐ๋ฐฉ์ฃผ์๋ฒ ๋ฐฉ์ :
์ฅ์ :
1) ๋ ๋ค๋ฅธ ์ ์ฅ๊ณต๊ฐ ์์ด ํด์ํ
์ด๋ธ ๋ด์์ ๋ฐ์ดํฐ ์ ์ฅ ๋ฐ ์ฒ๋ฆฌ๊ฐ ๊ฐ๋ฅํ๋ค.
2) ๋ ๋ค๋ฅธ ์ ์ฅ๊ณต๊ฐ์์์ ์ถ๊ฐ์ ์ธ ์์
์ด ์๋ค.
๋จ์ :
1) ํด์ ํจ์(Hash Function)์ ์ฑ๋ฅ์ ์ ์ฒด ํด์ํ
์ด๋ธ์ ์ฑ๋ฅ์ด ์ข์ง์ฐ์ง๋๋ค.
2) ๋ฐ์ดํฐ์ ๊ธธ์ด๊ฐ ๋์ด๋๋ฉด ๊ทธ์ ํด๋นํ๋ ์ ์ฅ์๋ฅผ ๋ง๋ จํด ๋์ด์ผ ํ๋ค.
๐ก ํด์ ํ ์ด๋ธ์ ๋จ์ ์ ๋ฌด์์ด ์์๊น์? ์ธ์ ์ฌ์ฉํ๋ฉด ์ ๋ ๊น์?
์ ๋ฐ์ดํธ ์์
๐ก BST (Binary Search Tree)
์ BST
์ ํน์ง์ ๋ํด ์ค๋ช
ํ ์ ์๋์?
๋ฐ์ดํฐ์ ๋น ๋ฅธ ๊ฒ์์ ์ํด ๋ง๋ค์ด์ง ํธ๋ฆฌ ์๋ฃ๊ตฌ์กฐ์ ๋๋ค.
์๋์ ๊ฐ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ ํธ๋ฆฌ์ ๋ํด BST๋ผ๊ณ ๋ถ๋ฅผ ์ ์์ต๋๋ค.
- ์ด์ง ํธ๋ฆฌ (์์์ ์ต๋ 2๊ฐ๊น์ง ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ)
- ๋ฃจํธ๋ ธ๋์ ๋ํด์ ์ผ์ชฝ ์์์ ๋ฃจํธ ๋ ธ๋๋ณด๋ค ๋ ์์ ๊ฐ์, ์ค๋ฅธ์ชฝ ์์์ ๋ฃจํธ ๋ ธ๋๋ณด๋ค ๋ ํฐ ๊ฐ์ ์ ์ฅํ๋ค.
- ๋ฃจํธ๋ ธ๋์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ, ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋ํด ์์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ค.
ํ์์ ์ ๋ฆฌํ ์๋ฃ๊ตฌ์กฐ๋ก, ํน์ ๊ฐ์ ๋ํด ํ์ํ๋ ์๊ฐ ๋ณต์ก๋๊ฐ ํธ๋ฆฌ์ ๋์ด์ ์์กดํ๊ธฐ ๋๋ฌธ์ ํ๊ท ์ ์ผ๋ก logN์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค.
๋ค๋ง, ์ด์งํ์ํธ๋ฆฌ์ ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ์ ๊ท ํ์ด ๋ง์ง ์๊ณ ํ ์ชฝ์ผ๋ก๋ง ์น์ฐ์ณ์ง ๊ฒฝ์ฐ์๋ ํธ๋ฆฌ์ ๋์ด ์์ฒด๊ฐ N์ด ๋๋ฏ๋ก Worst Case์ ๊ฒฝ์ฐ O(N)์ ์๊ฐ๋ณต์ก๋๋ฅผ ๊ฐ์ต๋๋ค.
๐ก BST
์ ์ฑ๋ฅ์ ๊ฐ์ ํ๊ธฐ ์ํ ๋ฐฉ๋ฒ์๋ ๋ฌด์์ด ์๋์?
์์์ ์ธ๊ธํ๋ฏ์ด, BST์ ์์ชฝ ๋์ด์ ๊ท ํ์ ๋ง์ถ๋ ๊ฒ์ด ์ฑ๋ฅ์ ๊ฐ์ ํ๋ ๋ฐฉ์์ ๋๋ค.
๋ํ์ ์ผ๋ก ๊ฐ๋๋ BST ํธ๋ฆฌ๋ก์จ, AVL ํธ๋ฆฌ, Red-Black ํธ๋ฆฌ๊ฐ ์์ต๋๋ค.
๐ก AVL ํธ๋ฆฌ๋ ๋ฌด์์ธ๊ฐ์?
์ ๋ฐ์ดํธ ์์
๐ก ํธ๋ฆฌ์ ๊ทธ๋ํ์ ์ฐจ์ด์ ๋ํด์ ์ค๋ช ํ ์ ์๋์?
๊ทธ๋ํ๋ ํธ๋ฆฌ๋ณด๋ค ๋ ํฌ๊ด์ ์ธ ๊ฐ๋ ์ ๋๋ค. ์ฆ, ํธ๋ฆฌ๋ ๊ทธ๋ํ๋ผ๊ณ ๋ถ๋ฅผ ์ ์์ผ๋ ๋ชจ๋ ๊ทธ๋ํ๋ฅผ ํธ๋ฆฌ๋ผ๊ณ ๋ถ๋ฅผ ์ ์์ต๋๋ค.
๊ทธ๋ํ๋ ๊ฐ ์์๋ฅผ ๋ํ๋ด๋ ๋ ธ๋์ ๋ ธ๋ ์ฌ์ด์ ๊ด๊ณ๋ฅผ ๋ํ๋ด๋ ์ฃ์ง๋ก ๋ํ๋ผ ์ ์์ต๋๋ค.
ํธ๋ฆฌ๋ ๊ทธ๋ํ์ ๋์ผํ๋, ์ฌ์ดํด์ด ์๋ ๊ทธ๋ํ๋ฅผ ์๋ฏธํ๋ฉฐ ๊ณ์ธต ๊ตฌ์กฐ๋ฅผ ๋ํ๋ผ ๋ ์ฉ์ดํฉ๋๋ค.
๐ก ์ด์งํธ๋ฆฌ์ ์ ์ / ์ค์ / ํ์ ์ํ๊ฐ ๋ฌด์์ธ๊ฐ์? ์ค๋ช ํ๊ณ , ์์ ์ด ์ง๋ฌด ์ธ์ด๋ก ์ํ ๊ฒฐ๊ณผ๋ฅผ ์ฝ๋ฉํด๋ณด์ธ์.
- ๋ฃจํธ๋ฅผ ๋ฐฉ๋ฌธํ๋ ์์ ์ V
- ์ผ์ชฝ ์๋ธ ํธ๋ฆฌ ๋ฐฉ๋ฌธ์ L
- ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ ๋ฐฉ๋ฌธ์ R
- ๋ฃจํธ๋ฅผ ์๋ธ ํธ๋ฆฌ์ ์์์ ๋จผ์ ๋ฐฉ๋ฌธํ๋ฉด ์ ์ ์ํ
- ๋ฃจํธ๋ฅผ ์ผ์ชฝ๊ณผ ์ค๋ฅธ์ชฝ ์๋ธ ํธ๋ฆฌ ์ค๊ฐ์ ๋ฐฉ๋ฌธํ๋ฉด ์ค์ ์ํ
- ๋ฃจํธ๋ฅผ ์๋ธ ํธ๋ฆฌ ๋ฐฉ๋ฌธ ํ์ ๋ฐฉ๋ฌธํ๋ฉด ํ์ ์ํ๊ฐ ๋ฉ๋๋ค.
public class TreeOrder {
public static void main(String[] args) {
int[] array = {1, 3, 2, 5, 6, 4, 7, 9, 8};
Tree tree = new Tree(array);
tree.preOrder(1);
System.out.println("");
tree.inOrder(1);
System.out.println("");
tree.postOrder(1);
}
}
class Tree{
int[] binaryTree;
public Tree(int[] array){
int tree_size = array.length + 1;
this.binaryTree = new int[tree_size];
this.binaryTree[0] = 0;
System.arraycopy(array, 0, binaryTree, 1, tree_size - 1);
}
public void preOrder(int idx){
if(0 > idx | idx >= binaryTree.length){
return;
}
System.out.println(this.binaryTree[idx]);
this.preOrder(idx*2);
this.preOrder(idx*2 + 1);
}
public void inOrder(int idx){
if(0 > idx | idx >= binaryTree.length){
return;
}
this.preOrder(idx*2);
System.out.println(this.binaryTree[idx]);
this.preOrder(idx*2 + 1);
}
public void postOrder(int idx){
if(0 > idx | idx >= binaryTree.length){
return;
}
this.preOrder(idx*2);
this.preOrder(idx*2 + 1);
System.out.println(this.binaryTree[idx]);
}
}
๐ก + Java
์ Collections
์ ๋ํด์ ์๊ณ ์๋์?
์ ๋ฐ์ดํธ ์์ .
๐โ๏ธ ๋ค๋ฅธ ์ง๋ฌธ ๋๋น ์๋ฃ
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โ ์๋ฃ๊ตฌ์กฐ
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โก ์๊ณ ๋ฆฌ์ฆ
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โข ๋ฐ์ดํฐ๋ฒ ์ด์ค
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โฃ ๋คํธ์ํฌ
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โค ์ด์์ฒด์
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โฅ ์๋ฐ(Java)
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โฆ ๋ฐฑ์๋(Java Spring ๊ธฐ๋ฐ)
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โง ๊ฐ๋ฐ๊ณตํต / ์ธ์ฑ๋ฉด์