์คํ ์คํจ
์๊ฐ ์ ํ: 0.5 ์ด (์ถ๊ฐ ์๊ฐ ์์)
๋ฉ๋ชจ๋ฆฌ ์ ํ: 256 MB
๋ฌธ์
์ ์๋ฅผ ์ ์ฅํ๋ ์คํ์ ๊ตฌํํ ๋ค์, ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ ๋ช ๋ น์ ์ฒ๋ฆฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๋ช ๋ น์ ์ด ๋ค์ฏ ๊ฐ์ง์ด๋ค.
- push X: ์ ์ X๋ฅผ ์คํ์ ๋ฃ๋ ์ฐ์ฐ์ด๋ค.
- pop: ์คํ์์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ๋นผ๊ณ , ๊ทธ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
- size: ์คํ์ ๋ค์ด์๋ ์ ์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
- empty: ์คํ์ด ๋น์ด์์ผ๋ฉด 1, ์๋๋ฉด 0์ ์ถ๋ ฅํ๋ค.
- top: ์คํ์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค. ๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ์ฃผ์ด์ง๋ ๋ช ๋ น์ ์ N (1 โค N โค 10,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ N๊ฐ์ ์ค์๋ ๋ช ๋ น์ด ํ๋์ฉ ์ฃผ์ด์ง๋ค. ์ฃผ์ด์ง๋ ์ ์๋ 1๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค. ๋ฌธ์ ์ ๋์์์ง ์์ ๋ช ๋ น์ด ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ๋ ์๋ค.
์ถ๋ ฅ
์ถ๋ ฅํด์ผํ๋ ๋ช ๋ น์ด ์ฃผ์ด์ง ๋๋ง๋ค, ํ ์ค์ ํ๋์ฉ ์ถ๋ ฅํ๋ค.
import java.util.Scanner;
//2021.06.21 10828๋ฒ: ์คํ
//์๊ฐ ์ด๊ณผ (์๊ฐ์ ํ 0.5์ด) -> ๋น ๋ฅธ ์
์ถ๋ ฅ ๊ณต๋ถํ๊ธฐ!! 15552 ๋ฒ ๋ฌธ์ ์ฐธ๊ณ
public class baekjoon10828 {
public static class linkedStack{
private class Node{
int data;
Node link;
}
private Node top=null;
private int count=0;
// push X: ์ ์ X๋ฅผ ์คํ์ ๋ฃ๋ ์ฐ์ฐ์ด๋ค.
public void push(int item) {//top๊ณผ newNode ๊ฐ์ง๊ณ ํ๊ธฐ
Node newNode=new Node();
newNode.data=item;
newNode.link=top;
top=newNode;
count++;
}
//pop: ์คํ์์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ๋นผ๊ณ , ๊ทธ ์๋ฅผ ์ถ๋ ฅํ๋ค.
//๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
public int pop() {//top๋ง ๊ฐ์ง๊ณ ํ๊ธฐ
int data;
if(isEmpty()==0) {
data=top.data;
top=top.link;
count--;
}
else
data=-1;
return data;
}
//empty: ์คํ์ด ๋น์ด์์ผ๋ฉด 1, ์๋๋ฉด 0์ ์ถ๋ ฅํ๋ค.
public int isEmpty() {
if(top==null)//๋น์ด์์ผ๋ฉด
return 1;
return 0;
}
//size: ์คํ์ ๋ค์ด์๋ ์ ์์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
public int getSize() {
return count;
}
//top: ์คํ์ ๊ฐ์ฅ ์์ ์๋ ์ ์๋ฅผ ์ถ๋ ฅํ๋ค.
//๋ง์ฝ ์คํ์ ๋ค์ด์๋ ์ ์๊ฐ ์๋ ๊ฒฝ์ฐ์๋ -1์ ์ถ๋ ฅํ๋ค.
public int getTop(){
if(isEmpty()==1)
return -1;
return top.data;
}
}
//ํ๋ก๊ทธ๋จ ์คํ
public static void main(String[] args) {
Scanner scanner=new Scanner(System.in);
linkedStack stack=new linkedStack();
int instructionNum;
instructionNum=scanner.nextInt();
for(int i=0; i<instructionNum;i++) {
String instruction=scanner.next();
switch(instruction){
case "push":
int item=scanner.nextInt();
stack.push(item);
break;
case "pop":
System.out.println(stack.pop());
break;
case "size":
System.out.println(stack.getSize());
break;
case "empty":
System.out.println(stack.isEmpty());
break;
case "top":
System.out.println(stack.getTop());
break;
}
}
scanner.close();
}
}
- ์ ์๋ฅผ ์ ์ฅํ๋ ์คํ ๊ตฌํ: ์ฐ๊ฒฐ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ ๊ตฌํ
- static ํด๋์ค๋ก ์คํ ๊ตฌํ
- switch๋ฌธ์ ์ฌ์ฉํ์ฌ ์ ๋ ฅ๋ฐ์ ๋ฌธ์์ด๋ณ ๊ฐ ๋ฉ์๋ ํธ์ถ
- ํ๋ฆฐ ๋ถ๋ถ: ์๊ฐ ์ด๊ณผ
1. ์คํ (stack)

- ์ ์๋ฅผ ์๋ฏ์ด ์๋ฃ๋ฅผ ์ฐจ๊ณก์ฐจ๊ณก ์์์ฌ๋ฆฐ ํํ์ ์๋ฃ๊ตฌ์กฐ
- ํ์ ์ ์ถ ๊ตฌ์กฐ(LIFO: Last-In First-out) โ top ์์๋ง ์ ์ฅ๋ ์์์ ์ ๊ทผํ ์ ์๋ค.
- top : ์คํ์ ๊ฐ์ฅ ์์ ๋์ธ ์์๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
- ์คํ์ ์ฐ์ฐ:
- push(s, item) : ์ฝ์ , ์คํ s์ item(์์)์ ์ฝ์ ํ๋ ์ฐ์ฐ
- pop(s) : ์ญ์ , ์คํ s์ top์ ์๋ ์์๋ฅผ ์ญ์ ํ์ฌ ๋ฆฌํดํ๋ ์ฐ์ฐ
- + ์ถ๊ฐ ์ฐ์ฐ - peek(s) : ์คํ s์ top์ ์๋ ์์๋ฅผ ์ญ์ ํ์ง ์๊ณ ๋ฆฌํดํ๋ ์ฐ์ฐ
- ์คํ์ ๊ตฌํ:
- ์์ฐจ ์๋ฃ๊ตฌ์กฐ - 1์ฐจ์ ๋ฐฐ์ด์ ์ด์ฉํ์ฌ ๊ตฌํ. ๋จ์ ) ๊ณต๊ฐ ๋ญ๋น ๊ฐ๋ฅ์ฑ ๋์, ํฌ๊ธฐ ๋ณ๊ฒฝ ๋นํจ์จ์
- ์ฐ๊ฒฐ ์๋ฃ๊ตฌ์กฐ - ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ. ์คํ์ ์์ ํ๋ = ๋ ธ๋ ํ๋
1.1 ์คํ์ ๊ตฌํ - ์ฐ๊ฒฐ ์๋ฃ๊ตฌ์กฐ

- ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ๋ฅผ ์ด์ฉํ์ฌ ๊ตฌํ
- ์คํ ์์ ํ๋ = ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ๋ ธํธ ํ๋
- ์์ฐจ ์๋ฃ๊ตฌ์กฐ์ ๋จ์ ๊ทน๋ณต ๊ฐ๋ฅ
- ๋ณ์ top : ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ ์ฒซ๋ฒ์งธ ๋
ธ๋ ๊ฐ๋ฆฌํค๋ ๋ณ์
- empty ์ํ : top == null (์ด๊ธฐ์ํ)
- full ์ํ : ์ ์๋์ง ์์
- ์ฐ๊ฒฐ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ด์ฉํ ์คํ ์ฐ์ฐ
- push(s, item) : ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์คํ s์ ๊ฐ์ฅ ์์ data ๊ฐ์ผ๋ก item์ ๊ฐ์ง ๋ ธ๋ ์ฝ์ . <์์์๊ฐ O(1)>
- pop(s) : ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ ์คํ s์ ์ฒซ๋ฒ์งธ ๋ ธ๋ ์ญ์ . ์ฆ, top์ด ๊ฐ๋ฆฌํค๊ณ ์๋ ๋ ธ๋ ์ญ์ ํ ๋ฆฌํด
public class MyLinkedStack {
private Node top =null //๊ณต๋ฐฑ ์คํ ์์ฑ
private class Node{//Nodeํด๋์ค
char data;
Node link
}
public boolean isEmpty(){
if(top == null) //empty ์ํ : top == null
return true;
else
return false;
}
public void push(char item){//top๊ณผ item๋ง ์ด์ฉํ์ฌ ์คํ์ ์ฝ์
Node newNode= new Node();//์ฝ์
ํ item๋ฅผ ์ ์ฅํ ์ ๋
ธ๋ ์์ฑ
newNode.data=item; //์ ๋
ธ๋์ data์ item ์ ์ฅ
newNode.link=top;
/*
๋ง์ฝ ๊ณต๋ฐฑ ์คํ์ผ ๊ฒฝ์ฐ top์ null,
์ ๋
ธ๋๋ ํด๋น ์คํ์ ์ฒซ๋ฒ์งธ ๋
ธ๋์ด์ ๋ง์ง๋ง ๋
ธ๋์ด๋ฏ๋ก link์ null ์ ์ฅํด์ผ ํจ
๊ณต๋ฐฑ ์คํ์ด ์๋ ๊ฒฝ์ฐ top์ ์ด์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํด
์ ๋
ธ๋๋ ์ด์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌ์ผ์ผ ํ๋ฏ๋ก top,
์ฆ ์ด์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํค๋ link๋ฅผ ๋ฐ์ ์ด์ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํจ๋ค.
*/
top=newNode; //top์ด ์ ๋
ธ๋, ์ฆ ์ฒซ๋ฒ์งธ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ํ๋ค.
}
public char pop(){ //top์ ์ฌ์ฉํ์ฌ ์ญ์ ํ ๋ฆฌํด
if(isEmpty())
์์ธ ๋ฐ์;
else{
char item=top.data; //top์ด ๊ฐ๋ฆฌํค๋ ๋
ธ๋์ data๋ฅผ ๋ฐ๋ก ์ ์ฅํ๋ค.
top=top.link; //top์ด ์ฒซ๋ฒ์งธ ๋
ธ๋์ link, ์ฆ ๋๋ฒ์งธ ๋
ธ๋๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ํ๋ค.
//์ฐ๊ฒฐ ๋ฆฌ์คํธ์์ ๋
ธ๋๋ ๋ค๋ฅธ ๋
ธ๋์์ ์ฐ๊ฒฐ์ด ๋์ด์ง๋ฉด ํด๋น ๋
ธ๋๋ ์ญ์ ๋๋ค.
return item;
}
}
}
๊ณต๋ถ ์๋ฃ
์๋ฐ๋ก ๋ฐฐ์ฐ๋ ์ฌ์ด ์๋ฃ๊ตฌ์กฐ, ์ ๊ณต ์์
'์ฝ๋ฉ ํ ์คํธ > ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ / java ] 15552 - ๋น ๋ฅธ A+B ( BufferedReader ) (0) | 2021.06.30 |
---|---|
[ ๋ฐฑ์ค ์๊ณ ๋ฆฌ์ฆ / Java ] 1152 - ๋จ์ด์ ๊ฐ์ (0) | 2021.06.20 |