Stack
์ค๋ stack์ ๋ํด ๋ฐฐ์ฐ๋ฉด์, ์ ์์ ์ฌ์ฉ๋ฒ์ ๋ํด ๊ฐ๋จํ ์ ๋ฆฌํด๋ณด๊ณ ๋ฌธ์ ํ์ด๋ฅผ ์ฌ๋ฆฌ๋ ค๊ณ ํ๋ค.

๋จผ์ , Stack์ ์ด๋ฆ์์๋ ๋๊ปด์ง๋ ๊ฒ์ฒ๋ผ ์์ ์ฌ๋ฆฌ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค.
์ฝ๊ฒ ์ดํดํ๋ ค๋ฉด, ์ ์๋ฅผ ์์์ฌ๋ฆฐ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๊ทธ๋ฆผ์์ ๋ณด๋ ๊ฒ๊ณผ ๊ฐ์ด ๋ฐ๋ถ๋ถ์ด ๋งํ์๋ ์์์ ์ ์๋ฅผ ์์์ฌ๋ฆฌ๋ฉด ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ ๋๋ ๊ฐ์ฅ ์์ ๋ฃ๊ณ ๋ฐ์ดํฐ๋ฅผ ๋นผ๋ผ๋๋ ๊ฐ์ฅ ์์์ ๋นผ๊ฒ ๋๋ค.
์ด๋ฌํ ์๋ฃ๊ตฌ์กฐ๋ฅผ LIFO(Last In First Out)์ด๋ผ๊ณ ํ๋ค.
์ด๋ฐ Stack๊ณผ ์์ฃผ ๋น๊ต๋๋ Queue๋ FIFO ์๋ฃ๊ตฌ์กฐ๋ก, ํฐ๋์ ๋น์ ํด์ ์ดํดํ ์ ์๋ค.
๐ป Stack ์ฌ์ฉ๋ฒ
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
}
}
stack์ java.util.Stack ํด๋์ค๋ฅผ importํ๊ณ Stack์ ์์ ๊ฐ์ด ์ ์ธํด ์ฌ์ฉํ ์ ์๋ค.
๐ Stack ๊ด๋ จ ๋ฉ์๋
๋ฐ์ดํฐ ์ถ๊ฐ, push()
๊ฐ์ฅ ๋จผ์ ,๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ธฐ ์ํด์๋ push() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. push(E e) ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์๋ก์ด ์์๊ฐ์ ๋ฃ์ด์ฃผ๋ฉด, ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๊ฐ ์์นํ๊ฒ ๋๋ค. ์ด๋ ๊ฒ Stack์์ ๊ฐ์ฅ ์์ ์๋ ๋ฐ์ดํฐ๋ฅผ Top์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for(int i = 0; i < 3; i++) {
stack.push(i);
}
}
}
์ ์ฝ๋๋ stack์ 0, 1, 2๋ฅผ ์ฐจ๋ก๋ก ๋ฃ๋ ๋์์ ์ํํ๊ณ ์๋ค.
๋ฐ์ดํฐ ์กฐํ, peek()
๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํด์ฃผ๋ฉด ์ด๋ฅผ ์กฐํํ๋ ๋ฉ์๋ ์ญ์ ํ์ํ๋ค. ์คํ์์๋ peek()์ด๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ Top ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ์ ์๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for(int i = 0; i < 3; i++) {
stack.push(i);
}
System.out.print(stack.peek() + " ");
System.out.print(stack.peek() + " ");
}
}
๊ฒฐ๊ณผ : 4 4
peek()์ ์ฌ์ฉํ๋ฉด, ๊ฐ์ฅ ์(์ต๊ทผ) ๋ฐ์ดํฐ๋ฅผ ์กฐํ๋ง ํ๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ด ์์ฑํ๋ฉด ๋ชจ๋ 4๊ฐ ๋์จ๋ค.
๋ฐ์ดํฐ ๋นผ๋ด๊ธฐ, pop()
๋ฐ์ดํฐ๋ฅผ ๋นผ๋ด๊ธฐ ์ํด์๋ pop()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < 3; i++)
stack.push(i);
while(!stack.isEmpty()) {
System.out.println(stack.pop());
}
}
}
๊ฒฐ๊ณผ : 2 1 0
์์์ ๋์ค๋ isEmpty()๋ stack์ด ๋น์๋์ง ์์๋ฅผ ๊ฐ์ง๊ณ ์๋์ง๋ฅผ ํ์ธํด์ค๋ค. ์์๊ฐ ๋น์ด์๋ค๋ฉด true๋ฅผ ๋ฐํํ๋ค.
๋๋ stack์ด ๋น์ด์์ง ์์ผ๋ฉด ๊ณ์ stack์ ์์๋ฅผ ๋นผ๋ผ ๊ฒ์ด๋ฏ๋ก !stack.isEmpty()๋ฅผ while ๋ฐ๋ณตํด print ํ๋ค.
์ฃผ์ํ ์ ์ stack์ ๊ฒฝ์ฐ ๊ฐ์ฅ ์ต๊ทผ(๋ค)์ ์์๋ฅผ ๋นผ๋ด๊ธฐ ๋๋ฌธ์ ํํ ์๊ฐํ๋ 0 1 2๋ก ์ถ๋ ฅ๋๋๊ฒ ์๋, 2 1 0์ผ๋ก ์ถ๋ ฅ๋๋ค๋ ๊ฒ์ด๋ค ! ์ด์ ๊ด๋ จํด์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ฉด์ ๊ฐ์ ์ตํ๋ณด์
๐ ๋ฌธ์ ํ์ด
ํ๋ก๊ทธ๋๋จธ์ค stack ๋ฌธ์ ๋งํฌ (stack์ผ๋ก ํ์ด๋ณผ ๊ฒ)
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
ํญ์ ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ํ ๋ ๋ฌธ์ ๋ฅผ ๊ฐ์ด ํธ๋ ์ต๊ด์ ๋ค์ฌ์ผ ํ๋ค๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์, ์ด๋ก ๊ณต๋ถ๋ฅผ ํ ๋ค์ ๋ฐ๋ก ์ฐพ์ ํ์ด๋ณด์๋ค. stack ๊ณต๋ถ๋ฅผ ํ๊ณ ์๋ ๋ถ์ด๋ผ๋ฉด ํ์ด๋ฅผ ๋ณด๊ธฐ ์ ์ stack์ ์ฌ์ฉํด ์์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์๊ธฐ๋ฅผ ๊ถ์ฅ ๋๋ฆฐ๋ค.
๋ฌธ์ ์ค๋ช
๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค.
๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค๋ฉด,
arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค.
arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค.
๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์
- ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์
๋ฌธ์ ํ์ด
import java.util.*;
public class Solution {
public int[] solution(int []arr) {
Stack<Integer> stack = new Stack<>();
for(int i : arr) {
if(stack.isEmpty() || i != stack.peek()) {
stack.push(i);
}
}
int[] answer = new int[stack.size()];
for(int i = stack.size() -1; i >= 0; i--) {
answer[i] = stack.pop();
}
return answer;
}
}
1. stack ์ ์ธ ํ arr ๊ธธ์ด๋งํผ foreach๋ฌธ์ ์ฌ์ฉํ๋ค.
- stack์ top ๋ฐ์ดํฐ๊ฐ i(๊ธฐ์กด ๋ฐฐ์ด์์ ๊ฐ์ ธ์จ ๊ฐ)์ ๊ฐ์ง ์๋ค๋ฉด, stack์ i ๊ฐ์ ๋ฃ์ด์ค๋ค.
- ๊ฐ์ฅ ์ฒ์์๋ stack์ด ๋น์ด์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ stack.peek()๋ก ๋น๊ตํ๋ฉด EmptyStackException์ด ๋ฐ์ํ๋ค. ๊ทธ๋ฌ๋๊น ๋น์ด์๋์ง๋ ํจ๊ป ํ์ธ ํด์ค๋ค. => stack.isEmpty()
2. stack์ ํฌ๊ธฐ๋งํผ int ๋ฐฐ์ด์ ์ ์ธํด์ค๋ค.
3. stack์ ํฌ๊ธฐ๋ฅผ n์ด๋ผ๊ณ ๊ฐ์ ํ ๋, index i๋ฅผ n-1๋ถํฐ 0๊น์ง ๋ฐ๋ณตํ๋๋ก ํ์ฌ ์ ๋ต ๋ฐฐ์ด์ stack์์๋ค์ ๋ฃ์ด์ค๋ค.
- stack์ ์ต๊ทผ ๊ฐ๋ถํฐ ๋ถ๋ฌ์ค๊ธฐ ๋๋ฌธ์, index๋ฅผ ์ญ์ผ๋ก ์ค์ ํ์ง ์์ผ๋ฉด ๋ฐฐ์ด์ด ๊ฑฐ๊พธ๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค.
- โญ ์ด ๋ถ๋ถ์ด ๋ฌธ์ ์์ ๊ฐ์ฅ ์ฃผ์ํด์ผ ํ ์ ์ด์ stack์ ์ ์์์ ํต์ฌ์ ์ธ ๋ถ๋ถ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค. โญ
์ถ์ฒ
1. stack, queue ์ด๋ฏธ์ง
https://velog.io/@lsx2003/%EC%8A%A4%ED%83%9DStack-%EA%B5%AC%ED%98%84
[์๋ฃ๊ตฌ์กฐ] Stack
์ด๋ฒ ํฌ์คํ ์์๋ ์๋ฃ๊ตฌ์ข ์ค์์ ์คํ(Stack)์ ๋ํด ์ ๋ฆฌํ๊ฒ ์ต๋๋ค. ์คํ์ Last In First Out ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ์ ํ ์๋ฃ๊ตฌ์กฐ ์ ๋๋ค.
velog.io
'๐ต java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] Scanner์ BufferReader ์ ๋ฆฌํด๋ณด์ (0) | 2024.01.07 |
---|---|
JAVA | ํ์ ๊ณ์ฐ๊ธฐ ์ค์ต - (2) (0) | 2023.09.06 |
JAVA | ํ์ ๊ณ์ฐ๊ธฐ ์ค์ต - (1) (0) | 2023.09.04 |
JAVA | ์ฌ์น ์ฐ์ฐ ๊ณ์ฐ๊ธฐ ์ค์ต - (2) (0) | 2023.08.19 |
JAVA | ์ฌ์น ์ฐ์ฐ ๊ณ์ฐ๊ธฐ ์ค์ต - (1) (0) | 2023.08.15 |
Stack
์ค๋ stack์ ๋ํด ๋ฐฐ์ฐ๋ฉด์, ์ ์์ ์ฌ์ฉ๋ฒ์ ๋ํด ๊ฐ๋จํ ์ ๋ฆฌํด๋ณด๊ณ ๋ฌธ์ ํ์ด๋ฅผ ์ฌ๋ฆฌ๋ ค๊ณ ํ๋ค.

๋จผ์ , Stack์ ์ด๋ฆ์์๋ ๋๊ปด์ง๋ ๊ฒ์ฒ๋ผ ์์ ์ฌ๋ฆฌ๋ ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋งํ๋ค.
์ฝ๊ฒ ์ดํดํ๋ ค๋ฉด, ์ ์๋ฅผ ์์์ฌ๋ฆฐ๋ค๊ณ ์๊ฐํ๋ฉด ๋๋ค. ๊ทธ๋ฆผ์์ ๋ณด๋ ๊ฒ๊ณผ ๊ฐ์ด ๋ฐ๋ถ๋ถ์ด ๋งํ์๋ ์์์ ์ ์๋ฅผ ์์์ฌ๋ฆฌ๋ฉด ์๋ก์ด ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ ๋๋ ๊ฐ์ฅ ์์ ๋ฃ๊ณ ๋ฐ์ดํฐ๋ฅผ ๋นผ๋ผ๋๋ ๊ฐ์ฅ ์์์ ๋นผ๊ฒ ๋๋ค.
์ด๋ฌํ ์๋ฃ๊ตฌ์กฐ๋ฅผ LIFO(Last In First Out)์ด๋ผ๊ณ ํ๋ค.
์ด๋ฐ Stack๊ณผ ์์ฃผ ๋น๊ต๋๋ Queue๋ FIFO ์๋ฃ๊ตฌ์กฐ๋ก, ํฐ๋์ ๋น์ ํด์ ์ดํดํ ์ ์๋ค.
๐ป Stack ์ฌ์ฉ๋ฒ
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
}
}
stack์ java.util.Stack ํด๋์ค๋ฅผ importํ๊ณ Stack์ ์์ ๊ฐ์ด ์ ์ธํด ์ฌ์ฉํ ์ ์๋ค.
๐ Stack ๊ด๋ จ ๋ฉ์๋
๋ฐ์ดํฐ ์ถ๊ฐ, push()
๊ฐ์ฅ ๋จผ์ ,๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํ๊ธฐ ์ํด์๋ push() ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค. push(E e) ๋ฉ์๋๋ฅผ ์ฌ์ฉํด ์๋ก์ด ์์๊ฐ์ ๋ฃ์ด์ฃผ๋ฉด, ๊ฐ์ฅ ์์ ๋ฐ์ดํฐ๊ฐ ์์นํ๊ฒ ๋๋ค. ์ด๋ ๊ฒ Stack์์ ๊ฐ์ฅ ์์ ์๋ ๋ฐ์ดํฐ๋ฅผ Top์ด๋ผ๊ณ ๋ถ๋ฅธ๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for(int i = 0; i < 3; i++) {
stack.push(i);
}
}
}
์ ์ฝ๋๋ stack์ 0, 1, 2๋ฅผ ์ฐจ๋ก๋ก ๋ฃ๋ ๋์์ ์ํํ๊ณ ์๋ค.
๋ฐ์ดํฐ ์กฐํ, peek()
๋ฐ์ดํฐ๋ฅผ ์ถ๊ฐํด์ฃผ๋ฉด ์ด๋ฅผ ์กฐํํ๋ ๋ฉ์๋ ์ญ์ ํ์ํ๋ค. ์คํ์์๋ peek()์ด๋ผ๋ ๋ฉ์๋๋ฅผ ์ฌ์ฉํด์ Top ๋ฐ์ดํฐ๋ฅผ ์กฐํํ ์ ์๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for(int i = 0; i < 3; i++) {
stack.push(i);
}
System.out.print(stack.peek() + " ");
System.out.print(stack.peek() + " ");
}
}
๊ฒฐ๊ณผ : 4 4
peek()์ ์ฌ์ฉํ๋ฉด, ๊ฐ์ฅ ์(์ต๊ทผ) ๋ฐ์ดํฐ๋ฅผ ์กฐํ๋ง ํ๊ธฐ ๋๋ฌธ์ ์์ ๊ฐ์ด ์์ฑํ๋ฉด ๋ชจ๋ 4๊ฐ ๋์จ๋ค.
๋ฐ์ดํฐ ๋นผ๋ด๊ธฐ, pop()
๋ฐ์ดํฐ๋ฅผ ๋นผ๋ด๊ธฐ ์ํด์๋ pop()๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ค.
import java.util.Stack;
public class Stack {
public static void main(String[] args) {
Stack<Integer> stack = new Stack<>();
for (int i = 0; i < 3; i++)
stack.push(i);
while(!stack.isEmpty()) {
System.out.println(stack.pop());
}
}
}
๊ฒฐ๊ณผ : 2 1 0
์์์ ๋์ค๋ isEmpty()๋ stack์ด ๋น์๋์ง ์์๋ฅผ ๊ฐ์ง๊ณ ์๋์ง๋ฅผ ํ์ธํด์ค๋ค. ์์๊ฐ ๋น์ด์๋ค๋ฉด true๋ฅผ ๋ฐํํ๋ค.
๋๋ stack์ด ๋น์ด์์ง ์์ผ๋ฉด ๊ณ์ stack์ ์์๋ฅผ ๋นผ๋ผ ๊ฒ์ด๋ฏ๋ก !stack.isEmpty()๋ฅผ while ๋ฐ๋ณตํด print ํ๋ค.
์ฃผ์ํ ์ ์ stack์ ๊ฒฝ์ฐ ๊ฐ์ฅ ์ต๊ทผ(๋ค)์ ์์๋ฅผ ๋นผ๋ด๊ธฐ ๋๋ฌธ์ ํํ ์๊ฐํ๋ 0 1 2๋ก ์ถ๋ ฅ๋๋๊ฒ ์๋, 2 1 0์ผ๋ก ์ถ๋ ฅ๋๋ค๋ ๊ฒ์ด๋ค ! ์ด์ ๊ด๋ จํด์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ฉด์ ๊ฐ์ ์ตํ๋ณด์
๐ ๋ฌธ์ ํ์ด
ํ๋ก๊ทธ๋๋จธ์ค stack ๋ฌธ์ ๋งํฌ (stack์ผ๋ก ํ์ด๋ณผ ๊ฒ)
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
ํญ์ ์๊ณ ๋ฆฌ์ฆ ๊ณต๋ถ๋ฅผ ํ ๋ ๋ฌธ์ ๋ฅผ ๊ฐ์ด ํธ๋ ์ต๊ด์ ๋ค์ฌ์ผ ํ๋ค๊ณ ์๊ฐํ๊ธฐ ๋๋ฌธ์, ์ด๋ก ๊ณต๋ถ๋ฅผ ํ ๋ค์ ๋ฐ๋ก ์ฐพ์ ํ์ด๋ณด์๋ค. stack ๊ณต๋ถ๋ฅผ ํ๊ณ ์๋ ๋ถ์ด๋ผ๋ฉด ํ์ด๋ฅผ ๋ณด๊ธฐ ์ ์ stack์ ์ฌ์ฉํด ์์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด์๊ธฐ๋ฅผ ๊ถ์ฅ ๋๋ฆฐ๋ค.
๋ฌธ์ ์ค๋ช
๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค.
์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค.
๋จ, ์ ๊ฑฐ๋ ํ ๋จ์ ์๋ค์ ๋ฐํํ ๋๋ ๋ฐฐ์ด arr์ ์์๋ค์ ์์๋ฅผ ์ ์งํด์ผ ํฉ๋๋ค.
์๋ฅผ ๋ค๋ฉด,
arr = [1, 1, 3, 3, 0, 1, 1] ์ด๋ฉด [1, 3, 0, 1] ์ return ํฉ๋๋ค.
arr = [4, 4, 4, 3, 3] ์ด๋ฉด [4, 3] ์ return ํฉ๋๋ค.
๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ์ ๊ฑฐํ๊ณ ๋จ์ ์๋ค์ return ํ๋ solution ํจ์๋ฅผ ์์ฑํด ์ฃผ์ธ์.
์ ํ์ฌํญ
- ๋ฐฐ์ด arr์ ํฌ๊ธฐ : 1,000,000 ์ดํ์ ์์ฐ์
- ๋ฐฐ์ด arr์ ์์์ ํฌ๊ธฐ : 0๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ 9๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์ ์
๋ฌธ์ ํ์ด
import java.util.*;
public class Solution {
public int[] solution(int []arr) {
Stack<Integer> stack = new Stack<>();
for(int i : arr) {
if(stack.isEmpty() || i != stack.peek()) {
stack.push(i);
}
}
int[] answer = new int[stack.size()];
for(int i = stack.size() -1; i >= 0; i--) {
answer[i] = stack.pop();
}
return answer;
}
}
1. stack ์ ์ธ ํ arr ๊ธธ์ด๋งํผ foreach๋ฌธ์ ์ฌ์ฉํ๋ค.
- stack์ top ๋ฐ์ดํฐ๊ฐ i(๊ธฐ์กด ๋ฐฐ์ด์์ ๊ฐ์ ธ์จ ๊ฐ)์ ๊ฐ์ง ์๋ค๋ฉด, stack์ i ๊ฐ์ ๋ฃ์ด์ค๋ค.
- ๊ฐ์ฅ ์ฒ์์๋ stack์ด ๋น์ด์๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฅ stack.peek()๋ก ๋น๊ตํ๋ฉด EmptyStackException์ด ๋ฐ์ํ๋ค. ๊ทธ๋ฌ๋๊น ๋น์ด์๋์ง๋ ํจ๊ป ํ์ธ ํด์ค๋ค. => stack.isEmpty()
2. stack์ ํฌ๊ธฐ๋งํผ int ๋ฐฐ์ด์ ์ ์ธํด์ค๋ค.
3. stack์ ํฌ๊ธฐ๋ฅผ n์ด๋ผ๊ณ ๊ฐ์ ํ ๋, index i๋ฅผ n-1๋ถํฐ 0๊น์ง ๋ฐ๋ณตํ๋๋ก ํ์ฌ ์ ๋ต ๋ฐฐ์ด์ stack์์๋ค์ ๋ฃ์ด์ค๋ค.
- stack์ ์ต๊ทผ ๊ฐ๋ถํฐ ๋ถ๋ฌ์ค๊ธฐ ๋๋ฌธ์, index๋ฅผ ์ญ์ผ๋ก ์ค์ ํ์ง ์์ผ๋ฉด ๋ฐฐ์ด์ด ๊ฑฐ๊พธ๋ก ๋ค์ด๊ฐ๊ฒ ๋๋ค.
- โญ ์ด ๋ถ๋ถ์ด ๋ฌธ์ ์์ ๊ฐ์ฅ ์ฃผ์ํด์ผ ํ ์ ์ด์ stack์ ์ ์์์ ํต์ฌ์ ์ธ ๋ถ๋ถ์ด๋ผ๊ณ ๋ณผ ์ ์๋ค. โญ
์ถ์ฒ
1. stack, queue ์ด๋ฏธ์ง
https://velog.io/@lsx2003/%EC%8A%A4%ED%83%9DStack-%EA%B5%AC%ED%98%84
[์๋ฃ๊ตฌ์กฐ] Stack
์ด๋ฒ ํฌ์คํ ์์๋ ์๋ฃ๊ตฌ์ข ์ค์์ ์คํ(Stack)์ ๋ํด ์ ๋ฆฌํ๊ฒ ์ต๋๋ค. ์คํ์ Last In First Out ๊ตฌ์กฐ๋ฅผ ๊ฐ์ง๋ ์ ํ ์๋ฃ๊ตฌ์กฐ ์ ๋๋ค.
velog.io
'๐ต java' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[JAVA] Scanner์ BufferReader ์ ๋ฆฌํด๋ณด์ (0) | 2024.01.07 |
---|---|
JAVA | ํ์ ๊ณ์ฐ๊ธฐ ์ค์ต - (2) (0) | 2023.09.06 |
JAVA | ํ์ ๊ณ์ฐ๊ธฐ ์ค์ต - (1) (0) | 2023.09.04 |
JAVA | ์ฌ์น ์ฐ์ฐ ๊ณ์ฐ๊ธฐ ์ค์ต - (2) (0) | 2023.08.19 |
JAVA | ์ฌ์น ์ฐ์ฐ ๊ณ์ฐ๊ธฐ ์ค์ต - (1) (0) | 2023.08.15 |