자료구조 stack - List

//LINKEDLIST_STACK_H라는 헤더파일을 만들어준다

#ifndef LINKEDLIST_STACK_H

#define LINKEDLIST_STACK_H
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

typedef struct tagNode {
        char *Data;
        struct tagNode* Next;
}Node;


typedef struct LinkedListStack {
        Node* List;
        Node* Top;
}LinkedListStack;

void CreateStack(LinkedListStack** Stack);
void DestroyStack(LinkedListStack* Stack);

Node* CreateNode(char *Data);
void DestroyNode(Node* Node);

void Push(LinkedListStack* Stack, Node* NewNode);
Node* Pop(LinkedListStack* Stack);

Node* Top(LinkedListStack* Stack);
int GetSize(LinkedListStack* Stack);
int IsEmpty(LinkedListStack* Stack);

#endif

=======================================================
#include"LinkedListStack.h"

void CreateStack(LinkedListStack** Stack) {
        //스택을 자유 저장소에 생성
        (*Stack) = (LinkedListStack*)malloc(sizeof(LinkedListStack));
        (*Stack)->List = NULL;
        (*Stack)->Top = NULL;
}


void DestroyStack(LinkedListStack* Stack) {
        while (!IsEmpty(Stack)) {
                Node* Popped = Pop(Stack);
                DestroyNode(Popped);
        }
        //스택을 자유저장소에서 해제
        free(Stack);
}

Node* CreateNode(char *Data) {
        Node* NewNode = (Node*)malloc(sizeof(Node));
        NewNode->Data = (char*)malloc(strlen(Data) + 1);

        strcpy(NewNode->Data, Data); //데이터를 저장한다.

        NewNode->Next = NULL; //다음 노드에 대한 포인터는 NULL로 초기화한다.

        return NewNode; // 노드의 주소를 반환한다.
}
void DestroyNode(Node* Node) {
        free(Node->Data);
        free(Node);
}

void Push(LinkedListStack* Stack, Node* NewNode) {
        if (Stack->List == NULL) {
                Stack->List = NewNode;
        } else {
                //최상위 노드를 찾아 NewNode를 연결
                Node* OldTop = Stack->List;

                while (OldTop->Next != NULL) {
                OldTop = OldTop->Next;
                }
                OldTop->Next = NewNode;
        }
        //스택의 Top필드에 새 노드의 주소를 등록
        Stack->Top = NewNode;
}
Node* Pop(LinkedListStack* Stack) {
        //함수가 반환할 최상위 노드가 필요함
        Node* TopNode = Stack->Top;

        if (Stack->List == Stack->Top) {
Stack->List = NULL;
Stack->Top = NULL;
        }
        else {
                //새로운 최상위 노드를 스택의 Top 필드에 등록
                Node* CurrentTop = Stack->List;
                while (CurrentTop != NULL && CurrentTop->Next != Stack->Top) {
                        CurrentTop = CurrentTop->Next;
                }
                Stack->Top = CurrentTop;
                CurrentTop->Next = NULL;
        }
        return TopNode;
}

Node*Top(LinkedListStack* Stack) {
        return Stack->Top;
}

int GetSize(LinkedListStack* Stack) {
        int Count = 0;
        Node* Current = Stack->List;
        while (Current != NULL) {
                Current = Current->Next;
                Count++;
        }
        return Count;
}
int IsEmpty(LinkedListStack* Stack) {
        return(Stack->List == NULL);
}

void main() {
        int Count;
        Node* popped;
        LinkedListStack* Stack;

        CreateStack(&Stack);

        Push(Stack, CreateNode("ABC"));
        Push(Stack, CreateNode("DEF"));
        Push(Stack, CreateNode("GHI"));
        Push(Stack, CreateNode("JKL"));

        Count = GetSize(Stack);
        printf("Size : %d, Top : %s\n\n", Count, Top(Stack)->Data);

        for (int i = 0; i < Count; i++) {
                if (IsEmpty(Stack)) break;
                popped = Pop(Stack);
                printf("Popped : %s, ", popped->Data);

                DestroyNode(popped);

                if (!IsEmpty(Stack))
                        printf("Current Top : %s\n", Top(Stack)->Data);
                else printf("Stack is Empty.\n");
        }
        DestroyStack(Stack);

        system("pause");
}