๐ง๐ป๐ป ๊ธ์ ์์ํ๊ธฐ์ ์์..
- ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ์์ ์์ฃผ ๋์ค๋ ์ง๋ฌธ์ ๋ชจ์ ํ ๋ฒ์ ์ ๋ฆฌํ ํฌ์คํธ์ ๋๋ค.
- ์ ์ ๊ฐ๋ฐ์ ๊ธฐ์ ๋ฉด์ ์ ์ค๋นํ๋ ์ฌ๋์ผ๋ก, ์ ํํ์ง ์์ ์ ๋ณด๊ฐ ํฌํจ๋ ์ ์์ต๋๋ค. ๋ ์ฌ๋ฐ๋ฅธ ๋ต์ ์๊ณ ์๋ค๋ฉด ๋๊ธ๋ก ๋จ๊ฒจ์ฃผ์๋ฉด ๋ฐ์ํ๋๋ก ํ๊ฒ ์ต๋๋ค.
- ํ์๋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)์ธ ๋จ์ ์ด ์กด์ฌํฉ๋๋ค.
[์๋ฃ๊ตฌ์กฐ] Array์ LinkedList์ ์ฐจ์ด (์ธํฐ๋ทฐ ๋๋น)
๐ก 1. Array(๋ฐฐ์ด), Array VS ArrayList 1. ๋ฐฐ์ด : ๋ฐฐ์ด์ ์์ฐจ์ ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์๋ฃ๊ตฌ์กฐ์ด๋ค. 2.ํฌ๊ธฐ : ๋ฐฐ์ด์ ํฌ๊ธฐ๋ ๊ณ ์ ๊ธธ์ด์ด๋ฏ๋ก, ์ถ๊ฐ์ ์ผ๋ก ๋๋ฆด ์ ์๋ค. Array ๋ ์ด๊ธฐํ ์ ๋ฉ๋ชจ๋ฆฌ์ ํ
hoons-dev.tistory.com
๐ก 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๊ณผ Queue์ ๋น๊ต (์ธํฐ๋ทฐ ๋๋น)
๐ก 1. Stack(์คํ)์ด๋? 1. ์คํ : Stack ์ ๋จผ์ ๋ค์ด๊ฐ ์์๊ฐ ๊ฐ์ฅ ๋์ค์ ๋์ค๊ฒ ๋๋ ์ ์ ํ์ถ(LIFO, Last In First Out) ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ค. 2. ๊ตฌํ : Stack ์ ๊ตฌํํ ๋๋, ์์๋ฅผ ์ ๊ฑฐ..
hoons-dev.tistory.com
๐ก 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 ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํด์ ์ฐ์ ์์ ํ๋ฅผ ๊ตฌํํฉ๋๋ค.
[์๋ฃ๊ตฌ์กฐ] Priority Queue (์ฐ์ ์์ ํ) ์ธํฐ๋ทฐ ๋๋น
๐ก 1. ์ฐ์ ์์ ํ(Priority Queue)๋? ์ฐ์ 'ํ'๋ ์ ์ ์ ์ถ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ํ์ ๋ค์ด์จ ์์๋ฅผ ์ฐ์ ์์๋ก ๊ฐ๋ ํ์ธ ๊ฒ์ด๋ค. ์ฐ์ ์์ ํ๋ ์ผ๋ฐ์ ์ผ๋ก ๋จผ์ ๋ค์ด์จ ์์๋๋ก
hoons-dev.tistory.com
๐ก ๊ทธ๋ ๋ค๋ฉด, Heap์ด ๋ฌด์์ธ์ง , ์ฝ์
๋ฐ ์ญ์ ์ ์ด๋ป๊ฒ ๋์ํ๋์ง ์ค๋ช
ํ ์ ์๋์?
ํ(Heap)์ '์์ ์ด์งํธ๋ฆฌ'๋ฉด์, ๋ชจ๋ ๋ถ๋ชจ๋ ธ๋์ ์์๋ ธ๋ ๊ฐ์ 'ํฌ๊ฑฐ๋ ๊ฐ์' ํน์ '์๊ฑฐ๋ ๊ฐ์'์ ๊ด๊ณ๋ฅผ ๊ฐ์ง๊ณ ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ด์งํธ๋ฆฌ๋ ์์๋ ธ๋๋ฅผ ์ต๋ 2๊ฐ๊น์ง ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํ๋ฉฐ, ์์ ์ด์งํธ๋ฆฌ๋ ๋ฆฌํ๋ ธ๋ ๋ ๋ฒจ์ ์ ์ธํ ๋๋จธ์ง ํธ๋ฆฌ๋ ํฌํ ์ด์งํธ๋ฆฌ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ๊ณ , ๋ฆฌํ๋ ธ๋ ๋ ๋ฒจ์ ๋ ธ๋๋ค์ ์ผ์ชฝ ์ธ๋ฑ์ค๋ถํฐ ์ฐจ๋ก๋ก ์ฑ์์ง ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
ํฌํ ์ด์ง ํธ๋ฆฌ๋ ๋ฆฌํ๋ ธ๋๋ค์ ์ ์ธํ ๋๋จธ์ง ๋ ธ๋๋ค์ ๋ชจ๋ ์์์ 2๊ฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ฆฌํ๋ ธ๋๋ค์ ์์์ ๊ฐ์ง ์๋ ํธ๋ฆฌ๋ฅผ ์๋ฏธํฉ๋๋ค.
์ฝ์ ๋ฐ ์ญ์ ๋ฅผ ํ๋ฉด Heap์ ๊ตฌ์กฐ๊ฐ ๋ฌด๋์ง๊ฒ ๋๋๋ฐ, ๋ค์ Heap์ผ๋ก ๋ง๋๋ ๊ณผ์ ์ Heapify๋ผ๊ณ ํฉ๋๋ค.
์ฝ์ ์ ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ๋ ธ๋ ๋ค์ ์ธ๋ฑ์ค์ ์๋ก์ด ๋ ธ๋๋ฅผ ์ง์ด๋ฃ๊ณ Heapify ์ฐ์ฐ์ ํตํด ํ์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค.
์ญ์ ์ ํธ๋ฆฌ์ ๋ฃจํธ๋ ธ๋๋ฅผ ๋ฐํ ๋ฐ ์ ๊ฑฐํ๊ณ , ํธ๋ฆฌ์ ๊ฐ์ฅ ๋ง์ง๋ง ์ธ๋ฑ์ค๋ฅผ ๊ฐ์ง ๋ ธ๋์ ์ ์น๋ฅผ ๋ฆฌํ๋ ธ๋๋ก ์ด๋์ํต๋๋ค. ๊ทธ ํ Heapfiy ์ฐ์ฐ์ ํตํด ๋ค์ ํ์ผ๋ก ๊ตฌ์ฑํฉ๋๋ค.
์ฝ์ ๊ณผ ์ญ์ ์ฐ์ฐ ๋ชจ๋ ํธ๋ฆฌ์ ๋์ด์ ๋ฐ๋ผ ์ฐ์ฐํ์๊ฐ ๊ฒฐ์ ๋๋ฉฐ, worst case์ ์๊ฐ ๋ณต์ก๋๋ ๋ ๋ค O(logN)์ ๋ณด์ฅํฉ๋๋ค.
[์๋ฃ๊ตฌ์กฐ] Priority Queue (์ฐ์ ์์ ํ) ์ธํฐ๋ทฐ ๋๋น
๐ก 1. ์ฐ์ ์์ ํ(Priority Queue)๋? ์ฐ์ 'ํ'๋ ์ ์ ์ ์ถ์ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง ์ ํ ์๋ฃ๊ตฌ์กฐ์ด๋ค. ํ์ ๋ค์ด์จ ์์๋ฅผ ์ฐ์ ์์๋ก ๊ฐ๋ ํ์ธ ๊ฒ์ด๋ค. ์ฐ์ ์์ ํ๋ ์ผ๋ฐ์ ์ผ๋ก ๋จผ์ ๋ค์ด์จ ์์๋๋ก
hoons-dev.tistory.com
๐ก ํด์ ํ
์ด๋ธ(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 ๊ธฐ๋ฐ)
[๐ ์ ์ ์ธํฐ๋ทฐ ์ค๋น] - [๋ฉด์ ์ด์ ๋ฆฌ] ์ ์ ๊ฐ๋ฐ์ ์ธํฐ๋ทฐ ๋๋น ์ด์ ๋ฆฌ ์๋ฃ - โง ๊ฐ๋ฐ๊ณตํต / ์ธ์ฑ๋ฉด์