0. ์คํ Stack ์ด๋ ?
์คํ์ ๋ฐ์ดํฐ๋ฅผ ์ผ์์ ์ผ๋ก ์ ์ฅํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ์๋ฃ๊ตฌ์กฐ
๋ฐ์ดํฐ์ ์ ๋ ฅ๊ณผ ์ถ๋ ฅ ์์๋ ํ์ ์ ์ถ (LIFO : Last In First Out)
ex ) ์๋ฐ ํ๋ก๊ทธ๋จ์์ ๋ฉ์๋๋ฅผ ํธ์ถํ๊ณ ์คํํ ๋ ํ๋ก๊ทธ๋จ ๋ด๋ถ์์ ์คํ ์ฌ์ฉ
ํธ์ (push) : ์คํ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ๋ ์์
ํ (pop) : ์คํ์์ ๋ฐ์ดํฐ๋ฅผ ๊บผ๋ด๋ ์์
๊ผญ๋๊ธฐ (top) : ํธ์์ ํ์ ํ๋ ์์น
๋ฐ๋ฅ (bottom) : ์คํ์ ๊ฐ์ฅ ์๋ซ๋ถ๋ถ
1. ์คํ ๊ตฌํ
int[] stk : ์คํ ๋ณธ์ฒด์ฉ ๋ฐฐ์ด. index 0์ธ ์์๊ฐ ์คํ์ bottom
int max : ์คํ ์ฉ๋. ์คํ์ ์ ์ฅํ ์ ์๋ ์ต๋ ๋ฐ์ดํฐ ์
int ptr : ์คํ ํฌ์ธํฐ. ๋ค์ push()๋ฅผ ์คํํ ์์น. ํ์ฌ ์คํ์ ์ ์ฅ๋์ด ์๋ ๋ฐ์ดํฐ ์. ์คํ์ด ๋น์ด์์ผ๋ฉด num == 0, ์คํ์ด ๊ฐ๋ ์ฐจ ์์ผ๋ฉด num == max
- Stack() : ์์ฑ์
public Stack(int capacity) {
ptr = 0;
max = capacity;
try {
stk = new int[max];
} catch (OutOfMemoryError e) {
max = 0;
}
}
- ๋งค๊ฐ๋ณ์ : ์์ฑํ ์คํ์ ์ฉ๋
- ์คํ์ ์์ฑํ๋ฉด ๋น์ด์์ผ๋ฏ๋ก ptr์ 0
- ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ์ capacity๋ฅผ ์คํ ์ฉ๋์ ๋ํ๋ด๋ max์ ๋ณต์ฌ
- ์์ ์๊ฐ max์ธ ๋ฐฐ์ด stk ์์ฑ
- try-catch๋ฌธ์ ์ฌ์ฉํ์ฌ ๋ฐฐ์ด ๋ณธ์ฒด ์์ฑ์ ์คํจํ ๊ฒฝ์ฐ, max๋ฅผ 0์ผ๋ก ์ค์ ํ์ฌ ๋ค๋ฅธ ๋ฉ์๋๊ฐ ์กด์ฌํ์ง ์๋ ๋ฐฐ์ด์ ์๋ชป ์ ๊ทผํ๋ ๊ฒ์ ๋ง์
- push() : ์คํ์ ๋ฐ์ดํฐ๋ฅผ ํธ์
public int push(int x) throws OverFlowStackException {
if(ptr >= max) {
throw new OverFlowStackException();
}
stk[ptr++] = x;
return x;
}
- ๋งค๊ฐ๋ณ์ : ํธ์ํ ๊ฐ
- ์คํ์ด ๊ฐ๋ ์ฐจ์ ํธ์ํ ์ ์๋ ๊ฒฝ์ฐ, ๋ฏธ๋ฆฌ ์์ฑํ OverFlowStackException ์ throw
- ์คํ์ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ ํ, ์คํ ํฌ์ธํฐ๋ฅผ ์ฆ๊ฐ
- ๋ฐํ๊ฐ : ํธ์ํ ๊ฐ
- pop() : ์คํ์์ ๋ฐ์ดํฐ๋ฅผ ํ
public int pop() throws EmptyStackException {
if(ptr <= 0) {
throw new EmptyStackException();
}
int x = stk[--ptr];
return x;
}
- ์คํ์ ๊ผญ๋๊ธฐ์์ ๋ฐ์ดํฐ๋ฅผ ์ ๊ฑฐ
- ๋ฐ์ดํฐ๋ฅผ ์ค์ ๋ก ์ ๊ฑฐํ๋ ๊ฒ์ด ์๋๋ผ ptr์ ๊ฐ์์ํด์ผ๋ก์จ ๋ค์ push()์ ๋ฐ์ดํฐ๊ฐ ๋ฎ์ด์์์ง
- ์คํ์ด ๋น์ด์์ด ํ ํ ์ ์๋ ๊ฒฝ์ฐ, ๋ฏธ๋ฆฌ ์์ฑํ EmptyStackException ์ throw
- ๋ฐํ๊ฐ : ํํ ๊ฐ
- peek() : ์คํ์ ๊ผญ๋๊ธฐ ๊ฐ, ์คํ์์ ๋ค์์ ๊บผ๋ผ ๋ฐ์ดํฐ
public int peek() throws EmptyStackException {
if(ptr <= 0) {
throw new EmptyStackException();
}
return stk[ptr-1];
}
- ์คํ์ด ๋น์ด์์ผ๋ฉด ๋ฏธ๋ฆฌ ์์ฑํ EmptyStackException ์ throw
- stk[ptr-1]์ ๊ฐ์ ํ์ธ๋ง ํ๊ณ ๋ฐ์ดํฐ๋ฅผ ๋ณ๊ฒฝํ์ง ์์ผ๋ฏ๋ก ptr ๊ฐ์ ๋ณํ์ง ์์
- ๋ฐํ๊ฐ : ์คํ์ ๊ผญ๋๊ธฐ ๊ฐ
- indexOf() : ์คํ ๋ฐ์ดํฐ ํ์
public int indexOf(int x) {
for(int i = ptr - 1; i >= 0; i--) {
if(stk[i] == x) {
return i;
}
}
return -1;
}
- ๋งค๊ฐ๋ณ์ : ๊ฒ์ํ ๋ฐ์ดํฐ
- ์คํ์ x์ ๊ฐ์ ๊ฐ์ ๋ฐ์ดํฐ๊ฐ ํฌํจ๋์ด์๋์ง ํ์ ( ๋จผ์ ํ ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ฐพ๊ธฐ ์ํด ๊ผญ๋๊ธฐ์์ ๋ฐ๋ฅ ๋ฐฉํฅ์ผ๋ก ์ ํ ํ์ ์ํ )
- ๋ฐํ๊ฐ : ์กด์ฌํ๋ฉด ์ฐพ์ ๋ฐ์ดํฐ์ index, ์กด์ฌํ์ง ์์ผ๋ฉด -1
- dump() : ์คํ ์์ ๋ชจ๋ ๋ฐ์ดํฐ ์ถ๋ ฅ
public void dump() {
if(ptr <= 0) {
System.out.println("์คํ์ด ๋น์ด์์ต๋๋ค");
} else {
for(int i = 0; i < ptr; i++) {
System.out.println(stk[i] + " ");
}
System.out.println();
}
}
- ์คํ์ ํธ์ ๋ num๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฐ๋ฅ์์ ๊ผญ๋๊ธฐ ์์ผ๋ก ๋ชจ๋ ์ถ๋ ฅ
- ์คํ์ด ๋น์ด์์ผ๋ฉด "์คํ์ด ๋น์ด์์ต๋๋ค" ์ถ๋ ฅ
- ๊ธฐํ ๋ฉ์๋
public void clear() {
ptr = 0;
}
public int capacity() {
return max;
}
public int size() {
return ptr;
}
public boolean inEmpty() {
return ptr <= 0;
}
public boolean inFull() {
return ptr >= max;
}
- clear() : ํ์ฌ ์คํ์ ๋ชจ๋ ์์๋ฅผ ์ญ์ . ์คํ์ ๋ฐฐ์ด ์์ ๊ฐ์ ๋ณ๊ฒฝํ ํ์ ์์ด ์คํํฌ์ธํฐ ptr ๊ฐ๋ง 0์ผ๋ก ๋ณ๊ฒฝํด์ฃผ๋ฉด ๋จ
- capacity() : ์คํ์ ์ฉ๋ max๊ฐ ๋ฐํ
- size() : ์คํ์ ํ์ฌ ๋ฐ์ดํฐ ์ ptr์ ๋ฐํ
- isEmpty() : ์คํ์ด ๋น์ด์๋์ง ํ์ธ. ๋น์ด์๋ค๋ฉด true, ์๋๋ฉด false
- isFull() : ์คํ์ด ๊ฐ๋ ์ฐผ๋์ง ํ์ธ. ๊ฐ๋ ์ฐผ์ผ๋ฉด true, ์๋๋ฉด false