C언어 연결 리스트로 폴더 탐색기 구현하기

C언어에서 연결 리스트를 활용하여 폴더 탐색기를 구현하는 방법을 배울 수 있습니다. 연결 리스트는 동적 데이터 구조로, 유연한 메모리 사용과 효율적인 데이터 관리를 가능하게 합니다. 이 기사를 통해 폴더 생성, 삭제, 탐색과 같은 기본 기능부터 재귀적 탐색과 응용 기능까지 단계별로 학습해볼 것입니다. 연결 리스트를 이해하고 실제 프로젝트에 활용하는 방법을 익혀보세요.

연결 리스트의 기본 개념

연결 리스트는 데이터 구조의 한 종류로, 각 노드가 데이터와 다음 노드의 주소를 포함하는 형태로 구성됩니다. 이 구조는 배열과 달리 크기가 동적으로 조정될 수 있어, 메모리를 효율적으로 사용할 수 있습니다.

연결 리스트의 구조

연결 리스트는 다음과 같은 노드(Node)로 이루어져 있습니다:

typedef struct Node {
    int data;               // 저장할 데이터
    struct Node* next;      // 다음 노드를 가리키는 포인터
} Node;

이 기본 구조를 통해 노드들이 체인처럼 연결되며, 이를 통해 데이터 삽입, 삭제, 탐색 작업이 가능합니다.

연결 리스트의 특징

동적 크기 조정: 필요에 따라 노드를 추가하거나 삭제할 수 있습니다.
효율적인 삽입 및 삭제: 배열보다 삽입과 삭제가 빠르게 수행됩니다.
순차 접근: 특정 데이터에 접근하려면 순차적으로 탐색해야 합니다.

연결 리스트는 폴더 탐색기의 계층적 데이터 구조를 표현하기에 적합하며, 이를 기반으로 다양한 기능을 구현할 수 있습니다.

C언어에서 연결 리스트 구현

C언어로 연결 리스트를 구현하기 위해 기본적인 노드 구조와 삽입, 삭제, 출력 같은 기본 작업을 구현하는 방법을 살펴보겠습니다.

연결 리스트 노드 정의

연결 리스트의 기본 구성 요소인 노드를 정의합니다.

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

typedef struct Node {
    char folderName[50];      // 폴더 이름
    struct Node* next;        // 다음 노드를 가리키는 포인터
} Node;

노드 추가 함수

새로운 노드를 리스트의 끝에 추가하는 함수입니다.

Node* addNode(Node* head, const char* folderName) {
    Node* newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        printf("메모리 할당 실패\n");
        return head;
    }
    strcpy(newNode->folderName, folderName);
    newNode->next = NULL;

    if (head == NULL) {
        return newNode;  // 리스트가 비어있으면 새로운 노드가 헤드가 됨
    }

    Node* temp = head;
    while (temp->next != NULL) {
        temp = temp->next;
    }
    temp->next = newNode;
    return head;
}

노드 출력 함수

리스트의 모든 폴더 이름을 출력하는 함수입니다.

void printList(Node* head) {
    Node* temp = head;
    while (temp != NULL) {
        printf("%s -> ", temp->folderName);
        temp = temp->next;
    }
    printf("NULL\n");
}

노드 삭제 함수

특정 폴더를 삭제하는 함수입니다.

Node* deleteNode(Node* head, const char* folderName) {
    if (head == NULL) return NULL;

    Node* temp = head;
    if (strcmp(temp->folderName, folderName) == 0) {
        head = temp->next;
        free(temp);
        return head;
    }

    while (temp->next != NULL && strcmp(temp->next->folderName, folderName) != 0) {
        temp = temp->next;
    }

    if (temp->next == NULL) {
        printf("폴더를 찾을 수 없습니다.\n");
        return head;
    }

    Node* nodeToDelete = temp->next;
    temp->next = nodeToDelete->next;
    free(nodeToDelete);
    return head;
}

전체 코드 실행 예시

리스트를 생성하고 폴더를 추가, 삭제, 출력하는 작업을 수행하는 예제입니다.

int main() {
    Node* head = NULL;

    head = addNode(head, "Documents");
    head = addNode(head, "Pictures");
    head = addNode(head, "Downloads");

    printf("폴더 리스트:\n");
    printList(head);

    printf("Downloads 폴더 삭제 후:\n");
    head = deleteNode(head, "Downloads");
    printList(head);

    return 0;
}

이 코드는 연결 리스트를 사용하는 기본적인 C언어 구현을 보여줍니다. 폴더 탐색기 개발의 기초로 활용할 수 있습니다.

폴더 탐색기의 구조 설계

폴더 탐색기를 구현하려면 연결 리스트를 기반으로 폴더 계층 구조를 정의해야 합니다. 각 폴더는 이름과 하위 폴더(또는 파일)에 대한 포인터를 포함하며, 이를 계층적으로 구성해 탐색과 관리가 가능하도록 설계합니다.

폴더 탐색기 데이터 구조

폴더를 표현하기 위한 구조체 설계입니다. 각 폴더는 자신의 이름과 하위 폴더 리스트를 가리키는 포인터를 포함합니다.

typedef struct Folder {
    char folderName[50];        // 폴더 이름
    struct Folder* subFolders;  // 하위 폴더 리스트 (첫 번째 하위 폴더의 포인터)
    struct Folder* next;        // 동일 계층의 다음 폴더
} Folder;

이 구조는 연결 리스트를 사용해 폴더 계층을 표현하며, 트리 형태의 구조로 확장 가능합니다.

폴더 탐색기 구조 설계 개념

최상위 폴더: 탐색기의 루트 폴더로, 모든 폴더 탐색이 여기서 시작됩니다.
하위 폴더 연결: subFolders 포인터를 사용해 특정 폴더의 하위 폴더를 연결합니다.
동일 계층 폴더 연결: next 포인터를 사용해 동일한 계층의 폴더들을 연결합니다.
탐색 경로: 특정 폴더로 이동하거나 하위 폴더를 탐색하는 기능 구현을 고려합니다.

폴더 탐색기 계층 구조 예시

다음과 같은 계층 구조를 구현합니다:

Root  
├── Documents  
│   ├── Projects  
│   └── Reports  
├── Pictures  
│   └── Vacation  
└── Downloads

폴더 생성 및 삭제 설계

폴더 생성:

새 폴더를 현재 폴더의 하위 폴더 리스트에 추가하거나, 동일 계층에 추가합니다.
중복된 폴더 이름이 없도록 검사합니다.

폴더 삭제:

삭제하려는 폴더의 하위 폴더와 해당 폴더를 모두 메모리에서 해제합니다.

구조 설계 코드 스니펫

Folder* createFolder(const char* folderName) {
    Folder* newFolder = (Folder*)malloc(sizeof(Folder));
    if (newFolder == NULL) {
        printf("메모리 할당 실패\n");
        return NULL;
    }
    strcpy(newFolder->folderName, folderName);
    newFolder->subFolders = NULL;
    newFolder->next = NULL;
    return newFolder;
}

루트 폴더 생성

탐색기의 시작점이 되는 루트 폴더를 생성합니다.

Folder* initializeExplorer() {
    return createFolder("Root");
}

이 구조를 기반으로 폴더 탐색기의 계층적 구조를 구현하면, 이후 단계에서 폴더 생성, 삭제, 탐색 등의 기능을 추가할 수 있습니다.

폴더 탐색기의 기본 기능 구현

폴더 탐색기를 연결 리스트로 구현하기 위해 폴더 생성, 삭제, 이동과 같은 기본 기능을 설계하고 구현합니다. 이 단계는 폴더 탐색기의 핵심 동작을 정의하는 데 중점을 둡니다.

폴더 생성 기능

새 폴더를 현재 폴더의 하위 폴더 리스트에 추가하는 기능입니다.

void addSubFolder(Folder* parent, const char* folderName) {
    Folder* newFolder = createFolder(folderName);
    if (parent->subFolders == NULL) {
        parent->subFolders = newFolder;  // 첫 번째 하위 폴더로 설정
    } else {
        Folder* temp = parent->subFolders;
        while (temp->next != NULL) {
            temp = temp->next;  // 동일 계층의 끝으로 이동
        }
        temp->next = newFolder;  // 새로운 폴더를 끝에 추가
    }
    printf("폴더 '%s'가 생성되었습니다.\n", folderName);
}

폴더 삭제 기능

특정 폴더와 그 하위 폴더를 삭제하는 기능입니다.

void deleteFolder(Folder* parent, const char* folderName) {
    if (parent == NULL || parent->subFolders == NULL) {
        printf("삭제할 폴더가 없습니다.\n");
        return;
    }

    Folder* temp = parent->subFolders;
    Folder* prev = NULL;

    while (temp != NULL && strcmp(temp->folderName, folderName) != 0) {
        prev = temp;
        temp = temp->next;
    }

    if (temp == NULL) {
        printf("폴더 '%s'를 찾을 수 없습니다.\n", folderName);
        return;
    }

    // 하위 폴더 재귀 삭제
    while (temp->subFolders != NULL) {
        deleteFolder(temp, temp->subFolders->folderName);
    }

    // 연결 리스트에서 제거
    if (prev == NULL) {
        parent->subFolders = temp->next;  // 첫 번째 노드 삭제
    } else {
        prev->next = temp->next;  // 중간 또는 마지막 노드 삭제
    }

    free(temp);
    printf("폴더 '%s'가 삭제되었습니다.\n", folderName);
}

폴더 이동 기능

현재 위치에서 특정 하위 폴더로 이동하는 기능입니다.

Folder* moveToSubFolder(Folder* current, const char* folderName) {
    if (current == NULL || current->subFolders == NULL) {
        printf("하위 폴더가 없습니다.\n");
        return current;
    }

    Folder* temp = current->subFolders;
    while (temp != NULL) {
        if (strcmp(temp->folderName, folderName) == 0) {
            return temp;  // 대상 폴더로 이동
        }
        temp = temp->next;
    }

    printf("폴더 '%s'를 찾을 수 없습니다.\n", folderName);
    return current;  // 현재 위치 유지
}

폴더 리스트 출력 기능

현재 폴더의 하위 폴더 리스트를 출력하는 기능입니다.

void listSubFolders(Folder* parent) {
    if (parent == NULL || parent->subFolders == NULL) {
        printf("하위 폴더가 없습니다.\n");
        return;
    }

    Folder* temp = parent->subFolders;
    printf("'%s' 폴더의 하위 폴더:\n", parent->folderName);
    while (temp != NULL) {
        printf("- %s\n", temp->folderName);
        temp = temp->next;
    }
}

기능 테스트 예제

위의 기능을 종합적으로 테스트하는 코드입니다.

int main() {
    Folder* root = initializeExplorer();

    addSubFolder(root, "Documents");
    addSubFolder(root, "Pictures");
    addSubFolder(root, "Downloads");

    listSubFolders(root);

    root = moveToSubFolder(root, "Documents");
    addSubFolder(root, "Projects");
    addSubFolder(root, "Reports");

    listSubFolders(root);

    root = moveToSubFolder(root, "Root");  // 원래 위치로 복귀 (구현 필요)
    deleteFolder(root, "Downloads");

    listSubFolders(root);

    return 0;
}

이 코드는 폴더 생성, 삭제, 이동과 같은 기본적인 기능을 테스트하여 폴더 탐색기가 의도한 대로 작동하는지 확인합니다.

재귀를 활용한 폴더 탐색

폴더 구조에서 하위 폴더를 재귀적으로 탐색하는 기능은 계층적인 데이터를 효율적으로 처리하는 데 유용합니다. 재귀를 활용하면 하위 폴더의 깊이에 관계없이 전체 폴더를 탐색하거나 특정 작업을 수행할 수 있습니다.

폴더 구조 출력 기능

재귀를 사용하여 현재 폴더와 하위 폴더를 계층적으로 출력하는 코드입니다.

void printFolderStructure(Folder* folder, int depth) {
    if (folder == NULL) return;

    // 현재 폴더 출력
    for (int i = 0; i < depth; i++) {
        printf("  ");  // 들여쓰기
    }
    printf("- %s\n", folder->folderName);

    // 하위 폴더 탐색
    printFolderStructure(folder->subFolders, depth + 1);

    // 동일 계층 폴더 탐색
    printFolderStructure(folder->next, depth);
}

특정 폴더 탐색 기능

폴더 이름을 기준으로 특정 폴더를 재귀적으로 탐색하는 코드입니다.

Folder* findFolder(Folder* folder, const char* folderName) {
    if (folder == NULL) return NULL;

    // 현재 폴더가 목표 폴더인지 확인
    if (strcmp(folder->folderName, folderName) == 0) {
        return folder;
    }

    // 하위 폴더에서 탐색
    Folder* found = findFolder(folder->subFolders, folderName);
    if (found != NULL) {
        return found;
    }

    // 동일 계층 폴더에서 탐색
    return findFolder(folder->next, folderName);
}

응용 예제: 파일 탐색기와 유사한 기능

폴더 구조를 탐색하며 모든 폴더 이름을 출력하는 프로그램의 실행 예제입니다.

int main() {
    Folder* root = initializeExplorer();

    addSubFolder(root, "Documents");
    addSubFolder(root, "Pictures");
    addSubFolder(root, "Downloads");

    Folder* documents = findFolder(root, "Documents");
    if (documents != NULL) {
        addSubFolder(documents, "Projects");
        addSubFolder(documents, "Reports");
    }

    Folder* pictures = findFolder(root, "Pictures");
    if (pictures != NULL) {
        addSubFolder(pictures, "Vacation");
    }

    printf("폴더 구조 출력:\n");
    printFolderStructure(root, 0);

    return 0;
}

폴더 탐색의 주요 장점

단순화된 코드: 재귀를 사용하면 복잡한 계층 구조를 간단하게 탐색할 수 있습니다.
확장 가능성: 추가 기능(예: 폴더 크기 계산, 조건부 필터링 등)을 손쉽게 구현할 수 있습니다.
유지보수성: 계층 구조와 관련된 코드를 일관성 있게 관리할 수 있습니다.

실행 결과

위 코드의 출력 예는 다음과 같습니다:

- Root
  - Documents
    - Projects
    - Reports
  - Pictures
    - Vacation
  - Downloads

재귀를 활용한 탐색은 복잡한 계층적 데이터를 효율적으로 처리하며, 폴더 탐색기와 같은 응용 프로그램에서 매우 유용하게 사용됩니다.

사용자 인터페이스 설계

폴더 탐색기의 사용자 인터페이스(UI)는 사용자와 프로그램이 상호작용할 수 있는 콘솔 기반 시스템으로 설계됩니다. 이를 통해 폴더 생성, 삭제, 이동, 탐색과 같은 작업을 수행할 수 있습니다.

기본 메뉴 설계

사용자가 선택할 수 있는 옵션을 제공하는 메뉴를 설계합니다.

void displayMenu() {
    printf("\n폴더 탐색기 메뉴:\n");
    printf("1. 하위 폴더 추가\n");
    printf("2. 하위 폴더 삭제\n");
    printf("3. 하위 폴더 탐색\n");
    printf("4. 폴더 구조 출력\n");
    printf("5. 종료\n");
    printf("선택: ");
}

메뉴 옵션 처리

사용자의 입력에 따라 적절한 동작을 수행하는 로직입니다.

void handleUserInput(Folder* root) {
    int choice;
    char folderName[50];
    Folder* current = root;

    while (1) {
        displayMenu();
        scanf("%d", &choice);

        switch (choice) {
            case 1:
                printf("추가할 폴더 이름: ");
                scanf("%s", folderName);
                addSubFolder(current, folderName);
                break;

            case 2:
                printf("삭제할 폴더 이름: ");
                scanf("%s", folderName);
                deleteFolder(current, folderName);
                break;

            case 3:
                printf("이동할 하위 폴더 이름: ");
                scanf("%s", folderName);
                Folder* target = moveToSubFolder(current, folderName);
                if (target != current) {
                    current = target;
                    printf("'%s' 폴더로 이동했습니다.\n", current->folderName);
                }
                break;

            case 4:
                printf("폴더 구조:\n");
                printFolderStructure(root, 0);
                break;

            case 5:
                printf("프로그램을 종료합니다.\n");
                return;

            default:
                printf("잘못된 입력입니다. 다시 선택해주세요.\n");
        }
    }
}

메인 함수

폴더 탐색기를 초기화하고, 사용자 인터페이스를 실행하는 메인 코드입니다.

int main() {
    Folder* root = initializeExplorer();
    printf("폴더 탐색기를 시작합니다. 최상위 폴더: '%s'\n", root->folderName);
    handleUserInput(root);
    return 0;
}

사용자 인터페이스의 특징

직관적인 메뉴: 숫자를 입력해 원하는 작업을 쉽게 선택할 수 있습니다.
실시간 피드백: 각 작업 후 결과를 즉시 출력합니다.
동적 상태 변경: 현재 폴더 상태에 따라 동작이 변화합니다.

실행 예시

다음은 프로그램 실행 중 사용자가 입력한 데이터와 출력 예입니다:

폴더 탐색기를 시작합니다. 최상위 폴더: 'Root'

폴더 탐색기 메뉴:
1. 하위 폴더 추가
2. 하위 폴더 삭제
3. 하위 폴더 탐색
4. 폴더 구조 출력
5. 종료
선택: 1
추가할 폴더 이름: Documents

폴더 탐색기 메뉴:
1. 하위 폴더 추가
2. 하위 폴더 삭제
3. 하위 폴더 탐색
4. 폴더 구조 출력
5. 종료
선택: 4
폴더 구조:
- Root
  - Documents

콘솔 기반 사용자 인터페이스는 직관적이고 사용하기 쉬운 환경을 제공하며, 폴더 탐색기의 기능을 효과적으로 테스트할 수 있는 기본적인 시스템을 구축합니다.

디버깅과 성능 최적화

연결 리스트 기반의 폴더 탐색기에서 디버깅과 성능 최적화는 안정성과 효율성을 확보하는 데 필수적입니다. 이 섹션에서는 공통적으로 발생할 수 있는 문제를 해결하는 방법과 성능을 개선할 수 있는 전략을 다룹니다.

디버깅 방법

폴더 탐색기의 주요 디버깅 포인트와 문제 해결 방안입니다.

메모리 할당 오류 확인
동적 메모리를 사용하는 프로그램에서는 메모리 할당 실패가 자주 발생할 수 있습니다. 이를 방지하기 위해 메모리 할당 시 반환값을 항상 확인해야 합니다.

   Folder* newFolder = (Folder*)malloc(sizeof(Folder));
   if (newFolder == NULL) {
       printf("메모리 할당 실패\n");
       exit(EXIT_FAILURE);  // 프로그램 종료
   }

메모리 누수 점검
폴더 삭제 시 모든 하위 폴더와 동일 계층 폴더를 메모리에서 해제해야 합니다.

   void freeFolder(Folder* folder) {
       if (folder == NULL) return;

       // 하위 폴더 메모리 해제
       freeFolder(folder->subFolders);
       // 동일 계층 폴더 메모리 해제
       freeFolder(folder->next);

       free(folder);
   }

NULL 포인터 참조 방지
포인터를 사용할 때 항상 NULL 체크를 수행해 프로그램 충돌을 방지합니다.

   if (folder == NULL) {
       printf("폴더가 없습니다.\n");
       return;
   }

로직 오류 탐색

폴더 이동 또는 탐색 기능에서 잘못된 경로를 반환하는 문제를 로그를 통해 추적합니다.
특정 작업 후 폴더 구조를 출력해 현재 상태를 확인합니다.

성능 최적화

폴더 탐색기의 성능을 개선하기 위한 최적화 방법입니다.

반복 대신 재귀 제한
재귀 호출은 깊이가 깊어질수록 성능에 영향을 미칠 수 있으므로, 재귀 대신 반복 구조를 사용하는 것을 고려합니다.

   void printFolderStructureIterative(Folder* folder) {
       // 반복 구조를 활용해 폴더 탐색
   }

불필요한 탐색 제거
폴더 검색 시 중복 탐색을 줄이고, 캐싱 구조를 도입해 자주 참조되는 폴더를 저장합니다.
동적 할당 최소화
자주 생성되는 폴더 노드는 미리 메모리를 할당해 동적 할당 오버헤드를 줄입니다.
메모리 정리 자동화
프로그램 종료 시 전체 구조를 자동으로 해제하는 기능을 구현합니다.

   void cleanup(Folder* root) {
       freeFolder(root);
       printf("메모리 정리가 완료되었습니다.\n");
   }

디버깅 도구 활용

다음과 같은 디버깅 도구를 활용하면 문제를 보다 쉽게 식별할 수 있습니다:

GDB(Debugger): 코드 중단점 설정 및 변수 값 확인.
Valgrind: 메모리 누수 및 동적 메모리 사용 분석.

테스트 및 개선

테스트 케이스 작성:
다양한 시나리오에서 폴더 생성, 삭제, 이동, 탐색 기능을 테스트합니다.

   void testCases(Folder* root) {
       addSubFolder(root, "TestFolder1");
       addSubFolder(root, "TestFolder2");
       deleteFolder(root, "TestFolder1");
       printFolderStructure(root, 0);
   }

부하 테스트:
대규모 폴더와 하위 폴더를 생성하여 성능을 측정합니다.
버그 리포트 관리:
디버깅 중 발견된 문제를 기록하고 해결 과정을 문서화합니다.

결론

디버깅과 성능 최적화는 연결 리스트 기반 폴더 탐색기의 안정성과 사용자 경험을 향상시키는 데 중요한 역할을 합니다. 이러한 방법을 적용하여 효율적이고 신뢰성 높은 프로그램을 개발할 수 있습니다.

응용 예제: 파일 탐색 기능 추가

폴더 탐색기에 파일 탐색 기능을 추가하면, 폴더 내부의 파일을 관리할 수 있어 더 유용한 프로그램으로 확장할 수 있습니다. 이 섹션에서는 파일을 추가, 삭제, 탐색하는 기능을 구현하는 방법을 다룹니다.

데이터 구조 확장

파일을 저장하기 위해 폴더 구조체에 파일 리스트를 추가합니다.

typedef struct File {
    char fileName[50];        // 파일 이름
    struct File* next;        // 동일 계층의 다음 파일
} File;

typedef struct Folder {
    char folderName[50];      // 폴더 이름
    struct Folder* subFolders; // 하위 폴더 리스트
    struct File* files;       // 파일 리스트
    struct Folder* next;      // 동일 계층의 다음 폴더
} Folder;

파일 추가 기능

현재 폴더에 파일을 추가하는 기능입니다.

void addFile(Folder* folder, const char* fileName) {
    if (folder == NULL) {
        printf("유효하지 않은 폴더입니다.\n");
        return;
    }

    File* newFile = (File*)malloc(sizeof(File));
    if (newFile == NULL) {
        printf("메모리 할당 실패\n");
        return;
    }

    strcpy(newFile->fileName, fileName);
    newFile->next = NULL;

    if (folder->files == NULL) {
        folder->files = newFile;  // 첫 번째 파일로 추가
    } else {
        File* temp = folder->files;
        while (temp->next != NULL) {
            temp = temp->next;  // 동일 계층의 끝으로 이동
        }
        temp->next = newFile;  // 새 파일 추가
    }

    printf("파일 '%s'가 추가되었습니다.\n", fileName);
}

파일 삭제 기능

특정 파일을 삭제하는 기능입니다.

void deleteFile(Folder* folder, const char* fileName) {
    if (folder == NULL || folder->files == NULL) {
        printf("삭제할 파일이 없습니다.\n");
        return;
    }

    File* temp = folder->files;
    File* prev = NULL;

    while (temp != NULL && strcmp(temp->fileName, fileName) != 0) {
        prev = temp;
        temp = temp->next;
    }

    if (temp == NULL) {
        printf("파일 '%s'를 찾을 수 없습니다.\n", fileName);
        return;
    }

    if (prev == NULL) {
        folder->files = temp->next;  // 첫 번째 파일 삭제
    } else {
        prev->next = temp->next;  // 중간 또는 마지막 파일 삭제
    }

    free(temp);
    printf("파일 '%s'가 삭제되었습니다.\n", fileName);
}

파일 리스트 출력 기능

현재 폴더에 있는 모든 파일을 출력하는 기능입니다.

void listFiles(Folder* folder) {
    if (folder == NULL || folder->files == NULL) {
        printf("파일이 없습니다.\n");
        return;
    }

    printf("'%s' 폴더의 파일 리스트:\n", folder->folderName);
    File* temp = folder->files;
    while (temp != NULL) {
        printf("- %s\n", temp->fileName);
        temp = temp->next;
    }
}

응용 기능 테스트

파일 탐색 기능을 테스트하는 코드입니다.

int main() {
    Folder* root = initializeExplorer();

    addFile(root, "README.txt");
    addFile(root, "setup.exe");

    Folder* documents = createFolder("Documents");
    root->subFolders = documents;

    addFile(documents, "report.docx");
    addFile(documents, "project.pptx");

    printf("\n루트 폴더 파일:\n");
    listFiles(root);

    printf("\nDocuments 폴더 파일:\n");
    listFiles(documents);

    deleteFile(root, "README.txt");
    printf("\n루트 폴더 파일 삭제 후:\n");
    listFiles(root);

    return 0;
}

실행 결과

다음은 프로그램 실행 예입니다:

루트 폴더 파일:
- README.txt
- setup.exe

Documents 폴더 파일:
- report.docx
- project.pptx

루트 폴더 파일 삭제 후:
- setup.exe

확장 가능성

파일 검색 기능: 폴더 구조를 재귀적으로 탐색하여 특정 파일을 찾는 기능 추가.
파일 속성 추가: 파일 크기, 생성 날짜 등의 속성을 포함해 더욱 세부적인 관리.
파일과 폴더의 통합 관리: 사용자 인터페이스에서 파일과 폴더 작업을 통합하여 편의성 향상.

파일 탐색 기능을 추가함으로써 폴더 탐색기의 유용성과 확장 가능성을 크게 향상시킬 수 있습니다.

요약

이 기사에서는 C언어와 연결 리스트를 활용하여 폴더 탐색기를 설계하고 구현하는 방법을 단계별로 설명했습니다. 연결 리스트를 사용한 데이터 구조 설계, 기본적인 폴더 및 파일 관리 기능 구현, 재귀를 활용한 탐색, 그리고 사용자 인터페이스 설계와 디버깅 및 최적화 방법을 다뤘습니다.

폴더 탐색기의 기본 기능에 더해 파일 관리와 같은 응용 기능을 추가하여 더욱 강력하고 유용한 프로그램으로 확장할 수 있습니다. 이러한 구현 과정을 통해 C언어의 데이터 구조와 실용적인 활용법을 깊이 이해할 수 있습니다.