Knowledge Base Management System

#ifndef BINARY_TREE_H

#define BINARY_TREE_H

#include <stdio.h>

#include <stdlib.h>

typedef char ElementType;

typedef struct tagSBTNode 

{

    struct tagSBTNode* Left;

    struct tagSBTNode* Right;

    ElementType Data;

} SBTNode;

SBTNode*  SBT_CreateNode( ElementType NewData );

void      SBT_DestroyNode( SBTNode* Node );

void      SBT_DestroyTree( SBTNode* Root );

void      SBT_PreorderPrintTree( SBTNode* Node );

void      SBT_InorderPrintTree( SBTNode* Node );

void      SBT_PostorderPrintTree( SBTNode* Node );

#endif BINARY_TREE_H

#ifndef EXPRESSION_TREE_H

#define EXPRESSION_TREE_H

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

typedef char ElementType;

typedef struct tagETNode 

{

    struct tagETNode* Left;

    struct tagETNode* Right;

    ElementType Data;

} ETNode;

ETNode*   ET_CreateNode( ElementType NewData );

void      ET_DestroyNode( ETNode* Node );

void      ET_DestroyTree( ETNode* Root );

void      ET_PreorderPrintTree( ETNode* Node );

void      ET_InorderPrintTree( ETNode* Node );

void      ET_PostorderPrintTree( ETNode* Node );

void      ET_BuildExpressionTree( char* PostfixExpression, ETNode** Node );

double    ET_Evaluate( ETNode* Tree );

#endif EXPRESSION_TREE_H

#ifndef DISJOINTSET_H

#define DISJOINTSET_H

#include <stdio.h>

#include <stdlib.h>

typedef struct tagDisjointSet

{

    struct tagDisjointSet* Parent;

    void*                  Data;

} DisjointSet;

void DS_UnionSet( DisjointSet* Set1, DisjointSet* Set2 );

DisjointSet* DS_FindSet( DisjointSet* Set );

DisjointSet* DS_MakeSet( void* NewData );

void DS_DestroySet( DisjointSet* Set );

#endif

#ifndef LINKED_QUEUE_H

#define LINKED_QUEUE_H

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

typedef struct tagNode

{

    char* Data;

    struct tagNode* NextNode;

} Node;

typedef struct tagLinkedQueue

{

    Node* Front;

    Node* Rear;

    int   Count;

} LinkedQueue;

void  LQ_CreateQueue( LinkedQueue** Queue );

void  LQ_DestroyQueue( LinkedQueue* Queue );

Node* LQ_CreateNode(char* Data);

void  LQ_DestroyNode(Node* _Node );

void  LQ_Enqueue( LinkedQueue* Queue, Node* NewNode );

Node* LQ_Dequeue( LinkedQueue* Queue );

int   LQ_IsEmpty( LinkedQueue* Queue );

#endif LINKED_QUEUE_H

#ifndef CIRCULAR_QUEUE_H

#define CIRCULAR_QUEUE_H

#include <stdio.h>

#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode

{

    ElementType Data;

} Node;

typedef struct tagCircularQueue

{

    int   Capacity;

    int   Front;

    int   Rear;

    Node* Nodes;

} CircularQueue;

void        CQ_CreateQueue( CircularQueue** Queue, int Capacity);    //큐 생성

void        CQ_DestroyQueue( CircularQueue* Queue );                     //큐 삭제

void        CQ_Enqueue( CircularQueue* Queue, ElementType Data);    //삽입

ElementType CQ_Dequeue( CircularQueue* Queue );                        //삭제

int         CQ_GetSize( CircularQueue* Queue );                                //큐의 크기

int         CQ_IsEmpty( CircularQueue* Queue );                                //큐의 상태가 비어있는지 확인

int         CQ_IsFull( CircularQueue* Queue );                                    //큐의 상태가 가득차 있는지 확인

#endif

#include "CircularQueue.h"

void  CQ_CreateQueue( CircularQueue** Queue, int Capacity)

{

    /*  큐를 자유저장소에 생성 */

    (*Queue ) = ( CircularQueue*)malloc(sizeof( CircularQueue ));

    /*  입력된 Capacity+1 만큼의 노드를 자유저장소에 생성 */

    (*Queue )->Nodes    = (Node*)malloc(sizeof(Node )* ( Capacity+1) );

    (*Queue )->Capacity = Capacity;

    (*Queue )->Front = 0;

    (*Queue )->Rear  = 0;

}

void CQ_DestroyQueue( CircularQueue* Queue )

{

    free(Queue->Nodes);

    free(Queue );

}

void CQ_Enqueue( CircularQueue* Queue, ElementType Data)

{

    int Position=0;

    if(Queue->Rear==Queue->Capacity)

    {

        Position=Queue->Rear;

        Queue->Rear=0;

    }

    else

        Position=Queue->Rear++;

    Queue->Nodes[Position].Data=Data;

}

ElementType CQ_Dequeue( CircularQueue* Queue )

{

    int Position = Queue->Front;

    if ( Queue->Front == Queue->Capacity )

        Queue->Front = 0;

    else

        Queue->Front++;

    return Queue->Nodes[Position].Data;

}

int CQ_GetSize( CircularQueue* Queue )

{

    if ( Queue->Front <= Queue->Rear )

        return Queue->Rear - Queue->Front;

    else

        return Queue->Rear + (Queue->Capacity - Queue->Front) + 1;

}

int CQ_IsEmpty( CircularQueue* Queue )

{

    return (Queue->Front == Queue->Rear);

}

int CQ_IsFull( CircularQueue* Queue )

{

    if ( Queue->Front < Queue->Rear )

        return ( Queue->Rear - Queue->Front) == Queue->Capacity;

    else

        return ( Queue->Rear + 1 ) == Queue->Front;

}

#include "Calculator.h"

char NUMBER[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.' };

int IsNumber( char Cipher )

{

    int i = 0;

    int ArrayLength = sizeof(NUMBER);

    for ( i=0; i<ArrayLength; i++ )

    {

        if ( Cipher == NUMBER[i] )

            return 1;

    }

    return 0;

}

unsigned int GetNextToken( char* Expression, char* Token, int* TYPE )

{

    unsigned int i = 0;

    for ( i=0 ; 0 != Expression[i]; i++ )

    {

        Token[i] = Expression[i];

        if ( IsNumber( Expression[i] ) == 1 )

        {            

            *TYPE = OPERAND;

            if ( IsNumber(Expression[i+1]) != 1 )

                break;

        }

        else

        {

            *TYPE = Expression[i];

            break;            

        }

    }

    Token[++i] = '\0';

    return i;

}

int GetPriority(char Operator, int InStack)

{

    int Priority = -1;

    switch (Operator)

    {

    case LEFT_PARENTHESIS:

        if ( InStack )

            Priority = 3;

        else

            Priority = 0;

        break;

    case MULTIPLY:

    case DIVIDE:

        Priority = 1;

        break;

    case PLUS:

    case MINUS:

        Priority = 2;

        break;

    }

    return Priority;

}

int IsPrior( char OperatorInStack, char OperatorInToken )

{

    return ( GetPriority(OperatorInStack, 1) > GetPriority(OperatorInToken, 0) );

}

void GetPostfix( char* InfixExpression, char* PostfixExpression )

{

    LinkedListStack* Stack;

    char Token[32];

    int  Type = -1;

    unsigned int Position = 0;

    unsigned int Length = strlen( InfixExpression );

    LLS_CreateStack(&Stack);

    while ( Position < Length )

    {

        Position += GetNextToken( &InfixExpression[Position], Token, &Type );

        if ( Type == OPERAND ) 

        {

            strcat( PostfixExpression, Token );

            strcat( PostfixExpression, " " );

        }

        else if ( Type == RIGHT_PARENTHESIS ) 

        {               

            while ( !LLS_IsEmpty(Stack) )

            {

                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] == LEFT_PARENTHESIS )

                {

                    LLS_DestroyNode( Popped );

                    break;

                }

                else

                {

                    strcat( PostfixExpression, Popped->Data );          

                    LLS_DestroyNode( Popped );

                }

            }

        }

        else

        {

            while ( !LLS_IsEmpty( Stack ) && 

                    !IsPrior( LLS_Top( Stack )->Data[0], Token[0] ) )

            {

                Node* Popped = LLS_Pop( Stack );

                if ( Popped->Data[0] != LEFT_PARENTHESIS )

                    strcat( PostfixExpression, Popped->Data );

                LLS_DestroyNode( Popped );

            }

            LLS_Push( Stack, LLS_CreateNode( Token ) );

        }

    }

    while ( !LLS_IsEmpty( Stack) )

    {

        Node* Popped = LLS_Pop( Stack );

        if ( Popped->Data[0] != LEFT_PARENTHESIS )

            strcat( PostfixExpression, Popped->Data );

        LLS_DestroyNode( Popped );

    }

    LLS_DestroyStack(Stack);

}

double Calculate( char* PostfixExpression )

{

    LinkedListStack* Stack;

    Node*  ResultNode;

    double Result;

    char Token[32];

    int  Type = -1;

    unsigned int Read = 0; 

    unsigned int Length = strlen( PostfixExpression );

    LLS_CreateStack(&Stack);

    while ( Read < Length )

    {

        Read += GetNextToken( &PostfixExpression[Read], Token, &Type );

        if ( Type == SPACE )  

            continue;

        if ( Type == OPERAND ) 

        {

            Node* NewNode = LLS_CreateNode( Token );

            LLS_Push( Stack, NewNode );

        }

        else

        {

            char   ResultString[32];            

            double Operator1, Operator2, TempResult;

            Node* OperatorNode;

            OperatorNode = LLS_Pop( Stack );

            Operator2 = atof( OperatorNode->Data );

            LLS_DestroyNode( OperatorNode );

            OperatorNode = LLS_Pop( Stack );

            Operator1 = atof( OperatorNode->Data );

            LLS_DestroyNode( OperatorNode );

            switch (Type)

            {

            case PLUS:     TempResult = Operator1 + Operator2; break;

            case MINUS:    TempResult = Operator1 - Operator2; break;

            case MULTIPLY: TempResult = Operator1 * Operator2; break;

            case DIVIDE:   TempResult = Operator1 / Operator2; break;

            }

            gcvt( TempResult, 10, ResultString );            

            LLS_Push( Stack, LLS_CreateNode( ResultString ) );

        }

    }

    ResultNode = LLS_Pop( Stack );            

    Result = atof( ResultNode->Data );

    LLS_DestroyNode( ResultNode );

    LLS_DestroyStack( Stack );

    return Result;

}

#include "ArrayStack.h"

void  AS_CreateStack(ArrayStack** Stack, int Capacity)

{

    /*  스택을 자유저장소에 생성 */

    (*Stack)           = (ArrayStack*)malloc(sizeof(ArrayStack));

    /*  입력된 Capacity만큼의 노드를 자유저장소에 생성 */

    (*Stack)->Nodes    = (Node*)malloc(sizeof(Node)*Capacity);

    /*  Capacity 및 Top 초기화 */

    (*Stack)->Capacity = Capacity;

    (*Stack)->Top = 0;

}

void AS_DestroyStack(ArrayStack* Stack)

{

    /*  노드를 자유 저장소에서 해제 */

    free(Stack->Nodes);

    /*  스택을 자유 저장소에서 해제 */

    free(Stack);

}

void AS_Push(ArrayStack* Stack, ElementType Data)

{

    int Position = Stack->Top;

    Stack->Nodes[Position].Data = Data;

    Stack->Top++;

}

ElementType AS_Pop(ArrayStack* Stack)

{

    int Position = --( Stack->Top );

    return Stack->Nodes[Position].Data;

}

ElementType AS_Top(ArrayStack* Stack)

{

    int Position = Stack->Top - 1;

    return Stack->Nodes[Position].Data;

}

int AS_GetSize(ArrayStack* Stack)

{

    return Stack->Top;

}

int AS_IsEmpty(ArrayStack* Stack)

{

    return (Stack->Top == 0);

}

#ifndef LINKEDLIST_STACK_H

#define LINKEDLIST_STACK_H

#include <stdio.h>

#include <string.h>

#include <stdlib.h>

typedef struct tagNode

{

    char* Data;

    struct tagNode* NextNode;

} Node;

typedef struct tagLinkedListStack

{

    Node* List;

    Node* Top;

} LinkedListStack;

void  LLS_CreateStack( LinkedListStack** Stack );

void  LLS_DestroyStack( LinkedListStack* Stack );

Node* LLS_CreateNode( char* Data );

void  LLS_DestroyNode( Node* _Node );

void  LLS_Push( LinkedListStack* Stack, Node* NewNode );

Node* LLS_Pop( LinkedListStack* Stack );

Node* LLS_Top( LinkedListStack* Stack );

int   LLS_GetSize( LinkedListStack* Stack );

int   LLS_IsEmpty( LinkedListStack* Stack );

#endif LINKEDLIST_STACK_H

#include "LinkedListStack.h"

void  LLS_CreateStack( LinkedListStack** Stack )

{

    /*  스택을 자유저장소에 생성 */

    (*Stack )       = ( LinkedListStack*)malloc(sizeof( LinkedListStack ) );

    (*Stack )->List = NULL;

    (*Stack )->Top  = NULL;

}

void LLS_DestroyStack( LinkedListStack* Stack )

{

    while ( !LLS_IsEmpty(Stack ) )

    {

        Node* Popped = LLS_Pop( Stack );

        LLS_DestroyNode(Popped);    

    }

    /*  스택을 자유 저장소에서 해제 */

    free(Stack );

}

Node* LLS_CreateNode( char* NewData )

{

    Node* NewNode = ( Node*)malloc(sizeof( Node ) );

    NewNode->Data = ( char*)malloc(strlen( NewData ) + 1);

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

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

    return NewNode;/*  노드의 주소를 반환한다. */

}

void  LLS_DestroyNode( Node* _Node )

{

    free(_Node->Data );

    free(_Node );

}

void LLS_Push( LinkedListStack* Stack, Node* NewNode )

{

    if ( Stack->List == NULL ) 

    {        

        Stack->List = NewNode;

    } 

    else

    {

        /*  최상위 노드를 찾아 NewNode를 연결한다(쌓는다). */

        Node* OldTop = Stack->List;

        while ( OldTop->NextNode != NULL )

        {

            OldTop = OldTop->NextNode;

        }

        OldTop->NextNode = NewNode;

    }

    /*  스택의 Top 필드에 새 노드의 주소를 등록한다. */

    Stack->Top = NewNode;

}

Node* LLS_Pop( LinkedListStack* Stack )

{

    /*  LLS_Pop() 함수가 반환할 최상위 노드 */

    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->NextNode != Stack->Top )

        {

            CurrentTop = CurrentTop->NextNode;

        }

        Stack->Top = CurrentTop;

        CurrentTop->NextNode = NULL;

    }

    return TopNode;

}

Node* LLS_Top( LinkedListStack* Stack )

{

    return Stack->Top;

}

int LLS_GetSize( LinkedListStack* Stack )

{

    int    Count = 0;

    Node*  Current = Stack->List;

    while ( Current != NULL )

    {

        Current = Current->NextNode;

        Count++;

    }

    return Count;

}

int LLS_IsEmpty( LinkedListStack* Stack )

{

    return (Stack->List == NULL);

}

#ifndef CIRCULAR_DOUBLY_LINKEDLIST_H

#define CIRCULAR_DOUBLY_LINKEDLIST_H

#include <stdio.h>

#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode

{

    ElementType Data;

    struct tagNode* PrevNode;

    struct tagNode* NextNode;

} Node;

Node* CDLL_CreateNode(ElementType NewData);

void  CDLL_DestroyNode(Node* Node);

void  CDLL_AppendNode(Node** Head, Node* NewNode);

void  CDLL_InsertAfter(Node* Current, Node* NewNode);

void  CDLL_RemoveNode(Node** Head, Node* Remove);

Node* CDLL_GetNodeAt(Node* Head, int Location);

int   CDLL_GetNodeCount(Node* Head);

#endif CIRCULAR_DOUBLY_LINKEDLIST_H

#include "CircularDoublyLinkedList.h"

/*  노드 생성 */

Node* CDLL_CreateNode(ElementType NewData)

{

    Node* NewNode = (Node*)malloc(sizeof(Node));

    NewNode->Data = NewData;

    NewNode->PrevNode = NULL;

    NewNode->NextNode = NULL;

    return NewNode;

}

/*  노드 소멸 */

void CDLL_DestroyNode(Node* Node)

{

    free(Node);

}

/*  노드 추가 */

void CDLL_AppendNode(Node** Head, Node* NewNode)

{

    /*  헤드 노드가 NULL이라면 새로운 노드가 Head */

    if ( (*Head) == NULL ) 

    {

        *Head = NewNode;

        (*Head)->NextNode = *Head;

        (*Head)->PrevNode = *Head;

    } 

    else

    {

        /*  테일과 헤드 사이에 NewNode를 삽입한다. */

        Node* Tail = (*Head)->PrevNode;

        Tail->NextNode->PrevNode = NewNode;

        Tail->NextNode = NewNode;

        NewNode->NextNode = (*Head);

        NewNode->PrevNode = Tail; /*  기존의 테일을 새로운  */

                                  /*  테일의 PrevNode가 가리킨다. */

    }

}

/*  노드 삽입 */

void CDLL_InsertAfter(Node* Current, Node* NewNode)

{

    NewNode->NextNode = Current->NextNode;

    NewNode->PrevNode = Current;

    if ( Current->NextNode != NULL )

    {

        Current->NextNode->PrevNode = NewNode;

        Current->NextNode = NewNode;

    }

}

/*  노드 제거 */

void CDLL_RemoveNode(Node** Head, Node* Remove)

{

    if ( *Head == Remove )

    {

        (*Head)->PrevNode->NextNode = Remove->NextNode;

        (*Head)->NextNode->PrevNode = Remove->PrevNode;

        *Head = Remove->NextNode;

        Remove->PrevNode = NULL;

        Remove->NextNode = NULL;

    }

    else

    {

/*

        Node* Temp = Remove;

        Remove->PrevNode->NextNode = Temp->NextNode;

        Remove->NextNode->PrevNode = Temp->PrevNode;

*/

        Remove->PrevNode->NextNode = Remove->NextNode;

        Remove->NextNode->PrevNode = Remove->PrevNode;

        Remove->PrevNode = NULL;

        Remove->NextNode = NULL;

    }    

}

/*  노드 탐색 */

Node* CDLL_GetNodeAt(Node* Head, int Location)

{

    Node* Current = Head;

    while ( Current != NULL && (--Location) >= 0)

    {

        Current = Current->NextNode;

    }

    return Current;

}

/*  노드 수 세기 */

int CDLL_GetNodeCount(Node* Head)

{

    unsigned int  Count = 0;

    Node*         Current = Head;

    while ( Current != NULL )

    {

        Current = Current->NextNode;

        Count++;

        if ( Current == Head )

            break;

    }

    return Count;

}

void PrintNode(Node* _Node)

{

    if ( _Node->PrevNode == NULL )

        printf("Prev: NULL");

    else

        printf("Prev: %d", _Node->PrevNode->Data);

    printf(" Current: %d ", _Node->Data);

    if ( _Node->NextNode == NULL )

        printf("Next: NULL\n");

    else

        printf("Next: %d\n", _Node->NextNode->Data);

}

#ifndef DOUBLY_LINKEDLIST_H

#define DOUBLY_LINKEDLIST_H

#include <stdio.h>

#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode

{

    ElementType Data;

    struct tagNode* PrevNode;

    struct tagNode* NextNode;

} Node;

/* 함수 원형 선언 */

Node* DLL_CreateNode( ElementType NewData );

void  DLL_DestroyNode( Node* Node);

void  DLL_AppendNode( Node** Head, Node* NewNode );

void  DLL_InsertAfter( Node* Current, Node* NewNode );

void  DLL_RemoveNode( Node** Head, Node* Remove );

Node* DLL_GetNodeAt( Node* Head, int Location );

int   DLL_GetNodeCount( Node* Head );

#endif DOUBLY_LINKEDLIST_H

#include "DoublyLinkedList.h"

/*  노드 생성 */

Node* DLL_CreateNode( ElementType NewData )

{

    Node* NewNode = (Node*)malloc(sizeof(Node));

    NewNode->Data = NewData;

    NewNode->PrevNode = NULL;

    NewNode->NextNode = NULL;

    return NewNode;

}

/*  노드 소멸 */

void DLL_DestroyNode( Node* Node )

{

    free(Node);

}

/*  노드 추가 */

void DLL_AppendNode( Node** Head, Node* NewNode )

{

    /*  헤드 노드가 NULL이라면 새로운 노드가 Head */

    if ( (*Head) == NULL ) 

    {

        *Head = NewNode;

    } 

    else

    {

        /*  테일을 찾아 NewNode를 연결한다. */

        Node* Tail = (*Head);

        while ( Tail->NextNode != NULL )

        {

            Tail = Tail->NextNode;

        }

        Tail->NextNode = NewNode;

        NewNode->PrevNode = Tail; /*  기존의 테일을 새로운 테일의 PrevNode가 가리킨다. */

    }

}

/*  노드 삽입 */

void DLL_InsertAfter( Node* Current, Node* NewNode )

{

    NewNode->NextNode = Current->NextNode;

    NewNode->PrevNode = Current;

    if ( Current->NextNode != NULL )

    {

        Current->NextNode->PrevNode = NewNode;

    Current->NextNode = NewNode;

    }

}

/*  노드 제거 */

void DLL_RemoveNode( Node** Head, Node* Remove )

{

    if ( *Head == Remove )

    {

        *Head = Remove->NextNode;

        if ( (*Head) != NULL )

            (*Head)->PrevNode = NULL;

        Remove->PrevNode = NULL;

        Remove->NextNode = NULL;

    }

    else

    {

        Node* Temp = Remove;

        if ( Remove->PrevNode != NULL )

            Remove->PrevNode->NextNode = Temp->NextNode;

        if ( Remove->NextNode != NULL )

            Remove->NextNode->PrevNode = Temp->PrevNode;

        Remove->PrevNode = NULL;

        Remove->NextNode = NULL;

    }    

}

/*  노드 탐색 */

Node* DLL_GetNodeAt( Node* Head, int Location )

{

    Node* Current = Head;

    while ( Current != NULL && (--Location) >= 0)

    {

        Current = Current->NextNode;

    }

    return Current;

}

/*  노드 수 세기 */

int DLL_GetNodeCount( Node* Head )

{

    unsigned int  Count = 0;

    Node*         Current = Head;

    while ( Current != NULL )

    {

        Current = Current->NextNode;

        Count++;

    }

    return Count;

}

void PrintNode( Node* _Node )

{

    if ( _Node->PrevNode == NULL )

        printf("Prev: NULL");

    else

        printf("Prev: %d", _Node->PrevNode->Data);

    printf(" Current: %d ", _Node->Data);

    if ( _Node->NextNode == NULL )

        printf("Next: NULL\n");

    else

        printf("Next: %d\n", _Node->NextNode->Data);

}

#ifndef LINKEDLIST_H

#define LINKEDLIST_H

#include <stdio.h>

#include <stdlib.h>

typedef int ElementType;

typedef struct tagNode

{

    ElementType Data;

    struct tagNode* NextNode;

} Node;

/* 함수 원형 선언 */

Node* SLL_CreateNode(ElementType NewData);

void  SLL_DestroyNode(Node* Node);

void  SLL_AppendNode(Node** Head, Node* NewNode);

void  SLL_InsertAfter(Node* Current, Node* NewNode);

void  SLL_InsertNewHead(Node** Head, Node* NewHead);

void SLL_InsertBefore(Node** Head, Node* current, Node* NewNode);

void  SLL_RemoveNode(Node** Head, Node* Remove);

void SLL_DestroyAllNodes(Node** List);

Node* SLL_GetNodeAt(Node* Head, int Location);

int   SLL_GetNodeCount(Node* Head);

#endif

#include "LinkedList.h"

/*  노드 생성 */

Node* SLL_CreateNode(ElementType NewData)

{

    Node* NewNode = (Node*)malloc(sizeof(Node));

    NewNode->Data = NewData;  /*  데이터를 저장한다. */

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

    return NewNode;/*  노드의 주소를 반환한다. */

}

/*  노드 소멸 */

void SLL_DestroyNode(Node* Node)

{

    free(Node);

}

/*  노드 추가 (태일에 노드 추가)*/

void SLL_AppendNode(Node** Head, Node* NewNode)

{

    /*  헤드 노드가 NULL이라면 새로운 노드가 Head */

    if ( (*Head) == NULL ) 

    {        

        *Head = NewNode;

    } 

    else

    {

        /*  테일을 찾아 NewNode를 연결한다. */

        Node* Tail = (*Head);

        while ( Tail->NextNode != NULL )

        {

            Tail = Tail->NextNode;

        }

        Tail->NextNode = NewNode;

    }

}

/*  노드 삽입 (현재 노드 뒤에 삽입) */

void SLL_InsertAfter(Node* Current, Node* NewNode)

{

    NewNode->NextNode = Current->NextNode;

    Current->NextNode = NewNode;

}

/* 노드 삽입 (머리노드 앞에 새로운 노드 삽입) */

void SLL_InsertBefore(Node** Head, Node* Current, Node* NewHead)

{

Newnode->NextNode = Current;

*Head = Newnode;

}

void  SLL_InsertNewHead(Node** Head, Node* NewHead)

{

    if ( Head == NULL )

    {

        (*Head) = NewHead;    

    }

    else

    {

        NewHead->NextNode = (*Head);

        (*Head) = NewHead;

    }

}

/*  노드 제거 */

void SLL_RemoveNode(Node** Head, Node* Remove)

{

    if ( *Head == Remove )

    {

        *Head = Remove->NextNode;

    }

    else

    {

        Node* Current = *Head;

        while ( Current != NULL && Current->NextNode != Remove )

        {

            Current = Current->NextNode;

        }

        if ( Current != NULL )

            Current->NextNode = Remove->NextNode;

    }

}

/* 모든 노드 제거 */

void SLL_DestroyAllNodes(Node** List)

{

Node* Current = *List;

Node* Next = Current->NextNode;

while(Current != NULL)

{

SLL_DestroyNode(Current);

Current = Next;

Next = Current->NextNode;

}

}

/*  노드 탐색 */

Node* SLL_GetNodeAt(Node* Head, int Location)

{

    Node* Current = Head;

    while ( Current != NULL && (--Location) >= 0)

    {

        Current = Current->NextNode;

    }

    return Current;

}

/*  노드 수 세기 */

int SLL_GetNodeCount(Node* Head)

{

    int   Count = 0;

    Node* Current = Head;

    while ( Current != NULL )

    {

        Current = Current->NextNode;

        Count++;

    }

    return Count;

}