[JAVA] 자바 클래스(class) 기본 개념, 생성자와 상속

언어/JAVA 2018. 10. 8. 00:13

클래스(Class)


객체지향언어에서는 현실세계를 반영하기 위해 객체(Object)라는 개념을 도입하게 됩니다. 현실세계에서 보는 사람들, 자동차, TV 등이 객체지향언어에서는 객체로 표현이 됩니다. 


클래스란 객체를 생성하기 위해 그 객체가 어떤 데이터를 갖고 어떤 연산을 하는지에 대해 정의합니다.




클래스 정의

사람(Human)이라는 클래스가 있다고 칩시다. 사람은 눈, 코, 입이 있고, 손과 다리가 있겠죠. 이런 것이 클래스에서는 데이터입니다. 그리고 눈으로는 사물을 보고, 코로는 냄새를 맏고, 입으로는 말을 하거나 음식을 먹겠죠. 이것이 클래스 관점으로 보면 연산입니다.


간단히 이야기하면 멤버 변수와 멤버 메소드라고 기억하시기 바랍니다. 


코드로 정의를 해본다면 이렇게 될겁니다.


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<p>class Human{
    String eyes="눈";
    String ears="귀";
    String nose="코";
    String mouth="입";
     
    void useEyes(){
        System.out.println(eyes+"으로 봄");
    }
    void useEars(){
        System.out.println(ears+"로 소리를 들음");
    }
    void useNose(){
        System.out.println(nose+"로 냄새를 맡음");
    }
    void useMouth(){
        System.out.println(mouth+"으로 욕을 함");
    }
}
</p>

class라는 키워드로 Human이라는 클래스를 정의하고 있습니다. 클래스 안에는 데이터가 있고, 이 데이터들을 활용하여 행동을 정의하고 있습니다. 하지만 이렇게 클래스를 정의했다고 해서 바로 써먹을 수 있는 것은 아닙니다.




객체생성

자바에서는 모든 데이터를 객체로 취급합니다. 클래스를 정의한 이후에 클래스를 통해서 객체를 생성해야합니다. 객체를 생성하는 방법은 new라는 키워드로 메모리에 할당을 해야하는데요. 간단합니다.


Human human=new Human();


클래스를 통해서 메모리에 생성을 했습니다. 이제 human이라는 객체!가 생성이 된것이죠. 

C++을 배웠다면 new라는 키워드가 익숙할 겁니다. 네, C++에서의 new와 거의 동일한 역할을 합니다. 하지만 우리는 객체를 쓰고 닫을때 C++에서와 같이 메모리를 해제하지 않아도 됩니다. 왜냐하면 Garbage Collector가 알아서 메모리를 해제해 주거든요. C++에 대해 배우지 않았어도 상관없습니다. 


우리는 앞서 클래스를 정의할때 메소드 들을 정의했었습니다. 그렇기 때문에 이 메소드들을 사용할 수 있는 것입니다. 물론 그 객체의 변수들도 바꾸어 줄 수 있습니다. 


아래처럼요.


?
1
2
3
4
5
6
7
8
9
10
11
12
<p>public class Main {
 
    public static void main(String[] args){
        Human human=new Human();
        human.eyes="쌍꺼풀 수술한 눈";
        human.useEyes();
        human.useEars();
        human.useNose();
    }
}
 
</p>


물론 데이터가 바뀌었으니, 메소드의 연산도 바뀔 수 있습니다.




생성자

우리는 new라는 키워드를 통해서 객체를 생성할 때 


Human human=new Human();


라는 표현으로 객체를 생성했습니다. 하지만 눈 여겨 보면 괄호가 있는 것을 확인 할 수 있지요.

분명 괄호를 쓰는 이유가 있을 겁니다. 메소드처럼 그 안에 데이터를 매개변수로 전달하거나 하는 이유가 있지 않을까요?


우리는 클래스로부터 객체를 생성할때 초기 데이터를 전달해줄 수 있습니다. 그것이 바로 생성자라고 합니다.


생성자는 객체가 생성될때 가장 처음 호출하는 메소드라고 보면 됩니다. 이 생성자는 꼭 호출이 됩니다. 그리고 객체가 생성되지요. 하지만 우리는 생성자를 선언하지 않았습니다. 하지만 객체를 만들 수는 있었죠.


왜 일까요? 우리가 명시적으로 생성자를 선언하지 않아도 자동으로 default 생성자를 알아서 자바가 정의해줍니다. 물론 아무 기능을 하지 않는 생성자로요.


생성자의 정의는 일반 메소드를 정의하는 것과 같지만


1. 반환값이 없습니다.

2. 생성자의 이름은 클래스의 이름과 정확히 같아야합니다.

3. 생성자는 매개변수에 따라 여러개가 정의 될 수 있습니다.

4. public이라는 접근제어자여야 합니다.


위의 Human은 아무 매개변수가 없는 Default 생성자가 자동으로 호출이 된 것입니다. 




아래 코드는 생성자를 통해서 객체를 초기화 시키는 방법을 보여줍니다. 

?
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
28
29
30
31
32
33
34
35
36
37
38
39
class Human{
    String eyes="눈";
    String ears="귀";
    String nose="코";
    String mouth="입";
    public Human(){
        //default 생성자
    }
    public Human(String _eyes, String _ears, String _nose, String _mouth){
        eyes=_eyes;
        ears=_ears;
        nose=_nose;
        mouth=_mouth;
    }
    public void useEyes(){
        System.out.println(eyes+"으로 봄");
    }
    public void useEars(){
        System.out.println(ears+"로 소리를 들음");
    }
    public void useNose(){
        System.out.println(nose+"로 냄새를 맡음");
    }
    public void useMouth(){
        System.out.println(mouth+"로 욕을 함");
    }
}
 
 
public class Main {
 
    public static void main(String[] args){
        Human human=new Human("라식한 눈","귀","코털 삐져나온 코","험악한 입");
        human.useEars();
        human.useEyes();
        human.useMouth();
        human.useNose();
    }
}


위에서 생성자를 정의한 규칙대로 생성자를 정의해주었습니다. 그리고 default 생성자를 명시적으로 정의해주었습니다. 


그래서 생성자가 2개인 것이군요.


객체를 생성할때 2번째있는 생성자로 객체를 초기화시켰습니다. 그렇다면 초기화된 데이터로 객체가 생성됐을까요?

결과를 보고 확인해보죠.

 


제가 설명한 대로 군요.

생성자 어렵지 않지요?


Object 클래스

우리는 단지 위 4개의 메소드만을 정의했습니다. 하지만 우리가 정의하지 않은 메소드들도 리스트에 나옵니다. 우리는 분명이 아래와 같은 hashCode, notify, wait 과 같은 메소드들은 정의하지 않았습니다. 이것들은 무엇일까요? 우리는 이 정체를 밝혀내기 위해서 우선 Object 클래스를 알아야합니다.



사실 위의 메소드들은 Object클래스의 메소드들입니다. 위의 메소드들이 Object클래스에 그대로 존재하고 있다는 것을 확인하고 있지요.





허나 왜 Object클래스의 메소드가 왜 내가 만든 클래스에 딸려 나오는 것이냐?

모든 클래스는 Object클래스를 자동으로 상속받게 됩니다.




상속(Inheritance)?

아직 이야기하지는 않았습니다. 간단히 말해서 어떤 클래스의 변수와 메소드들을 물려받는다고 지금은 그렇게 이해하시기 바랍니다. 상속을 쓰게 되면 코드의 재활용이나 유지보수가 더욱 더 쉬워집니다. 상속을 사용하는 방법은 클래스를 정의하기 전 중괄호( { )에서 extends 클래스명 을 통해 이루어 집니다.


그렇기 때문에 extends Object를 명시해주지 않아도, 우리는 Object클래스의 메소드를 사용할 수 있는 겁니다.


모든 클래스입니다. 모든 클래스는 Object 클래스를 상속받는다는 것을 기억하세요.


아직은 Object 클래스의 메소드들을 일일이 설명하는 것은 좀 오바인것 같습니다.

포스팅을 하면서 중간중간에 설명하는 것으로 하거나, 정 궁금하다면 자바 Doc를 보아주세요.



반응형
저작자표시 비영리 변경금지

'언어 > JAVA' 카테고리의 다른 글

[자바] 파일 입출력1(FileReader, FileWriter, BufferedReader, BufferedWriter)  (0) 2018.12.23
[자바] 추상클래스와 인터페이스 개념과 사용방법  (0) 2018.12.23
[JAVA] 자바 다형성(Polymorphism) 개념부터 응용 쉬운 설명  (13) 2018.12.23
[JAVA] 캡슐화, 접근 제어자(private, default, protected, public)  (0) 2018.10.09
[JAVA] 클래스 상속(Inheritance)과 오버라이딩 예제  (0) 2018.10.08
블로그 이미지

REAKWON

와나진짜

,

[자료구조] 그림으로 쉽게 보는 연결 리스트 (Linked List) 개념과 구현

자료구조 2018. 10. 4. 22:32

Linked List


링크드리스트란 짧게 이야기해서 노드를 연결시킨 자료구조입니다. 노드는 무엇일까요?


링크드리스트에서 데이터를 갖고 있는 데이터의 묶음입니다. 그림으로 보는 것이 편할 것 같네요.





데이터들을 갖고 있는 하나의 요소가 보이시나요? 이것이 노드입니다. 노드 속에 다음 노드를 가리키고 있습니다.

화살표 모양으로 보아하니, 포인터군요!

특히, 제일 앞에 있는 노드는 헤드(head), 제일 끝 노드는 테일(tail)이라고 부릅니다.




head와 tail은 데이터 필드는 있지만 쓰지 않을 겁니다. 구현의 용이함을 위해선데요. 만약 head와 tail의 데이터 필드를 쓰게 되면  추가, 삭제시 3가지를 고려해야합니다.


1) 추가, 삭제할 노드가 맨 앞 노드인가

2) 추가, 삭제할 노드가 맨 뒤 노드인가

3) 추가, 삭제할 노드가 중간 노드인가


하지만 head와 tail의 data를 쓰지 않는다면 3)번 조건만 고려하면 되기 때문입니다.


이처럼 아무 데이터가 없는 노드를 더미노드라고 합니다.


이딴걸 왜 쓰지?

링크드리스트의 가장 큰 장점은 리스트의 길이가 가변적이라는 겁니다. 배열의 단점을 링크드리스트가 커버 할 수 있습니다.

배열은 크기가 가변적이지 않죠. 우선 크기를 정해준 다음에 모자라면 메모리를 더 할당하고, 배열의 데이터를 복사해야 되죠. 오래걸리고 비효율적이라는 것을 알 수 있겠죠?

배열을 사용해서 다시 사이즈를 늘리는 코드를 이런식으로 짤 수 있겠죠.

?
1
2
3
4
data *newList = (data*)malloc(sizeof(data)*(2*size));
for (int i = 0; i < size; size++)
    list[i] = newList[i];
free(list);


위 코드에서 보는 것과 같이 메모리를 할당한 후 for루프로 기존의 있던 값을 복사합니다.


하지만 링크드리스트는 어떨까요?

링크드리스트는 다음 노드만 추가하면 되기 때문에 리스트의 사이즈를 조정하는데, 그리 큰 비용을 들이지 않습니다.


아 좋은거네! 이것만 쓰면 되겠구만

이라고 생각할 수도 있겠지만, 링크드리스트는 어떤 노드를 search하거나 데이터를 변경할때 바로 찾아낼 수가 없습니다.

링크드리스트를 전부 탐색해야할 수도 있습니다.


그러니까 데이터가 자주 추가되거나 가변적으로 자주 변하게 될 프로그램이라면 링크드리스트를 쓰는 것이 좋겠고, 주로 데이터의 변경이나 탐색을 위한 것이라면 배열을 쓰는 것이 좋습니다. case-by-case죠.




구현

포인터나 구조체를 제대로 배우지 않은 사람이라면 약간 어려울 수 있습니다.


우리는 다음과 같은 연산을 정의할 겁니다.



1. addFirst(list, data)

링크드리스트의 새로운 노드를 추가합니다. 가장 앞 있는 노드(head의 다음)에 새로운 노드를 추가하는 연산입니다.


2. addLast(list, data)

addFirst와 반대로 가장 뒤에 노드를 추가합니다.


3. removeNode(list, data)

링크드리스트가 갖고 있는 노드 중에 data값을 갖고 있는 노드를 삭제합니다. 


4. searchNode(list,data)

링크드 리스트에서 data의 값과 일치하는 노드를 검색합니다.


5. printList()

링크드리스트를 전부 탐색합니다. 리스트의 데이터를 전부 보여줍니다.


각각의 연산을 어떻게 구현하면 될 지 그림으로 설명하도록 하지요.


1. addFirst(list, data)

가장 첫번째에 노드를 추가합니다. 가장 첫번째라고 해서 head 앞에 추가해서는 안됩니다. head의 다음 노드에 추가해야합니다.

head의 다음 노드를 새로운 노드로 가리키게 만들고, 그 새로운 노드는 이전에 head가 가리키고 있던 노드를 가리키면 됩니다.


코드는 아래와 같습니다.


?
1
2
3
4
5
6
7
void addFirst(List *list,int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = list->head->next;
    list->head->next = newNode;
    list->size++;
}


2. addLast(list, data)

가장 마지막(tail 앞)에 노드를 추가하는 연산입니다. 일단 tail앞까지 가야하지만, 그 전의 노드를 기억해야합니다. 그러니까 살짝 까다로울 수 있지요.


아래는 노드 삭제연산을 구현한 코드입니다.


?
1
2
3
4
5
6
7
8
9
10
11
12
void addLast(List* list, int data) {
    Node *last = list->head;
     
    while (last->next != list->tail)
        last = last->next;
     
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = list->tail;
    last->next = newNode;
    list->size++;
}




3. removeNode(list, data)

리스트의 노드를 하나씩 돌면서 data가 일치하면 그 노드를 삭제하는 겁니다.

주의할 점은 그 노드 다음 노드를 이전의 노드가 가리키는 작업이 우선적으로 이루어져야한다는 겁니다.



?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void removeNode(List *list, int data) {
    Node *node = list->head;
    while (node->next != list->tail) {
        if (node->next->data == data) {
            Node *delNode = node->next;
            node->next = delNode->next;
            free(delNode);
            list->size--;
            return;
        }
        node = node->next;
    }
    printf("데이터를 찾지 못했습니다.\n");
}

4. searchNode(list, data)

삭제 연산보다 쉽습니다. list를 돌면서 data와 값이 일치하면 그 노드를 반환하면 되니까요.


?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
void removeNode(List *list, int data) {
    Node *node = list->head;
    while (node->next != list->tail) {
        if (node->next->data == data) {
            Node *delNode = node->next;
            node->next = delNode->next;
            free(delNode);
            list->size--;
            return;
        }
        node = node->next;
    }
    printf("데이터를 찾지 못했습니다.\n");
}

5. printList(list)

이 함수 역시 정말 쉽습니다. search 연산과 별 다를 것이 없죠. 그냥 list돌면서 하나하나 출력해주기만 하면 됩니다.




전체 코드


?
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
#include <stdio.h>
#include <stdlib.h>
 
 
typedef struct node {
    int data;
    struct node *next;
} Node;
typedef struct list {
    Node *head;
    Node *tail;
    int size;
} List;
 
void createlist(List *list) {
     
    list->head = (Node*)malloc(sizeof(Node));
    list->tail = (Node*)malloc(sizeof(Node));
    list->head->next = list->tail;
    list->tail->next = list->tail;
    list->size = 0;
}
void addFirst(List *list,int data) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = list->head->next;
    list->head->next = newNode;
    list->size++;
}
void addLast(List* list, int data) {
    Node *last = list->head;
     
    while (last->next != list->tail)
        last = last->next;
     
    Node *newNode = (Node*)malloc(sizeof(Node));
    newNode->data = data;
    newNode->next = list->tail;
    last->next = newNode;
    list->size++;
}
 
Node* searchNode(List *list, int data) {
    Node *node = list->head->next;
    while (node != list->tail) {
        if (node->data == data)
            return node;
        node = node->next;
    }
    printf("데이터를 찾지 못했습니다.\n");
 
    return NULL;
}
 
void removeNode(List *list, int data) {
    Node *node = list->head;
    while (node->next != list->tail) {
        if (node->next->data == data) {
            Node *delNode = node->next;
            node->next = delNode->next;
            free(delNode);
            list->size--;
            return;
        }
        node = node->next;
    }
    printf("데이터를 찾지 못했습니다.\n");
}
 
 
 
void printList(List *list) {
    Node *node = list->head->next;
    int i = 1;
    while (node != list->tail) {
        printf("%d 번째 노드 데이터 :%d\n", i++, node->data);
        node = node->next;
    }
}
void distroyList(List *list) {
    Node *node = list->head;
    while (node != list->tail) {
        Node *delNode = node;
        node = delNode->next;
        free(delNode);
    }
    free(list->head);
    free(list->tail);
}
 
int main() {
 
    int i;
    List list;
    createlist(&list);
     
    for (i = 1; i <= 5; i++)
        addLast(&list, i);
    for (i = 11; i <= 15; i++)
        addFirst(&list, i);
    removeNode(&list, 11);
    removeNode(&list, 15);
    removeNode(&list, 5);
    removeNode(&list, 4);
    removeNode(&list, 50);
 
    Node *node = searchNode(&list, 14);
    printf("search :%d\n", node->data);
 
    node=searchNode(&list,12);
    printf("search :%d\n", node->data);
 
    node = searchNode(&list, 3);
    printf("search :%d\n", node->data);
 
    printList(&list);
    return 0;
}


제가 구현한 코드가 삑사리가 있을지도 모릅니다. 그럴땐 여러분들이 고쳐보세요! 그러면서 실력이 느는거 아니겠습니까?! 하하


반응형
저작자표시 비영리 변경금지

'자료구조' 카테고리의 다른 글

[자료구조] 트리 개념 및 순회 방법, 전위순회, 중위순회, 후위순회  (0) 2018.11.04
[자료구조] 연결형 큐(Linked List + Queue) 개념과 구현(C++소스)  (0) 2018.10.11
[자료구조] 큐(Queue)와 원형큐(Circular Queue) 개념과 구현  (1) 2018.10.10
[자료구조] 그림으로 쉽게 보는 연결형 스택 원리, 구현, 코드  (0) 2018.10.09
[자료구조] 그림으로 쉽게 보는 배열 스택(Stack)과 구현  (0) 2018.10.02
블로그 이미지

REAKWON

와나진짜

,

[자료구조] 그림으로 쉽게 보는 배열 스택(Stack)과 구현

자료구조 2018. 10. 2. 22:18

스택(Stack) 개념


자료구조에서 스택은 어떤 자료구조일까요? 스택은 영어 단어 자체에서 힌트를 얻을 수 있습니다.


stack

1. (보통 깔끔하게 정돈된) 무더기   2. 많음, 다량   3. (특히 공장의 높은) 굴뚝
1. 쌓다


stack은 쌓다, 무더기 이런 의미로 쓰이죠.


이 의미가 자료구조에 그대로 반영이 됩니다. 

우리는 어떤 물건을 쌓는다면 가장 먼저 쌓은 물건은 아래에 깔리고 가장 최근 쌓은 물건은 위에 쌓이게 되지요.


꺼낼때는 어떨까요?

나중에 쌓은 물건을 먼저 꺼내겠죠?


이처럼 나중에 쌓은 것이 먼저 나오고 먼저 쌓은 물건은 더 나중에 나온다 라는 개념이 LIFO(Last In First Out)이라고 합니다. 그와 반대, 먼저 들어온 것이 먼저 나간다의 개념은 FIFO(First In First Out)라고 합니다.




종류

스택은 두 가지 정도의 종류가 존재합니다.


● 배열형태의 스택

● 연결리스트 형태의 스택


두 형태는 스택을 구현하는 기능은 같더라도 효율성에서 다릅니다. 


배열형 스택은 우선 접근 속도가 빠릅니다. 하지만 다시 크기를 확장하거나 줄일때 효율성이 떨어지게 되죠. 생각해보세요. 스택 크기가 10인 스택이 데이터를 더 저장하기 위해 스택의 길이를 늘리게 되면 우선 배열의 크기를 다시 할당하고 난 후에 값을 복사해야합니다. 길이가 10인 스택이라 그렇지 크기가 크면 클 수록 성능이 저하되는 것을 알 수 있습니다.


그리고 사용자가 얼마만큼의 스택 크기가 필요한지 예측을 할 수도 없습니다.


반면 연결리스트형 스택은 가변적으로 스택의 크기를 줄였다 늘였다 할 수 있습니다. 반면 값에 접근하려면 그 효율성이 떨어지게 됩니다. 연결리스트 형 스택을 구현하려면 linked list 자료구조를 우선 알아야합니다.


스택의 사용처

스택은 함수의 호출 뿐만 아니라 수식에서도 사용되며 사용처는 많습니다. 우리가 즐겨쓰는 인터넷의 뒤로가기 역시 스택 자료구조가 쓰이게 됩니다. 심지어 미로를 찾는데에도 스택을 쓸 수 있습니다.


구현

기본적으로 스택은 여러 언어에서 표준 라이브러리로 제공이 되긴 합니다만 어떻게 구현이 되어있는지 정도는 이해하고 있어야합니다.


아래의 코드는 배열형 스택을 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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
#include <iostream>
#define stack_size 100
using namespace std;
 
struct stack {
    int top = -1;
    int arr[stack_size];
    void push(int data) {
        if (top == stack_size-1) {
            printf("stack is full\n");
            return;
        }
        arr[++top] = data;
    }
    int pop() {
        if (empty()) {
            printf("stack is empty\n");
            return -1;
        }
        return arr[top--];
    }
    int peek() {
        if (empty()) {
            printf("stack is empty\n");
            return -1;
        }
        return arr[top];
    }
    bool empty() {
        return top <= -1;
    }
};
int main() {
    stack st;
    //현재 스택은 비워져있는 상태
    cout << "is stack empty? "<<st.empty() << endl;
    cout << st.pop() << endl;
    cout << st.peek() << endl;
 
        //for 루프가 돌면 스택은 1개만 저장 가능한 상태
    for (int i = 0; i < stack_size-1; i++)
        st.push(i + 1);
 
        cout << endl;
        cout << "after for loop"<<endl;
    st.push(15);
        //스택은 전부 채워져 있는 상태
    st.push(120);
        //스택에서 한 개가 비워짐, 1개 채울 수 있는 상태
    st.pop();
 
    st.push(120);
 
    cout<<endl;
        //스택이 비워지면 while루프 종료
    while(!st.empty())
        cout << st.pop() << endl;
     
}




stack은 다음과 같은 연산을 하게 됩니다.

push : 데이터를 쌓습니다.
pop : 데이터를 하나 꺼내옵니다.
peek : 데이터를 하나 봅니다. 꺼내오지는 않습니다.
empty : 스택이 비어있는 지 확인합니다.

위의 코드를 이해하기 쉽게 그림으로 표현해보겠습니다. 


1. 초기 스택의 상태는 이런 그림입니다. top은 맨 아래, -1이라는 배열의 인덱스로 쓸 수 없는 위치에 있지요.

 

그래서 stack.empty()는 true(1)입니다. stack에서 peek이나 push 연산을 해도 데이터가 없기 때문에 stack is empty라는 메시지를 보게 되고 -1이 반환됩니다.

2. 그 이후 for 루프로 스택의 최상위 위치를 빼고 전부 push연산으로 채웁니다.

top은 아래의 위치에 있습니다.



3. 이제 15을 push하게 되면 스택은 전부 채워졌고, 다음 120은 모두 채워져있기 때문에 스택에 쌓이지 못합니다.





4. 이후 스택에서 pop연산을 했으니 공간이 하나 남고, 다시 120을 push하면 스택에 들어가게 됩니다.


5. 이제 while루프를 돌며 pop연산을 하게 됩니다. 스택에 데이터가 남아있는 동안 출력하게 됩니다. 최종적으로 스택은 초기상태가 됩니다.




코드를 잘 따라가 보면 이해하실 겁니다.


배열 스택을 조금 이해하셨나요?

반응형
저작자표시 비영리 변경금지

'자료구조' 카테고리의 다른 글

[자료구조] 트리 개념 및 순회 방법, 전위순회, 중위순회, 후위순회  (0) 2018.11.04
[자료구조] 연결형 큐(Linked List + Queue) 개념과 구현(C++소스)  (0) 2018.10.11
[자료구조] 큐(Queue)와 원형큐(Circular Queue) 개념과 구현  (1) 2018.10.10
[자료구조] 그림으로 쉽게 보는 연결형 스택 원리, 구현, 코드  (0) 2018.10.09
[자료구조] 그림으로 쉽게 보는 연결 리스트 (Linked List) 개념과 구현  (3) 2018.10.04
블로그 이미지

REAKWON

와나진짜

,
반응형

공지사항

글 보관함

달력

«   2025/04   »
일 월 화 수 목 금 토
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 28 29 30

티스토리툴바