c언어 구현 linkedlist

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define _SIZE_ 50
#define _TRUE_ 1
 
typedef struct _linkedlist {
    char name [_SIZE_]; // 이름
    int num; // 고유 넘버
    int HP; // 체
    struct _linkedlist *pnext;
}linkedlist;
 
typedef struct _node {
    linkedlist* HEAD;
    linkedlist* TAIL;
    int dataCnt;
}node;
 
// _____ [ Function prototype ] ____________________________________
void ERROR(char* errorMessage); //________________ [1]__ 에러 컨트롤
void IN(node** ppnode); // _______________________ [2]__ 초기화
void ADD(node** ppnode); // ______________________ [3]__ 추가
void PRT(node** ppnode); // ______________________ [4]__ 출력
void DEL(node** ppnode); // ______________________ [5]__ 삭제
//__________________________________________________________________
int main (void) {
    node* _start = NULL;
    IN(&_start);
    ADD(&_start);
    ADD(&_start);
    ADD(&_start);
    ADD(&_start);
    PRT(&_start);
    DEL(&_start);
    PRT(&_start);
    return 0;
}
void ERROR(char* errorMessage) {//_______________ [1]__ 에러 컨트 
    fprintf(stdout, "%s", errorMessage);
    exit(0);
} // end of [ERROR] function
 
void IN(node** ppnode) { //______________________ [2]__ 초기 
    (* ppnode) = (node*)malloc(sizeof(node));
    if ( (* ppnode) == NULL ) {
        ERROR(" MALLO_FAIL !!");
    } else {
        (* ppnode)->dataCnt = 0;
        (* ppnode)->HEAD = (linkedlist*)malloc(sizeof(linkedlist));
        memset((* ppnode)->HEAD, 0, sizeof(linkedlist));
        (* ppnode)->TAIL = (linkedlist*)malloc(sizeof(linkedlist));
        memset((* ppnode)->TAIL, 0, sizeof(linkedlist));
    }
 
} // end of [IN] function
 
void newNodeIn(linkedlist** ppnode) {
    strcpy( (**ppnode).name , " ");
    (**ppnode).num = 0;
    (**ppnode).HP = 0;
    (**ppnode).pnext = NULL;
} // end of [newNodeIn] function
 
void duplicate(node** ppnode, linkedlist** pp_new) {
    linkedlist* tempIndex = NULL;
    int i; // for_index
    int tmpCnt = 0;
    int result = 0;
    while( _TRUE_ ) {
        if ((** ppnode).dataCnt == 0 ) {
            fprintf(stdout, "%s\n", " 입력하신 번호와 중복되는 번호는 없습니다. ");
            break;
        } else { // (** ppnode).dataCnt != 0
            tempIndex = (** ppnode).HEAD->pnext;
            if ( tmpCnt == 2 ) {
                fprintf(stdout, "%s ", " 리스트 [번호]현황입니다. ");
                for ( i = 0; i < (** ppnode).dataCnt; i++ ) {
                    printf("%d ", tempIndex->num);
                    tempIndex = tempIndex->pnext;
                }
                tmpCnt = 0;
                tempIndex = (** ppnode).HEAD->pnext;
            } else { // tmpCnt <2
                for ( i = 0; i < (** ppnode).dataCnt; i++ ) {
                    if ( tempIndex->num == (** pp_new).num) {
                        fprintf(stdout, "%s\n", " 중복되는 번호가 있습니다. 다시 입력해주세요 ");
                        tmpCnt ++;
                        result = 1;
                        break;
                    }
                    else {
                        tempIndex = tempIndex->pnext;
                        result = 0;
                    }
                }
            }
        }
        if (result == 1) {
            fprintf(stdout, "%s ", " 번호 입력 : ");
            scanf("%d", &((*pp_new)->num));
            fflush(stdin); 
        } else {
            fprintf(stdout, "%s\n", " 입력하신 번호와 중복되는 번호는 없습니다. ");
            break;
        }
        system("cls");    
    }
} // end of [duplicate] function
 
void ADD(node** ppnode) {
    system("cls");
    // 새로 추가할 노드 정보
    linkedlist *p = (linkedlist*)malloc(sizeof(linkedlist)); // 새로 추가할 노드
    newNodeIn(&p);
    fprintf(stdout, "%s", "번호 입력 : ");
    scanf("%d", &(p->num));
    fflush(stdin);
    duplicate(ppnode, &p);
    fprintf(stdout, "%s", "이름 입력 : ");
    gets( p->name );
    fflush(stdin);
    fprintf(stdout, "%s", "체력 입력 : ");
    scanf("%d", &(p->HP));
    system("cls");
    //데이터 삽입
    if ( (**ppnode).dataCnt == 0 ) {
        (**ppnode).HEAD->pnext = p;
        (**ppnode).TAIL->pnext = p;
        (**ppnode).dataCnt ++ ;
    } else {
        (**ppnode).TAIL->pnext->pnext = p;
        (**ppnode).TAIL->pnext = p;
        (**ppnode).dataCnt ++ ;
    }
} // end of [ADD] function
    
void PRT(node** ppnode) {
    linkedlist* nodeIndex = NULL;
    int i; // index
    if ( (**ppnode).dataCnt == 0) { 
        ERROR("출력할 데이터가 없습니다.");
    } else { // (**ppnode).dataCnt != 0
        nodeIndex = (**ppnode).HEAD->pnext;
        for (i = 0; i< (**ppnode).dataCnt; i++) {
            printf("[%d] ====================== \n", i+1); 
            printf("nodeIndex-> num : %d \n", nodeIndex->num);
            printf("nodeIndex-> name : %s \n", nodeIndex->name); 
            printf("nodeIndex-> HP : %d \n", nodeIndex->HP);
            printf("=========================== \n");
            nodeIndex = nodeIndex->pnext;
        }
    } 
} // end of [PRT] function
void DEL(node** ppnode) {
    linkedlist* prev = NULL;
    linkedlist* next = NULL;
    linkedlist* removeNode = NULL;
    int remTarget = 0; // 삭제할 데이터의 타겟
    int i; // index
 
    // 리스트에 데이터가 있는지 확인
    if ( (** ppnode).dataCnt == 0 ) {
        ERROR("삭제할 데이터가 없습니다.");
    } else { // (** ppnode).dataCnt != 0
        prev = (** ppnode).HEAD;
        next = (** ppnode).HEAD->pnext;
        fprintf(stdout, "%s ", "삭제할 데이터의 고유번호 입력 : ");
        scanf("%d", &remTarget);
        fflush(stdin);
        for (i = 0 ; i < (** ppnode).dataCnt ; i++) {
            if (next->num == remTarget) {
                if ( next == (** ppnode).HEAD->pnext ) {
                    if ( next == (** ppnode).TAIL->pnext ) {
                        fprintf(stdout, "%s\n", "삭제할 데이터를 찾았습니다.");
                        removeNode = next;
                        (** ppnode).HEAD->pnext = NULL;
                        (** ppnode).TAIL->pnext = NULL;
                        (** ppnode).dataCnt --;
                        free(removeNode);
                        break;
                    } else { // next != (** ppnode).TAIL->pnext
                        fprintf(stdout, "%s\n", "삭제할 데이터를 찾았습니다.");
                        removeNode = next;
                        (** ppnode).HEAD->pnext = removeNode->pnext;
                        (** ppnode).dataCnt --;
                        free(removeNode);
                        break;
                    }
                }
                else { // next != (** ppnode).HEAD->pnext
                    if ( next == (** ppnode).TAIL->pnext ) {
                        fprintf(stdout, "%s\n", "삭제할 데이터를 찾았습니다.");
                        removeNode = next;
                        (** ppnode).TAIL->pnext = prev;
                         (** ppnode).dataCnt --;
                        free(removeNode);
                        break;
                    } else { // next != (** ppnode).TAIL->pnext
                        fprintf(stdout, "%s\n", "삭제할 데이터를 찾았습니다.");
                        removeNode = next;
                        prev->pnext = next->pnext;
                        (** ppnode).dataCnt --;
                        free(removeNode);
                        break;
                    }
 
                }
            }
            else {
                next = next->pnext;
                prev = prev->pnext;
            }
        }
    }
}