์ด์ ํฌ์คํ
1. [์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ? - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์
https://atoz-develop.tistory.com/entry/entry/์๋ฃ๊ตฌ์กฐ-์๋ฃ๊ตฌ์กฐ๋-๋ฌด์์ธ๊ฐ-์ ๋ฆฌ-๋ฐ-์ฐ์ต๋ฌธ์
2. [์๋ฃ๊ตฌ์กฐ] ๋ฐฐ์ด - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์
https://atoz-develop.tistory.com/entry/์๋ฃ๊ตฌ์กฐ-๋ฐฐ์ด-์ ๋ฆฌ-๋ฐ-์ฐ์ต๋ฌธ์
1. ์คํ(Stack)์ ๊ฐ๋
- ์คํ์ ๊ฐ์ฒด์ ๊ทธ ๊ฐ์ฒด๊ฐ ์ ์ฅ๋๋ ์์๋ฅผ ๊ธฐ์ตํ๋ ๋ฐฉ๋ฒ์ ๊ดํ ์ถ์ ์๋ฃํ์ด๋ค.
- ๊ฐ์ฅ ๋ฆ๊ฒ ์ ๋ ฅ๋ ์๋ฃ๊ฐ ๊ฐ์ฅ ๋จผ์ ์ถ๋ ฅ๋๋ ๊ด๊ณ๋ฅผ ํํํ๋ค.
- LIFO(Last In First Out, ํ์ ์ ์ถ)
- ํ๋์ ์คํ ํฌ์ธํฐ ๋ณ์(์ผ๋ฐ์ ์ผ๋ก top์ผ๋ก ๋ช ๋ช )๋ฅผ ์ฌ์ฉํ๋ค.
- top์ ์คํ์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ์ผ์ด๋๋ ์ง์ ์ ๊ฐ๋ฆฌํจ๋ค.
- ์ฝ์ ์ top์ ์ฆ๊ฐ์ํค๊ณ ์ญ์ ์ ๊ฐ์์ํจ๋ค.
2. ์คํ์ ์ถ์ ์๋ฃํ(ADT)
* Object(๊ฐ์ฒด)
0๊ฐ ์ด์์ ์์๋ฅผ ๊ฐ๋ ์ ํ ์์ ๋ฆฌ์คํธ
* Functions(์ฐ์ฐ)
stack∈Stack, item∈element, maxStackSize∈positive integer์ธ ๋ชจ๋ stack, item, maxStack์ ๋ํ์ฌ ๋ค์๊ณผ ๊ฐ์ ์ฐ์ฐ์ด ์ ์๋๋ค. stack์ 0๊ฐ ์ด์์ ์์๋ฅผ ๊ฐ๋ ์คํ, item์ ์คํ์ ์ฝ์ ๋๋ ์์, maxQueueSize๋ ์คํ์ ์ต๋ ํฌ๊ธฐ๋ฅผ ์ ์ํ๋ ์ ์์ด๋ค.
โ Stack CreateStack(maxStackSize) ::=
์คํ์ ํฌ๊ธฐ๊ฐ maxStackSize์ธ ๋น ์คํ์ ์์ฑํ๊ณ ๋ฐํํ๋ค;
โก Boolean IsFull(stack) ::=
if((stack์ element ๊ฐ์) == maxStackSize))
then { 'TRUE' ๋ฐํ }
else { 'False' ๋ฐํ }
โข Stack Push(stack, item) ::=
if(isFull(stack))
then { 'stackFull' ์ถ๋ ฅ }
else { ์คํ์ ๊ฐ์ฅ ์์ item์ ์ฝ์ ํ๊ณ ์คํ์ ๋ฐํํ๋ค; }
โฃ Boolean isEmpty(stack) ::=
if(stack == CreateStack(maxStackSize))
then { 'TRUE' ๋ฐํ }
else { 'False' ๋ฐํ }
โค Element Pop(stack) ::=
if(isEmpty(stack))
then { 'stackEmpty' ์ถ๋ ฅ }
else { ์คํ์ ๊ฐ์ฅ ์์ ์๋ element๋ฅผ ์ญ์ ํ๊ณ ๋ฐํํ๋ค; }
3. ์คํ ์ฐ์ฐ ์ํ
โ CreateStack(3);
โก Push(stack, 'S');
โข Push(stack, 'T');
โฃ Pop(stack);
โค Push(stack, 'R');
โฅ Push(stack, 'P');
โฆ Push(stack, 'Q');
โง Pop(stack);
4. ๋ฐฐ์ด์ ์ด์ฉํ ์คํ์ ๊ตฌํ
๋ค์์ C์ธ์ด๋ก ๊ตฌํํ intํ ์คํ์ด๋ค.
4-1. ์คํ์ ์์ฑ
1
2
3
4
|
#define STACK_SIZE 5
typedef int element;
element stack(STACK_SIZE);
int top = -1;
|
cs |
1๋ผ์ธ: ์คํ์ ์ฌ์ด์ฆ๋ฅผ ์ ์ํ๋ค.
2๋ผ์ธ: intํ์ ์คํ element์ ์๋ฃํ์ผ๋ก ์ ์ํ๋ค.
3๋ผ์ธ: ์คํ์ ์์ฑํ๋ค.
4๋ผ์ธ: ์คํ์ top์ -1๋ก ์ด๊ธฐํํ์ฌ ๊ณต๋ฐฑ ์ํ๋ก ํ๋ค.
4-2. ์คํ์ ์ญ์ (pop)
1
2
3
4
5
6
7
8
|
element pop(int *top) {
if(*top == -1) {
printf("Stack is Empty\n");
return 0;
}
else return stack[*top--];
}
|
cs |
2~4๋ผ์ธ: ์คํ ๊ณต๋ฐฑ ์ฌ๋ถ ํ์ธ ๋ฐ ์ฒ๋ฆฌ
6๋ผ์ธ: *top์ด ๊ฐ๋ฆฌํค๋ ์์น์ ๊ฐ์ returnํ๊ณ *top์ 1 ๊ฐ์์ํจ๋ค. (์์ ์ค์)
4-3. ์คํ์ ์ฝ์ (push)
1
2
3
4
5
6
7
8
|
void push(int *top, element item) {
if(*top >= STACK_SIZE -1) {
printf("Stack is Full\n");
return;
}
else stack[++*top] = item;
}
|
cs |
2~4๋ผ์ธ: ์คํ full ํ์ธ ๋ฐ ์ฒ๋ฆฌ
6๋ผ์ธ: top์ ์ฃผ์๊ฐ์ 1 ์ฆ๊ฐ์ํค๊ณ top์ด ๊ฐ๋ฆฌํค๋ ์ฃผ์์ item์ ์ ์ฅํ๋ค. (์์ ์ค์)
5. ์คํ์ ์์ฉ ๋ถ์ผ
- ์คํ์ ์๋ ๊ธธ์ ๋๋์ ๊ฐ๋ ๊ฒฝ์ฐ์ ๋ง์ด ์ฌ์ฉ๋๋ค.
- ์์คํ ์คํ(system stack) : ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ณผ ์์ง. ์ฆ ์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ
- ์๋ธ๋ฃจํด ํธ์ถ(subroutine call) ๊ด๋ฆฌ : ์๋ธ๋ฃจํด์ ์ํ์ด ๋๋ ํ์ ๋๋์๊ฐ ํจ์ ์ฃผ์๋ฅผ ์ ์ฅ
- ์์ ๊ณ์ฐ : ์ฐ์ฐ์๋ค ๊ฐ์ ์ฐ์ ์์ ๊ฒฐ์
- ์ธํฐ๋ฝํธ(interrupt) : ํ๋ก๊ทธ๋จ ์ํ ์ค ๋ฐ์๋๋ ์ธํฐ๋ฝํธ์ ์ฒ๋ฆฌ์ ๋๋์๊ฐ ๋ช ๋ น ์ํ ์ง์ ์ ์ฅ
- ์ปดํ์ผ๋ฌ : ๋ฌธ๋ฒ ๊ฒ์ฌ
- ์ํ ํธ์ถ(recursion call) ๊ด๋ฆฌ : ์ํ ํธ์ถ์ด ๋๋๊ณ ๋๋์๊ฐ ์คํ ์ฃผ์ ์ ์ฅ
6. ์์์ ์ ์/ํ์/์ค์ ํํ
์ฐ์ฐ์๋ค ๊ฐ์ ์ฐ์ ์์๋ฅผ ๊ฒฐ์ ํ์ฌ ์์์ ๊ณ์ฐํ๋๋ฐ ์คํ์ด ์ฌ์ฉ๋๋ค. ํ๋ก๊ทธ๋จ์์ ์์์ ์ ๋ ฅ๋ฐ๊ธฐ ์ํด ์ฌ์ฉ๋ ์ ์๋ ์์์ ํ๊ธฐ ๋ฐฉ๋ฒ์ ์ฐ์ฐ์์ ํผ์ฐ์ฐ์์ ์์น์ ๋ฐ๋ผ ๋ค์์ ์ธ ๊ฐ์ง๊ฐ ์๋ค.
- ์ค์ ํ๊ธฐ๋ฒ(infix notation): ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์์ ์ฌ์ด์ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ; A+B
- ์ ์ ํ๊ธฐ๋ฒ(prefix notation, polish notation): ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์์ ์์ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ; +AB
- ํ์ ํ๊ธฐ๋ฒ(postfix notation): ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์์ ๋ค์ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ; AB+
ํ์ ํ๊ธฐ๋ฒ์ด ์ปดํจํฐ๋ก ์ฒ๋ฆฌ๋๊ธฐ์ ํจ์จ์ ์ธ ํ๊ธฐ๋ฒ์ด๋ค.
์ค์ ํ๊ธฐ๋ฒ์ ์ ์, ํ์ ํ๊ธฐ๋ฒ์ผ๋ก ๋ณํํ๋ ๋ฐฉ๋ฒ์ผ๋ก๋ ์คํ์ ์ด์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ํธ๋ฆฌ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ด ์๋ค. ๋ค์์์ ์ ์ ํ๊ธฐ๋ฒ์ผ๋ก์ ๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ํธ๋ฆฌ๋ฅผ, ํ์ ํ๊ธฐ๋ฒ์ผ๋ก์ ๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ์คํ๊ณผ ํธ๋ฆฌ๋ฅผ ์ด์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ค๋ฃฐ๊ฒ์ด๋ค.
๋ณํํ ์ : A/B+C
6-1. ์ค์ ํ๊ธฐ๋ฒ -> ์ ์ ํ๊ธฐ๋ฒ ๋ณํ
โ ์ฃผ์ด์ง ์์ ํธ๋ฆฌ๋ก ๊ทธ๋ฆฐ๋ค.
๋ฆฌํ ๋ ธ๋์ ํผ์ฐ์ฐ์ A, B, C๋ฅผ, ๋ถ๋ชจ ๋ ธ๋์๋ ์ฐ์ฐ์๋ฅผ ์ฐ์ ์์ ์์๋ก ์์นํ๋๋ก ๊ทธ๋ฆฐ๋ค. ์ ๊ทธ๋ฆผ์ ๋ณด๋ฉด ์ฝ๊ฒ ์ดํดํ ์ ์์ ๊ฒ์ด๋ค.
โก ํธ๋ฆฌ๋ฅผ ์ ์(preorder) ์ํํ๋ฉฐ ๊ฐ์ ์ถ๋ ฅํ๋ค.
์ ์ ์ํ๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด root → left → right ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ ํธ๋ฆฌ๋ฅผ ์ ์ ์ํํ๋ฉด ์ถ๋ ฅ ์์๋ +/ABC๊ฐ ๋๋ฉฐ ์ด๊ฒ์ด ์ฃผ์ด์ง ์ A/B+C์ ์ ์ ํ๊ธฐ๋ฒ์ผ๋ก ํํ๋ ๊ฒฐ๊ณผ์ด๋ค.
[์ค์ ํ๊ธฐ๋ฒ] A/B+C → [์ ์ ํ๊ธฐ๋ฒ] +/ABC
6-2. ์ค์ ํ๊ธฐ๋ฒ -> ํ์ ํ๊ธฐ๋ฒ ๋ณํ
6-2-1. ํธ๋ฆฌ ์ด์ฉ
โ ์ฃผ์ด์ง ์์ ํธ๋ฆฌ๋ก ๊ทธ๋ฆฐ๋ค.
๋์ผํ๊ฒ ํธ๋ฆฌ๋ฅผ ๊ทธ๋ฆฐ๋ค.
โก ํธ๋ฆฌ๋ฅผ ํ์(postorder) ์ํํ๋ฉฐ ๊ฐ์ ์ถ๋ ฅํ๋ค.
ํ์ ์ํ๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด left → right → root ์์ผ๋ก ๋ฐฉ๋ฌธํ๋ ๋ฐฉ๋ฒ์ด๋ค. ์ ํธ๋ฆฌ๋ฅผ ํ์ ์ํํ๋ฉด ์ถ๋ ฅ ์์๋ AB/C+๊ฐ ๋๋ฉฐ ์ด๊ฒ์ด ์ฃผ์ด์ง ์ A/B+C์ ํ์ ํ๊ธฐ๋ฒ์ผ๋ก ํํ๋ ๊ฒฐ๊ณผ์ด๋ค.
[์ค์ ํ๊ธฐ๋ฒ] A/B+C → [์ ์ ํ๊ธฐ๋ฒ] AB/C+
6-2-2. ์คํ ์ด์ฉ
โ ์ฃผ์ด์ง ์์ ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ ๋ฐฉํฅ์ผ๋ก ์ฝ๋๋ค.
โก ํผ์ฐ์ฐ์๋ ์คํ์ ์ ์ฅํ์ง ์๊ณ ๋ฐ๋ก ์ถ๋ ฅ์ํจ๋ค.
โข ์ฐ์ฐ์๋ ์คํ์ ์ ์ฅํ๋, ๋ค์์ ๊ท์น์ ๋ฐ๋ฅธ๋ค.
- ์๋ก ์ ๋ ฅํ ์ฐ์ฐ์(A)์ ์คํ์ ๊ฐ์ฅ ์์ ์ ์ฅ๋์ด ์๋ ์ฐ์ฐ์(B)์ ์ฐ์ ์์๋ฅผ ๋น๊ตํ๋ค.
- B๊ฐ A์ ์ฐ์ ์์๋ณด๋ค ๋๊ฑฐ๋ ๊ฐ์ผ๋ฉด B๋ฅผ ์ญ์ ํ๊ณ ์ถ๋ ฅํ๋ค.
- A๊ฐ B๋ณด๋ค ์ฐ์ ์์๊ฐ ๋์ ๊ฒฝ์ฐ์๋ง ๋ฐ๋ก ์คํ์ ์ ์ฅํ๋ค.
๋ค์์ ์ฃผ์ด์ง ์ค์ ํ๊ธฐ์ A/B+C๋ฅผ ์คํ์ ์ด์ฉํด ํ์ ํ๊ธฐ์์ผ๋ก ๋ณํํ๋ ๊ณผ์ ์ด๋ค.
โ ์ผ์ชฝ์์๋ถํฐ ์ฝ์ด ์ฒซ ๋ฒ์งธ ์
๋ ฅ๊ฐ(ํ ํฐ)์ 'A'์ด๋ค. ํผ์ฐ์ฐ์๋ ์คํ์ ์ ์ฅํ์ง ์๊ณ ๋ฐ๋ก ์ถ๋ ฅํ๋ค.
โก ์ฐ์ฐ์ '/'๋ ์คํ์ ์ ์ฅํ๋ค. ์คํ์ด ๋น์์ผ๋ฏ๋ก ๋น๊ตํ ์ฐ์ฐ์๊ฐ ์๋ค.
โข ํผ์ฐ์ฐ์ 'B'๋ ์คํ์ ์ ์ฅํ์ง ์๊ณ ๋ฐ๋ก ์ถ๋ ฅํ๋ค.
โฃ ์ฐ์ฐ์ '+'๋ ์คํ์ ๊ฐ์ฅ ์์ ์ ์ฅ๋ ์ฐ์ฐ์ '/'๋ณด๋ค ์ฐ์ ์์๊ฐ ๋ฎ์ผ๋ฏ๋ก '/'๋ฅผ ์ญ์ , ์ถ๋ ฅํ๊ณ '+'๋ฅผ ์ ์ฅํ๋ค.
โค ์ฐ์ฐ์ 'C'๋ ์คํ์ ์ ์ฅํ์ง ์๊ณ ๋ฐ๋ก ์ถ๋ ฅํ๋ค.
โฅ ๋ ์ด์ ์
๋ ฅ๊ฐ์ด ์์ผ๋ฏ๋ก ์คํ์ ์ฐจ๋ก๋ก ์ญ์ , ์ถ๋ ฅํ๋ค.
6-3. ํ์ ํ๊ธฐ์์ ๊ณ์ฐ ์๊ณ ๋ฆฌ์ฆ ๊ตฌํ(C)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
element evalPostfix(char *exp) {
int oper1, oper2, value, i=0;
int length = strlen(exp);
char symbol;
top = -1;
for(i=0; i<length; i++) {
symbol = exp[i];
if(symbol != '+' && symbol != '-' && symbol != '*' && symbol != '/') {
value = symbol - '0';
push(value);
}
else {
oper2 = pop();
oper1 = pop();
switch(symbol) {
case '+': push(oper1 + oper2); break;
case '-': push(oper1 - oper2); break;
case '*': push(oper1 * oper2); break;
case '/': push(oper1 / oper2); break;
}
}
}
return pop();
}
|
cs |
1๋ผ์ธ: element evalPostfix(char *exp)
์คํ์ ์ฌ์ฉํด ํ์ ํ๊ธฐ์์ ๊ณ์ฐํ๋ ํจ์๋ฅผ evalPostfix๋ผ๊ณ ์ ์ํ๋ค. ์์ ์คํ์ ์์ฑ์์ typedef int element;๋ก ์ ์ํ ์คํ element ์๋ฃํ์ ๋ฐํํ๋ค. charํ ํฌ์ธํฐ ๋งค๊ฐ๋ณ์๋ก ์์์ด ์ ์ฅ๋ ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ exp๋ฅผ ์ ๋ฌ๋ฐ๋๋ค. ๊ณ์ฐํ ํ๊ธฐ ํ๊ธฐ์์ 369*+๋ผ๊ณ ๊ฐ์ ํ๋ค.
2๋ผ์ธ: int oper1, oper2, value, i=0;
oper1, oper2 : ํผ์ฐ์ฐ์
value : ํ์ ํ๊ธฐ์์์ charํ์ผ๋ก ์ ์ฅ๋ ์ซ์๋ฅผ intํ์ผ๋ก ๋ณํํ์ฌ ์ ์ฅ
i : for๋ฌธ
3๋ผ์ธ: int length = strlen(exp);
charํ ํฌ์ธํฐ ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ฐ์ ํ์ํ๊ธฐ์ ๋ฐฐ์ด์ ๊ธธ์ด ์ ์ฅํ๋ค. ๋ฐฐ์ด์ ๊ธธ์ด๋งํผ ๋ฐ๋ณต ์ํํ๊ธฐ ์ํจ์ด๋ค. ํ์ฌ ์์ด '369*-'์ด๋ฏ๋ก length์ 5๊ฐ ์ ์ฅ๋๋ค.
4๋ผ์ธ: char symbol;
๋ฐฐ์ด์ ํ๋์ฉ ์ฝ์ด ์ ์ฅํ ๋ณ์
5๋ผ์ธ: top = -1;
top ์ด๊ธฐํ
8๋ผ์ธ: symbol = exp[i];
9๋ผ์ธ: if(symbol != '+' && symbol != '-' && symbol != '*' && symbol != '/')
symbol์ด ์ฐ์ฐ์์ธ์ง ํ์ธ
10๋ผ์ธ: value = symbol - '0';
์ฐ์ฐ์์ด๋ฉด char๋ฅผ int๋ก ํ๋ณํํ๊ธฐ ์ํด '0'์ ๋บ ๊ฐ์ ์ ์ฅ
11๋ผ์ธ: push(value);
์ฐ์ฐ์์ด๋ฉด ์คํ์ ์ ์ฅ
14~15๋ผ์ธ: oper2 = pop(); oper1 = pop();
symbol์ด ์ฐ์ฐ์์ด๋ฉด ์คํ์ ์ ์ฅ๋ผ์๋ ํผ์ฐ์ฐ์๋ฅผ ๊บผ๋ด์ ์ ์ฅ
16~20๋ผ์ธ: switch(symbol)...
symbol์ด ์ฐ์ฐ์์ด๋ฉด ํด๋นํ๋ ์ฐ์ฐ ์ํํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ์คํ์ ์ ์ฅ
7๋ผ์ธ: for(i=0; i<length; i++)
25๋ผ์ธ: return pop();
i๊ฐ 5๊ฐ ๋๋ฉด ๋ฐ๋ณต๋ฌธ์ ์ข ๋ฃํ๊ณ ์คํ์ ์ ์ฅ๋์ด ์๋ ๊ฒฐ๊ณผ๊ฐ์ popํ์ฌ ๋ฐํํ๊ณ ํ์ ํ๊ธฐ์ ๊ณ์ฐ ํจ์๋ฅผ ์ข ๋ฃํ๋ค.
ํ์ ํ๊ธฐ์ 369*+์ ๊ณ์ฐ ๊ฒฐ๊ณผ๋ 57์ด๋ค.
7. ์ฐ์ต๋ฌธ์
1. A*B+C๋ฅผ ํ์ ํ๊ธฐ์์ผ๋ก ๋ํ๋ธ ๊ฒ์?
โ AB*C+
โก ABC*+
โข AC*B+
โฃ AC+B*
2. ์คํ์ ์์ฉ๋ถ์ผ๊ฐ ์๋๊ฒ์?
โ ์์คํ ์คํ
โก ์๋ธ๋ฃจํด ํธ์ถ
โข ์์ ์ค์ผ์ค๋ง
โฃ ์์์ ๊ณ์ฐ
3. ๋ค์ ๋ฌธ์ฅ์ ์ณ๊ณ ๊ทธ๋ฆ์ ๊ฒฐ์ ํ์์ค. (O, X)
์คํ์ ์ถ์ ์๋ฃํ์์ ์ ์๋ ์ฐ์ฐ์ ์์คํ ๊ฐ๋ฐ์์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ์ ์๋๊ณ ๊ตฌํ๋ ์ ์๊ณ , ์ปดํ์ผ๋ฌ์ ์ค๊ณ์์ ๋ฐ๋ผ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ค๋ฅด๊ฒ ์ ๊ณต๋ ์ ์๋ค.
4. ๋ค์ ์ค ์คํ์ ์์ฉ์ ๋ํ ์ค๋ช ์ด ์๋๊ฒ์?
โ ์ค์์ฒ๋ฆฌ ์ฅ์น ํ ๋น์ ์ํ RR ๊ธฐ๋ฒ
โก ์๋ธ๋ฃจํด์ ์ํ์ด ๋๋ ํ์ ๋๋์๊ฐ ํจ์ ์ฃผ์ ์ ์ฅ
โข ํ๋ก๊ทธ๋จ์์ ์ฌ์ฉ๋๋ ๋ณ์๋ค์ ์๋ช ์ฃผ๊ธฐ ๊ด๋ฆฌ
โฃ ์ฐ์ฐ์๋ค ๊ฐ์ ์ฐ์ ์์์ ์ํด ๊ณ์ฐ ์์๊ฐ ๊ฒฐ์ ๋๋ ์์ ๊ณ์ฐ
5. ๋ค์์ ์คํ์ ์ฐ์ฐ๋ค์ด๋ค. โฃ๋ฅผ ์ํํ ๊ฒฐ๊ณผ๋ ๋ฌด์์ธ๊ฐ?
6. ๋ค์ ์ค๋ช ์ค ๊ฐ์ฅ ํ๋ฆฐ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
โ ์คํ์ ์๋ฃ์ ์ฝ์ ๊ณผ ์ญ์ ๊ฐ ๊ฐ์ ๋ณ์๋ฅผ ํตํด ์ ์ด๋๋ค.
โก ์คํ์ ๊ฐ์ฒด์ ๊ฐ์ฒด๊ฐ ์ ์ฅ๋๋ ์์๋ฅผ ๊ธฐ์ตํ๋ ๋ฐฉ๋ฒ์ ๊ดํ ์ถ์์๋ฃํ์ด๋ค.
โข ์คํ์ ํฌ๊ธฐ๋ ๊ฐ๋ณ์ ์ด๋ค.
โฃ ํ์ ํ๊ธฐ์์ ์ฐ์ฐ์๋ฅผ ํผ์ฐ์ฐ์์ ๋ค์ ํ๊ธฐํ๋ ๋ฐฉ๋ฒ์ด๋ค.
7. ๋ค์์ ์คํ์ ์ฐ์ฐ๋ค์ด๋ค. โฅ์ ์ํํ ๊ฒฐ๊ณผ๋ ๋ฌด์์ธ๊ฐ?
8. A+B+C*D๋ฅผ ์ ์ ํ๊ธฐ์์ผ๋ก ๋ํ๋ธ ๊ฒ์?
โ ++AB*CD
โก ABCD++*
โข ++*ABCD
โฃ AB+B+C*
9. ๋ค์์ ์คํ์ ๋ํ ์ฐ์ฐ์ด๋ค. โง ์ฐ์ฐ์ ์ํํ ํ์ ์คํ์ ๋ชจ์ต์ ๋ฌด์์ธ๊ฐ?
10. ๋ค์์ ๋ฐฐ์ด์ ์ด์ฉํด ์คํ์ ๊ตฌํํ๊ณ ์คํ์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ ํ๋ ๊ณผ์ ์ ๋ํ๋ด๋ ์ฝ๋์ด๋ค. [๊ฐ]์ ๋ค์ด๊ฐ ์ฝ๋๋ก ๊ฐ์ฅ ์๋ง์ ๊ฒ์ ๋ฌด์์ธ๊ฐ?
์ ๋ต โผ
1 : โ
2 : โข
3 : O
4 : โ
5 : โก
6 : โข
7 : โฃ
8 : โ
9 : โ
10 : โก
'Computer Science' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[์๋ฃ๊ตฌ์กฐ] ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(singly linked list) - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.20 |
---|---|
[์๋ฃ๊ตฌ์กฐ] ํ - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.20 |
[์๋ฃ๊ตฌ์กฐ] ๋ฐฐ์ด - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (2) | 2019.11.19 |
[์๋ฃ๊ตฌ์กฐ] ์๋ฃ๊ตฌ์กฐ๋ ๋ฌด์์ธ๊ฐ? - ์ ๋ฆฌ ๋ฐ ์ฐ์ต๋ฌธ์ (0) | 2019.11.18 |
์ ์ด์ฅ์น - ์ ์ด์ฅ์น์ ๊ตฌ์ฑ๊ณผ ๋ช ๋ น์ด ์ํ ๊ณผ์ (0) | 2019.11.09 |
๋๊ธ