[자료구조]단일연결리스트(C 반복문)

학교 과제로 C로 단일연결리스트 짰다.

C++로 구현하면 제네릭 프로그래밍이 가능한데 C는 ... 무안하다. nullptr도 없고 소멸자도없고; 

아무튼 링크드리스트의 크기를 명시해주면 삽입,삭제가 수월하다.

#include <stdio.h>
#include <stdlib.h> 
typedef struct Node
{
    int value;
    struct Node *next_node;
}Node;
 
typedef struct LinkedList
{
    struct Node *head;
    unsigned int size;
}LinkedList;
 
void Insert(struct LinkedList *list,int v); 
void Remove(struct LinkedList *list,int n);
void Print(struct LinkedList *list);
void Reserve(struct LinkedList *list);
void Search(struct LinkedList *list,int v);
void LinkingNode(struct Node *prev,Node *next); // 이전 노드와 다음 노드를 잇는다.
void LinkingList(struct LinkedList *list1,struct LinkedList *list2);
void FreeLinkedList(struct LinkedList *list);
int main()
{
    LinkedList myList = {NULL,0};
    Insert(&myList,30);
    Insert(&myList,20);
    Insert(&myList,10);
    Print(&myList);
    Remove(&myList,1);
    Print(&myList);
 
    LinkedList myList2 = {NULL,0};
    Insert(&myList2,80);
    Insert(&myList2,70);
    Insert(&myList2,60);
    Print(&myList2);
    LinkingList(&myList,&myList2);
    Print(&myList);
    Reserve(&myList);
    Print(&myList);
    Search(&myList,20);
 
    FreeLinkedList(&myList);
    FreeLinkedList(&myList2);
}
 
void LinkingNode(struct Node *prev,struct Node *next)
{
    prev->next_node = next;
}
 
void LinkingList(struct LinkedList *list1,struct LinkedList *list2)
{    
    Node *linker = list1->head;
    for(int i=1;i<list1->size;i++)
    {
        linker = linker->next_node;
    }
        linker->next_node = list2->head;
    list1->size += list2->size;
}
 
void FreeLinkedList(struct LinkedList *list)
{
    Node *cur = list->head;
    Node *temp;
    for(int i=0;i<list->size;i++){
        temp = cur;
        cur = cur->next_node;
        free(temp);
    }
}
void Insert(struct LinkedList *list,int v)
{
    if(list->size == 0){
        list->head = (Node *)malloc(sizeof(Node));
        list->head->value= v;
    } else{
        Node *cur = list->head;
        for(int i=0;i<list->size-1;i++){
            cur = cur->next_node;    
        }
        cur->next_node = (Node *)malloc(sizeof(Node));
        cur->next_node->value = v;
    }
    list->size++;
}
 
void Remove(struct LinkedList *list,int n)
{
    if(list->size == 0 || list->size < n) return;
    if(n == 1){
        Node *del_node = list->head;
        list->head = list->head->next_node;
        free(del_node);
        list->size--;
        return;
    } else if(n == 2){
        Node *del_node = list->head->next_node;
        LinkingNode(list->head,del_node->next_node);
        free(del_node);
        list->size--;
        return;
    } else{
        Node *cur = list->head;
        for(int i=1;i<n-1;i++)
            cur = cur->next_node;
        Node *del_node = cur->next_node;
        LinkingNode(cur,del_node->next_node);
        free(del_node);
        list->size--;
    }
}
 
void Print(struct LinkedList *list)
{
    Node *cur = list->head;
    for(int i=0;i<list->size;i++){
        printf("%d->",cur->value);
        cur = cur->next_node;
    }
    printf("\n");
}
 
void Reserve(struct LinkedList *list)
{
    Node * cur = list->head;
    int *temp = (int *)malloc(sizeof(temp)*list->size);
    for(int i=0;i<list->size;i++)
    {
        temp[i] = cur->value;
        cur = cur->next_node;
    }    
    cur = list->head;
    for(int i=list->size-1;i>=0;i--)
    {
        cur->value = temp[i];
        cur = cur->next_node;
    }
    free(temp);
 
}
 
void Search(struct LinkedList *list,int v)
{
    Node *cur = list->head;
    for(int i=0;i<list->size;i++)
    {
        if(cur->value == v){
            printf("탐색 성공 : %d\n",cur->value);
            return;
        }
        cur = cur->next_node;
    }
    printf("탐색 실패\n");    
}