linked+ queue+ stack + 덱

#include<stdio.h>
#include<stdlib.h>
#define NO 0
#define EXIST 1
typedef int element;
typedef struct linkedType
{
    element data;
    struct linkedType* next;
}linkedType, *linkedTypePointer;
typedef struct
{
    linkedTypePointer head;
    linkedTypePointer tail;
    int dataCnt;
}nodeType, *nodeTypePointer;
void menu()
{
    printf("[1] dataInsert\n");
    printf("[2] dataPrintf\n");
    printf("[3] dataFirstRemove\n");
    printf("[9] END\n");
}
//FUNCTION
void create(nodeTypePointer);//[1]
void dataInsert(nodeTypePointer);//[2] +
void dataPrintf(nodeTypePointer);//[3]
void dataFirstRemove(nodeTypePointer);//[4] -
void dataLastRemove(nodeTypePointer);//[5] -
void dataWantYouRemove(nodeTypePointer);//[6] -
void dataFirstPlus(nodeTypePointer);//[7] +
void dataLastPlus(nodeTypePointer);//[8] +
void dataAllRemove(nodeTypePointer);//[9] -
void dataPositionInsert(nodeTypePointer);//[10]+
void dataPositionRemove(nodeTypePointer);//[11]-
int main(void)
{
    nodeType head;
    create(&head);
    dataInsert(&head);
    dataInsert(&head);
    dataInsert(&head);
    dataInsert(&head);
    dataInsert(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataFirstRemove(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataLastRemove(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataWantYouRemove(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataFirstPlus(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataLastPlus(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataPositionInsert(&head);
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    dataAllRemove(&head);//**
    dataPrintf(&head);
    printf("----------------------------------------------------\n");
    return 0;
}
void create(nodeTypePointer L)//[1]
{
    //---------- head --------------------------------------
    L->head = (linkedTypePointer)malloc(sizeof(linkedType));
    L->head->data = 0;
    L->head->next = NULL;

    //---------- tail --------------------------------------
    L->tail = (linkedTypePointer)malloc(sizeof(linkedType));
    L->tail->data = 0;
    L->tail->next = NULL;

    //---------- dataCnt -----------------------------------
    L->dataCnt = 0;
}
void dataInsert(nodeTypePointer L)//[2]
{
    linkedTypePointer newData_Node = (linkedTypePointer)malloc(sizeof(linkedType));
    linkedTypePointer temp_link = L->tail->next;
    int data_insert = 0;
    if (newData_Node == NULL)
    {
        printf("fail\n");
        return;//END
    }
    else//newData_Node != NULL
    {
        //------- NEW DATA SETTING --------
        newData_Node->data = 0;
        newData_Node->next = NULL;
        L->dataCnt += 1;
        printf("data insert>> ");
        scanf("%d", &data_insert);
        newData_Node->data = data_insert;
        //---------------------------------

        //------- DATA_INSERT -------
        //case[1]
        if (L->head->next == NULL)
        {
            L->head->next = newData_Node;
            L->tail->next = newData_Node;

        }
            //case[2]
        else//L->head != NULL
        {
            temp_link->next = newData_Node;
            L->tail->next = newData_Node;
        }
    }
}
void dataPrintf(nodeTypePointer L)//[3]
{
    int i = 1;
    linkedTypePointer index_Node = NULL;
    if (L->dataCnt == 0)
    {
        printf("data empty\n");
        return;//END
    }
    else
    {
        for (index_Node = L->head->next; index_Node !=NULL; index_Node = index_Node->next,i++)
        {
            printf("Address[%p]  [%d]->data[%d]\n",index_Node,i, index_Node->data);
        }
        printf("dataCnt->[%d]\n",L->dataCnt);
    }
}
void dataFirstRemove(nodeTypePointer L)//[4]
{
    linkedTypePointer delete_node = L->head->next;
    if(delete_node == NULL)
    {
        printf("data is empty!\n");
        return;
    }
    else
        //delete_node != NULL
    {
        L->dataCnt -= 1;
        if(L->head->next == L->tail->next)
        {
            L->head->next = NULL;
            L->tail->next = NULL;
            free(delete_node);
            return;//END
        }
        else
            //L->head->next != L->tail->next
        {
            L->head->next = delete_node->next;
            free(delete_node);
            return;//END;
        }
    }
}
void dataLastRemove(nodeTypePointer L)//[5]
{
    linkedTypePointer delete_node = L->tail->next;
    linkedTypePointer index_Node  = NULL;
    if(delete_node == NULL)
    {
        printf("data empty!!\n");
        return;//END
    }
    else
        //delete_node !=NULL
    {
        L->dataCnt -= 1;
        if(L->head->next == L->tail->next)
        {
            L->head->next = NULL;
            L->tail->next = NULL;
            free(delete_node);
        }
        else
        {
            for (index_Node = L->head->next;;index_Node = index_Node->next)
            {
                if(index_Node->next == L->tail->next)
                {
                    break;
                }
            }
            L->tail->next = index_Node;
            index_Node->next = NULL;
            free(delete_node);
        }
    }
}
void dataWantYouRemove(nodeTypePointer L)//[6]
{
    linkedTypePointer index_node_next = L->head->next;
    linkedTypePointer index_node_prev = L->head;
    linkedTypePointer delete_node = NULL;
    int result = NO;
    int delete_data = 0;
    if( index_node_next == NULL)
    {
        printf("data empty!!\n");
        return;//END
    }
    else
        //L->head->next != NULL
    {
        printf("data_remove? ");
        scanf("%d", &delete_data);
        while(index_node_next != NULL)
        {
            if(index_node_next->data == delete_data)
            {
                    //case [1]
                if(L->head->next == L->tail->next)
                {
                    L->dataCnt -= 1;
                    L->head->next = NULL;
                    L->tail->next = NULL;
                    delete_node = index_node_next;
                    free(delete_node);
                    result = EXIST;
                    break;
                }
                    //case[2]
                else
                {
                    if(index_node_next == L->tail->next)
                    {
                        L->dataCnt -= 1;
                        L->tail->next = index_node_prev;
                        L->tail->next->next = NULL;
                        delete_node = index_node_next;
                        free(delete_node);
                        result = EXIST;
                        break;
                    }
                    else
                    {
                        L->dataCnt -= 1;
                        index_node_prev->next = index_node_next->next;
                        delete_node = index_node_next;
                        free(delete_node);
                        result = EXIST;
                        break;
                    }
                }
            }
            index_node_next = index_node_next->next;
            index_node_prev = index_node_prev->next;
        }
    }
    if(result == NO)
    {
        printf("data != remove\n");
    }
}
void dataFirstPlus(nodeTypePointer L)//[7] +
{
    int data_plus_integer = 0;
    linkedTypePointer data_first_insert = (linkedTypePointer)malloc(sizeof(linkedType));
    if(data_first_insert == NULL)
    {
        printf("fail!!\n");
        return;//END
    }
    else
    {
        data_first_insert->data = 0;
        data_first_insert->next = NULL;
        L->dataCnt +=1;
        printf("first data input: ");
        scanf("%d",&data_plus_integer);
        data_first_insert->data = data_plus_integer;

        if(L->head->next == NULL)
        {
            L->head->next = data_first_insert;
            L->tail->next = data_first_insert;
        }
        else
        {
            data_first_insert->next = L->head->next;
            L->head->next = data_first_insert;
        }
    }
}
void dataLastPlus(nodeTypePointer L)//[8] +
{
    linkedTypePointer data_last_insert = (linkedTypePointer)malloc(sizeof(linkedType));
    int data_last;
    if(data_last_insert == NULL)
    {
        printf("fail!!\n");
        return;//END
    }
    else
        //data_last_insert != NULL
    {

        L->dataCnt +=1;
        printf("last data input: ");
        scanf("%d", &data_last);
        data_last_insert->data = data_last;
        data_last_insert->next = NULL;

        if(L->head->next == NULL)
        {
            L->head->next = data_last_insert;
            L->tail->next = data_last_insert;
        }
        else//(L->head->next == NULL)
        {
            L->tail->next->next = data_last_insert;
            L->tail->next = data_last_insert;
        }
    }
}
void dataAllRemove(nodeTypePointer L)//[9] -
{
    linkedTypePointer data_remove = NULL;
    if(L->head->next == NULL)
    {
        printf("data emprt set!!\n");
        return;//END
    }
    else//L->head->next != NULL
    {
        L->tail->next = NULL;
        data_remove = L->head->next;
        while(data_remove != NULL)
        {
            printf("remove address[%p]\n", data_remove);
            L->head->next = data_remove->next;
            free(data_remove);
            L->dataCnt -=1;
            data_remove = L->head->next;
        }
        printf("head->next [%p]\n", L->head->next);
        printf("tail->next [%p]\n", L->tail->next);

        data_remove = L->head;
        free(data_remove);
        data_remove = L->tail;
        free(data_remove);

        printf("head [%p]\n", L->head);
        printf("tail [%p]\n", L->tail);
        printf("dataCnt [%d]\n", L->dataCnt);
    }
}
void dataPositionInsert(nodeTypePointer L)//[10] +
{
    int index;
    int position=0;
    int insert_data = 0;
    int temp = 0;
    linkedTypePointer index_node = L->head;
    linkedTypePointer new_data_node = (linkedTypePointer)malloc(sizeof(linkedType));
    if(new_data_node == NULL)
    {
        printf("fail!!\n");
        return;//END
    }
    else
    {
        // -------------- data setting ---------------
        new_data_node->next = NULL;
        new_data_node->data = 0;
        printf("[1] <= position <= [%d]\n", L->dataCnt);
        printf("position input>> ");
        scanf("%d", &position);
        printf("data input>> ");
        scanf("%d", &insert_data);
        new_data_node->data = insert_data;
        // -------------------------------------------
        if (position == L->dataCnt + 1)
        {
            L->dataCnt += 1;
            L->tail->next->next = new_data_node;
            L->tail->next = new_data_node;
            return;
        }
        else if (position == L->dataCnt)
        {
            L->dataCnt += 1;
            temp = L->tail->next->data;
            L->tail->next->data = new_data_node->data;
            new_data_node->data = temp;
            L->tail->next->next = new_data_node;
            L->tail->next = new_data_node;
            return;
        }
        else//(position != L->dataCnt + 1)
        {
            L->dataCnt += 1;
            for (index = 1; index < position; index++)
            {
                index_node = index_node->next;
            }
            new_data_node->next = index_node->next;
            index_node->next = new_data_node;
            return;
        }

    }
}
void dataPositionRemove(nodeTypePointer L)
{
    
}