๐์คํ : ํ์ ์ ์ถ(Last In First Out, LIFO) ๋ฐฉ์์ ๋ฐ๋ฅด๋ ์๋ฃ๊ตฌ์กฐ๋ก, ๊ฐ์ฅ ๋์ค์ ์ฝ์ ๋ ๋ฐ์ดํฐ๊ฐ ๊ฐ์ฅ ๋จผ์ ๊บผ๋ด์ง๋ ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค.
์คํ ๊ตฌํ
- Deque<E>๋ฅผ ์คํ์ฒ๋ผ ์ฌ์ฉ
Deque<Integer> stack = new ArrayDeque<>();
- Stack<E> ์ฌ์ฉ
Stack<Integer> stack = new Stack<>();
๊ธฐ๋ณธ ๋ฉ์๋
- push(E item) : ์คํ์ ๋งจ ์์ ์์๋ฅผ ์ถ๊ฐ
- pop() : ์คํ์ ๋งจ ์์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ๊ณ ๋ฐํ
- peek() : ์คํ์ ๋งจ ์์ ์๋ ์์๋ฅผ ์ ๊ฑฐํ์ง ์๊ณ ๋ฐํ
- isEmpty() : ์คํ์ด ๋น์ด ์๋์ง ์ฌ๋ถ๋ฅผ ํ์ธ
- size() : ์คํ ์์ ์์ ๊ฐ์ ๋ฐํ
์ฝ๋ฉ ํ ์คํธ ๋น์ถ ์ ํ
๊ดํธ ์ ํจ์ฑ ๊ฒ์ฌ
: "๋ค์ํ ์ ํ์ ๊ดํธ (), {}, [] ๊ฐ ํฌํจ๋ ๋ฌธ์์ด์์ ์ฌ๋ฐ๋ฅด๊ฒ ๊ดํธ๊ฐ ์ง์ง์ด์ ธ ์๋๊ฐ? "
- ํ์ด๋ฒ ) ์ฌ๋ ๊ดํธ๋ ์คํ์ ์๊ณ ๋ซ๋ ๊ดํธ๊ฐ ๋์ฌ ๋๋ง๋ค ์คํ์์ ์ง์ด ๋ง๋ ์ฌ๋ ๊ดํธ๋ฅผ ๊บผ๋ธ๋ค.
๐ ์ ํ ์ดํด ์ฝ๋ ๐
public boolean isValid(String s) {
//ArrayDeque<>์ธํฐํ์ด์ค๋ฅผ ํตํด ์คํ ๊ตฌํ
Deque<Character> stack = new ArrayDeque<>();
for (char c : s.toCharArray()) {
// ์ฌ๋ ๊ดํธ -> ์คํ์ ์๊ธฐ
if (c == '(' || c == '{' || c == '[') {
stack.push(c);
}
else {
//์คํ์ด ๋น์ด์์ ๊ฒฝ์ฐ false๊ฐ ๋ฐํ
if (stack.isEmpty()) return false;
//์คํ์ ๋งจ ์์ ์๋ ์์ ์ ๊ฑฐ ํ, open๊ฐ์ ๋ฐํ
char open = stack.pop();
//isMatching๋ฉ์๋ ์ด์ฉํ์ฌ ๋ค๋ฅธ ๊ฒฝ์ฐ false๊ฐ ๋ฐํ
if (!isMatching(open, c)) return false;
}
}
//isEmpty๋ฉ์๋๋ฅผ ์ฌ์ฉํ์ฌ ์คํ์ด ๋น์ด์๋์ง ์ฌ๋ถ ํ์ธ
return stack.isEmpty();
}
//isMatching ๋ฉ์๋ ์ ์: open๊ฐ๊ณผ close๊ฐ์ด ์ง์ ์ด๋ฃจ๋ฉด true, ๊ทธ๋ ์ง ์์ผ๋ฉด false๊ฐ ๋ฐํ
private boolean isMatching(char open, char close) {
return (open == '(' && close == ')') || (open == '{' && close == '}') || (open == '[' && close == ']');
}
2. ์ต์๊ฐ ์คํ ๊ตฌํ
- ๊ธฐ๋ณธ ์คํ ์ธ์ ์ต์๊ฐ์ ์ ์ฅํ๋ ๋ณด์กฐ ์คํ์ ์ฌ์ฉํด์ผ ํ๋ค.
๐ ์ ํ ์ดํด ์ฝ๋ ๐
class MinStack {
//๊ธฐ๋ณธ ์คํ ๊ตฌํ
private Deque<Integer> stack = new ArrayDeque<>();
//์ต์๊ฐ์ ์ ์ฅํ๋ ๋ณด์กฐ ์คํ ๊ตฌํ
private Deque<Integer> minStack = new ArrayDeque<>();
//push ๋ฉ์๋ ์์ฑ
public void push(int x) {
stack.push(x);
//๋ณด์กฐ์คํ์ด ๋น์ด์๊ฑฐ๋, ๋งค๊ฐ๋ณ์ x๊ฐ ๋ณด์กฐ ์คํ ๋งจ ์์ ์์๋ณด๋ค ๊ฐ๊ฑฐ๋ ์์ ๊ฒฝ์ฐ
if (minStack.isEmpty() || x <= minStack.peek()) {
//์คํ์ ์ถ๊ฐ
minStack.push(x);
}
}
//pop ๋ฉ์๋ ์์ฑ
public void pop() {
//๊ธฐ๋ณธ ์คํ์ ๋งจ ์์ ์์ ๊ฐ์ด ๋ณด์กฐ ์คํ์ ๋งจ ์์ ์์๊ฐ๊ณผ ๊ฐ์ ๊ฒฝ์ฐ
if (stack.pop().equals(minStack.peek())) {
//๋ณด์กฐ ์คํ์ ๋งจ ์์ ์์๋ฅผ ์ ๊ฑฐํ๋ค.
minStack.pop();
}
}
//top ๋ฉ์๋ ์์ฑ
public int top() {
//๊ธฐ๋ณธ ์คํ์ ๋งจ ์ ์์ ๋ฐํ
return stack.peek();
}
//getMin() ๋ฉ์๋ ์์ฑ
public int getMin() {
//๋ณด์กฐ ์คํ์ ๋งจ ์ ์์ ๋ฐํ
return minStack.peek();
}
}
์คํ ์ฌ์ฉ ์ ์ ์ ์ฌํญ
- ์๊ฐ ๋ณต์ก๋
- ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ : ์ฌ๊ทํจ์์ ๊น์ด๊ฐ ๋๋ฌด ๊น์ ๊ฒฝ์ฐ ์คํ ์ค๋ฒํ๋ก์ฐ ๋ฐ์.
→ ์ฌ๊ท๋ฅผ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋์ฒดํด์ผ ํ๋ค - Deque ์ฌ์ฉ ๊ถ์ฅ : Stack๋ ๋๊ธฐํ ๋ฌธ์ ๋ก ์๋์ ์ผ๋ก ์ฑ๋ฅ์ด ์ข์ง ์๋ค.
'Coding Test > Data Structure & algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๊ณ ๋ฆฌ์ฆ] ์ ๋ ฌ (Sorting) (0) | 2024.09.22 |
---|---|
[์๊ณ ๋ฆฌ์ฆ] ์๊ฐ ๋ณต์ก๋ (Time Complexity) (2) | 2024.09.22 |
[์๊ณ ๋ฆฌ์ฆ] ๊ทธ๋ฆฌ๋(Greedy) (2) | 2024.09.14 |
[์๋ฃ๊ตฌ์กฐ] ํ(Queue) (1) | 2024.09.06 |
[์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋? (0) | 2024.09.06 |