c언어 linkedlist

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

typedef struct node_{

	char cData;
	struct node_* nodeNext;
} node_;

typedef struct {

	node_* head;
	node_* tail;
}linkedlist;

linkedlist* createNode();
void init(linkedlist**);
void dataInsrt(linkedlist**, char*);
void dataPrint(linkedlist**);
void firstNodeRemove(linkedlist**); 
void lastNodeRemove(linkedlist**);
void memoryFree(linkedlist**);

//void memoryFree(node_*);

int main(void) {

	linkedlist* node = NULL;
	char nodeString[] = "ABCDEFGC";

	node = createNode();
	init(&node);
	dataInsrt(&node, nodeString);
	dataPrint(&node);
	//memoryFree(node->head->nodeNext);
    firstNodeRemove(&node);
	dataPrint(&node);
    lastNodeRemove(&node);
    dataPrint(&node);
    memoryFree(&node);

    return 0;

} // end of main function

linkedlist* createNode() {

	linkedlist* createNode = NULL;
	createNode = (linkedlist*)malloc(sizeof(linkedlist));

	if (createNode == NULL) {
		exit(1);
	}
	else {
		createNode->head = NULL;
		createNode->tail = NULL;
	}
	return createNode;
} // end of createNode function

void init(linkedlist** param) {

	(**param).head = (node_*)malloc(sizeof(node_));
	(**param).tail = (node_*)malloc(sizeof(node_));

	if ((**param).head == NULL || (**param).tail == NULL) {
		exit(1);
	}
	else {

		(**param).head->cData = ' ';
		(**param).head->nodeNext = NULL;
		(**param).tail->cData = ' ';
		(**param).tail->nodeNext = NULL;
	}
} // end of init function

void dataInsrt(linkedlist** param, char* cData) {

	
	for (unsigned int i = 0; i < strlen(cData); i++) {
	
		node_* createNode = NULL;
		createNode = (node_*)malloc(sizeof(node_));

		if (createNode != NULL) {
			
			createNode->cData = *(cData + i);

			createNode->nodeNext = NULL;

			if ((**param).head->nodeNext == NULL && (**param).tail->nodeNext == NULL) {
				
				(**param).head->nodeNext = createNode;
				(**param).tail->nodeNext = createNode;
			}
			else {
				
				(**param).tail->nodeNext->nodeNext = createNode;
				(**param).tail->nodeNext = createNode;
			}
		}
	}
} // end of dataInsrt function

void dataPrint(linkedlist** param) {

	node_* indexNode = NULL;

	// 데이터가 한개도 없는 경우
	if ((**param).head->nodeNext != NULL && (**param).tail->nodeNext != NULL) {

		indexNode = (**param).head->nodeNext;
		while (indexNode != NULL) {
			printf("%c [%p]", indexNode->cData, indexNode);

			if (indexNode->nodeNext != NULL) {

				printf(" -> ");
			}
			// 노드 이동
			indexNode = indexNode->nodeNext;
		}
		printf("\n");
	}
} // end of dataPrint function

/*
void memoryFree(node_* param) {

	// c언어는 java 처럼 가비지 컬렉터가 따로 동작하는 구조가 아니기 때문에 
	// 메모리 해제를 반드시 해야 한다.
	// 재귀함수를 사용하여 메모리 해제를 시도한다.

	if (param == NULL) {
		return;
	}
	else {

		node_* rmNode = NULL;
		node_* mvNode = NULL;

		printf("해제 시킬 메모리 주소 : %p\n", param);

		rmNode = param;
		mvNode = param->nodeNext;
		free(rmNode);
		memoryFree(mvNode);
	}
}*/


void firstNodeRemove(linkedlist** param) {
    
    node_* rmNode = NULL;

    if ( (**param).head->nodeNext != NULL && (**param).tail->nodeNext != NULL ) {
        
        rmNode = (**param).head->nodeNext;
        (**param).head->nodeNext = rmNode->nodeNext;
        free(rmNode);

        // 데이터가 한개 인 경우
        if ( (**param).head->nodeNext == (**param).tail->nodeNext ) {
    
            (**param).tail->nodeNext = NULL;
        } 
        
    }
} // end of firstNodeRemove function

void lastNodeRemove(linkedlist** param) {
    
    node_* rmNode   = NULL;
    node_* indxNode = NULL;

    if ( (**param).head->nodeNext != NULL && (**param).tail->nodeNext != NULL ) {

       // 데이터가 한개 인 경우
       if ( (**param).head->nodeNext == (**param).tail->nodeNext ) {
           
           rmNode = (**param).head->nodeNext;
           (**param).head->nodeNext = NULL;
           (**param).tail->nodeNext = NULL;
           free(rmNode);
       }
       else {

           indxNode = (**param).head->nodeNext;
           while (indxNode->nodeNext->nodeNext != NULL) {
                
               indxNode = indxNode->nodeNext;
           }
           indxNode->nodeNext = NULL;
           (**param).tail->nodeNext = indxNode;
           rmNode = indxNode->nodeNext;
           free(rmNode);
       }
    }
} // end of lastNodeRemove function

void memoryFree(linkedlist** param) {

    node_* rmNode   = NULL;
    node_* indxNode = NULL;

    if ( (**param).head->nodeNext != NULL && (**param).tail->nodeNext != NULL ) {
        
        // 데이터가 한개 인 경우
        if ( (**param).head->nodeNext == (**param).tail->nodeNext ) {
            lastNodeRemove(param);
        } 
        else {
            indxNode = (**param).head->nodeNext;
            (**param).head->nodeNext = NULL;

            while (indxNode->nodeNext != NULL) {
                rmNode = indxNode;
                indxNode = indxNode->nodeNext;
                free(rmNode);
            }

            (**param).tail->nodeNext = NULL;
        }
    }

    free( (**param).head );
    free( (**param).tail );
}