MENU
  1. ホーム
  2. C 언어
  3. C 언어로 그래프 표현하기: 인접 행렬의 활용과 구현 방법

C 언어로 그래프 표현하기: 인접 행렬의 활용과 구현 방법

C 언어

그래프는 컴퓨터 과학과 데이터 구조에서 매우 중요한 개념으로, 다양한 문제를 해결하는 데 사용됩니다. 그래프를 표현하는 방법 중 하나인 인접 행렬은 간결하고 효율적이며, 특히 그래프의 밀도가 높은 경우 유리합니다. 본 기사에서는 C 언어를 사용해 인접 행렬로 그래프를 구현하고, 이를 통해 다양한 응용 프로그램을 설계하는 방법을 살펴봅니다.

목차

그래프와 인접 행렬의 기본 개념


그래프는 정점(vertex)과 정점 간의 연결선(edge)으로 구성된 데이터 구조입니다. 이를 활용하면 네트워크, 경로 탐색, 데이터 관계 등을 효과적으로 모델링할 수 있습니다.

그래프의 정의


그래프는 다음과 같이 정의됩니다.

  • 정점(Vertex): 데이터를 나타내는 노드.
  • 간선(Edge): 두 정점을 연결하는 선으로, 방향성 유무에 따라 유향 그래프(Directed Graph)와 무향 그래프(Undirected Graph)로 나뉩니다.

인접 행렬의 개념


인접 행렬은 2차원 배열을 사용해 그래프를 표현하는 방법입니다.

  • 행(Row)와 열(Column): 정점을 나타냅니다.
  • 값(Value): 정점 간의 연결 여부를 나타냅니다.
  • 값이 1이면 두 정점이 연결됨을 의미합니다.
  • 값이 0이면 연결되지 않았음을 나타냅니다.

인접 행렬의 장점

  • 간단한 구현: 2차원 배열로 그래프를 표현하므로 코드가 간결합니다.
  • 빠른 간선 탐색: 특정 정점 간의 연결 여부를 O(1) 시간에 확인할 수 있습니다.

인접 행렬의 단점

  • 메모리 사용량: 정점 개수의 제곱에 비례하는 메모리를 사용하므로, 희소 그래프(Sparse Graph)에서는 비효율적입니다.
  • 간선 추가/삭제의 고정 비용: 모든 간선의 존재 여부를 저장해야 하므로 메모리 낭비가 발생할 수 있습니다.

그래프 표현의 기본으로 인접 행렬을 이해하면, 다양한 알고리즘과 문제를 효과적으로 해결할 수 있습니다.

인접 행렬을 사용하는 그래프 구현의 장단점

장점

  1. 간단한 데이터 구조
  • 2차원 배열로 그래프를 표현하므로 직관적이고 구현이 간단합니다.
  1. 빠른 연결 확인
  • 특정 두 정점 간의 연결 여부를 배열 인덱스를 통해 O(1) 시간에 확인할 수 있습니다.
  1. 고정된 구조
  • 모든 정점과 간선 정보를 고정된 크기의 배열에 저장하므로 안정적인 데이터 관리가 가능합니다.
  1. 다양한 알고리즘과의 호환성
  • 플로이드-워셜 알고리즘 같은 전역적인 그래프 탐색 알고리즘에서 사용하기에 적합합니다.

단점

  1. 메모리 비효율성
  • 정점 개수가 많고 간선이 적은 희소 그래프(Sparse Graph)에서는 대다수의 배열 요소가 0으로 낭비됩니다.
  • 메모리 사용량은 O(V²)로, 정점 수가 늘어날수록 급격히 증가합니다.
  1. 간선 추가/삭제의 제한
  • 정점 수가 고정되므로 배열 크기를 동적으로 변경할 수 없습니다.
  1. 시간 복잡도 문제
  • 모든 간선을 탐색해야 하는 작업에서는 O(V²)의 시간이 걸릴 수 있습니다.
  1. 저장 공간과 성능의 비효율성
  • 무향 그래프에서 배열의 절반은 중복된 데이터를 저장하게 됩니다.

인접 행렬은 메모리보다 성능을 중시하거나 그래프의 간선이 밀집된 경우에 적합한 방법입니다. 사용 목적과 그래프의 특성에 따라 적절히 선택하는 것이 중요합니다.

C 언어로 인접 행렬 초기화하기

인접 행렬 초기화의 기본 원리


C 언어에서 인접 행렬은 2차원 배열을 사용해 초기화됩니다. 그래프의 정점 개수를 기준으로 배열의 크기를 정하고, 각 요소를 초기값(주로 0)으로 설정합니다. 이를 통해 그래프의 연결 상태를 나타낼 준비를 합니다.

배열 초기화 코드 예제


다음은 C 언어를 사용해 인접 행렬을 초기화하는 코드입니다.

#include <stdio.h>

#define MAX_VERTICES 5  // 정점의 최대 개수

void initializeAdjacencyMatrix(int matrix[MAX_VERTICES][MAX_VERTICES], int vertices) {
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            matrix[i][j] = 0;  // 초기값을 0으로 설정
        }
    }
}

int main() {
    int adjacencyMatrix[MAX_VERTICES][MAX_VERTICES];
    int vertices = MAX_VERTICES;

    initializeAdjacencyMatrix(adjacencyMatrix, vertices);

    // 초기화 결과 출력
    printf("Initialized Adjacency Matrix:\n");
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            printf("%d ", adjacencyMatrix[i][j]);
        }
        printf("\n");
    }

    return 0;
}

코드 설명

  1. #define MAX_VERTICES
  • 그래프의 최대 정점 개수를 정의합니다.
  1. initializeAdjacencyMatrix 함수
  • 이 함수는 인접 행렬 배열을 초기화합니다.
  • 이중 for 루프를 사용해 배열의 각 요소를 0으로 설정합니다.
  1. 초기화 결과 출력
  • 초기화된 인접 행렬을 확인하기 위해 콘솔에 출력합니다.

동적 메모리 할당을 통한 초기화


정점 개수가 런타임에 결정되는 경우, 동적 메모리 할당을 사용할 수 있습니다.

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

void initializeDynamicMatrix(int** matrix, int vertices) {
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            matrix[i][j] = 0;
        }
    }
}

int main() {
    int vertices = 5;  // 사용자 입력으로 설정 가능
    int** adjacencyMatrix = (int**)malloc(vertices * sizeof(int*));

    for (int i = 0; i < vertices; i++) {
        adjacencyMatrix[i] = (int*)malloc(vertices * sizeof(int));
    }

    initializeDynamicMatrix(adjacencyMatrix, vertices);

    printf("Initialized Dynamic Adjacency Matrix:\n");
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            printf("%d ", adjacencyMatrix[i][j]);
        }
        printf("\n");
    }

    // 메모리 해제
    for (int i = 0; i < vertices; i++) {
        free(adjacencyMatrix[i]);
    }
    free(adjacencyMatrix);

    return 0;
}

동적 메모리 초기화 코드 설명

  1. 동적 메모리 할당
  • malloc을 사용해 정점 개수에 따라 2차원 배열을 생성합니다.
  1. 초기화
  • 동적 배열의 각 요소를 0으로 설정합니다.
  1. 메모리 해제
  • 사용이 끝난 배열은 free를 사용해 메모리를 해제합니다.

이처럼 고정 크기와 동적 크기 배열 초기화는 요구사항에 따라 선택적으로 사용할 수 있습니다.

그래프의 데이터 입력과 저장 방식

그래프 데이터를 입력받는 방식


그래프를 구성하기 위해 사용자로부터 정점 개수와 간선 정보를 입력받아 인접 행렬에 저장합니다. 입력 형식은 정점 간의 연결 정보를 간단히 표현합니다.

기본 코드 예제


다음은 C 언어로 그래프 데이터를 입력받아 인접 행렬에 저장하는 코드입니다.

#include <stdio.h>

#define MAX_VERTICES 5  // 정점의 최대 개수

void inputGraphData(int matrix[MAX_VERTICES][MAX_VERTICES], int vertices, int edges) {
    int u, v;  // 간선을 정의하는 두 정점

    for (int i = 0; i < edges; i++) {
        printf("Enter edge (u v): ");
        scanf("%d %d", &u, &v);
        matrix[u][v] = 1;  // 무향 그래프: 양방향 설정
        matrix[v][u] = 1;  
    }
}

void printAdjacencyMatrix(int matrix[MAX_VERTICES][MAX_VERTICES], int vertices) {
    printf("Adjacency Matrix:\n");
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            printf("%d ", matrix[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int adjacencyMatrix[MAX_VERTICES][MAX_VERTICES] = {0};  // 초기화
    int vertices, edges;

    printf("Enter the number of vertices: ");
    scanf("%d", &vertices);

    printf("Enter the number of edges: ");
    scanf("%d", &edges);

    inputGraphData(adjacencyMatrix, vertices, edges);
    printAdjacencyMatrix(adjacencyMatrix, vertices);

    return 0;
}

코드 동작 설명

  1. 입력 받기
  • 정점 개수와 간선 개수를 사용자로부터 입력받습니다.
  • 간선은 두 정점(u와 v)의 연결을 나타냅니다.
  1. 인접 행렬 업데이트
  • 각 간선을 입력받아 해당 인접 행렬 요소를 1로 설정합니다.
  • 무향 그래프의 경우 대칭적으로 값을 설정합니다.
  1. 인접 행렬 출력
  • 결과를 콘솔에 출력해 그래프 표현을 확인합니다.

유향 그래프 데이터 입력


유향 그래프에서는 간선 방향에 따라 인접 행렬을 다르게 설정합니다.

matrix[u][v] = 1;  // 방향에 따라 한쪽만 설정

가중치 그래프 데이터 입력


가중치가 있는 그래프는 간선 값을 1 대신 가중치 값으로 설정합니다.

int weight;
printf("Enter edge (u v weight): ");
scanf("%d %d %d", &u, &v, &weight);
matrix[u][v] = weight;
matrix[v][u] = weight;  // 무향 그래프일 경우

입력 예시


사용자가 다음 데이터를 입력했다고 가정합니다.

  • 정점: 4
  • 간선: 3
  • 간선 정보:
  0 1  
  1 2  
  2 3

출력된 인접 행렬:

0 1 0 0  
1 0 1 0  
0 1 0 1  
0 0 1 0

이 방식은 사용자 입력 데이터를 활용해 효율적으로 그래프를 초기화하고 저장할 수 있습니다.

그래프 탐색 알고리즘: DFS와 BFS

그래프 탐색은 정점과 간선을 통해 그래프를 탐색하거나 특정 패턴을 찾는 과정입니다. 대표적인 탐색 방법으로 깊이 우선 탐색(DFS)과 너비 우선 탐색(BFS)을 활용할 수 있습니다. 인접 행렬을 사용한 구현을 살펴봅니다.

DFS(Depth First Search)


DFS는 그래프에서 가능한 한 깊이 들어가며 탐색을 진행합니다. 재귀 또는 스택을 사용해 구현할 수 있습니다.

DFS 구현 코드

#include <stdio.h>
#include <stdbool.h>

#define MAX_VERTICES 5

void dfs(int matrix[MAX_VERTICES][MAX_VERTICES], bool visited[], int vertex, int vertices) {
    visited[vertex] = true;  // 현재 정점 방문 표시
    printf("%d ", vertex);   // 방문한 정점 출력

    for (int i = 0; i < vertices; i++) {
        if (matrix[vertex][i] == 1 && !visited[i]) {  // 연결된 미방문 정점 탐색
            dfs(matrix, visited, i, vertices);
        }
    }
}

int main() {
    int adjacencyMatrix[MAX_VERTICES][MAX_VERTICES] = {
        {0, 1, 0, 0, 1},
        {1, 0, 1, 1, 0},
        {0, 1, 0, 0, 1},
        {0, 1, 0, 0, 0},
        {1, 0, 1, 0, 0},
    };
    bool visited[MAX_VERTICES] = {false};

    printf("DFS Traversal: ");
    dfs(adjacencyMatrix, visited, 0, MAX_VERTICES);

    return 0;
}

출력 결과

DFS Traversal: 0 1 2 4 3

BFS(Breadth First Search)


BFS는 그래프에서 가까운 정점부터 탐색을 진행하며, 큐를 사용해 구현합니다.

BFS 구현 코드

#include <stdio.h>
#include <stdbool.h>

#define MAX_VERTICES 5

void bfs(int matrix[MAX_VERTICES][MAX_VERTICES], int start, int vertices) {
    bool visited[MAX_VERTICES] = {false};
    int queue[MAX_VERTICES];
    int front = 0, rear = 0;

    visited[start] = true;
    queue[rear++] = start;  // 시작 정점을 큐에 추가

    while (front < rear) {
        int current = queue[front++];
        printf("%d ", current);

        for (int i = 0; i < vertices; i++) {
            if (matrix[current][i] == 1 && !visited[i]) {
                visited[i] = true;
                queue[rear++] = i;  // 연결된 정점을 큐에 추가
            }
        }
    }
}

int main() {
    int adjacencyMatrix[MAX_VERTICES][MAX_VERTICES] = {
        {0, 1, 0, 0, 1},
        {1, 0, 1, 1, 0},
        {0, 1, 0, 0, 1},
        {0, 1, 0, 0, 0},
        {1, 0, 1, 0, 0},
    };

    printf("BFS Traversal: ");
    bfs(adjacencyMatrix, 0, MAX_VERTICES);

    return 0;
}

출력 결과

BFS Traversal: 0 1 4 2 3

DFS와 BFS 비교

특징DFSBFS
탐색 방식깊이 우선너비 우선
자료 구조재귀 호출 또는 스택큐
적합한 경우경로 탐색, 순환 찾기최단 경로 탐색, 연결 요소 확인
시간 복잡도O(V²) (인접 행렬)O(V²) (인접 행렬)

응용

  • DFS는 미로 탐색이나 순환 검출에 적합합니다.
  • BFS는 네트워크의 최단 경로를 찾는 데 적합합니다.

이 두 알고리즘을 적절히 활용하면 다양한 그래프 문제를 효과적으로 해결할 수 있습니다.

인접 행렬 기반의 그래프 응용 예제

인접 행렬을 활용한 그래프 응용은 네트워크 최적화, 경로 탐색, 데이터 연결성 분석 등 다양한 분야에서 활용됩니다. 다음은 인접 행렬을 기반으로 구현할 수 있는 대표적인 응용 예제를 소개합니다.

최단 경로 탐색: 플로이드-워셜 알고리즘


플로이드-워셜 알고리즘은 모든 정점 쌍 간의 최단 경로를 구하는 데 사용됩니다. 인접 행렬을 사용해 구현하면 간결하게 작성할 수 있습니다.

플로이드-워셜 알고리즘 코드

#include <stdio.h>
#define INF 99999
#define MAX_VERTICES 4

void floydWarshall(int matrix[MAX_VERTICES][MAX_VERTICES], int vertices) {
    int dist[MAX_VERTICES][MAX_VERTICES];

    // 초기화: 거리 배열에 기존 인접 행렬 값 복사
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            dist[i][j] = matrix[i][j];
        }
    }

    // 플로이드-워셜 알고리즘 수행
    for (int k = 0; k < vertices; k++) {
        for (int i = 0; i < vertices; i++) {
            for (int j = 0; j < vertices; j++) {
                if (dist[i][k] + dist[k][j] < dist[i][j]) {
                    dist[i][j] = dist[i][k] + dist[k][j];
                }
            }
        }
    }

    // 최단 거리 출력
    printf("Shortest Distance Matrix:\n");
    for (int i = 0; i < vertices; i++) {
        for (int j = 0; j < vertices; j++) {
            if (dist[i][j] == INF)
                printf("%7s", "INF");
            else
                printf("%7d", dist[i][j]);
        }
        printf("\n");
    }
}

int main() {
    int graph[MAX_VERTICES][MAX_VERTICES] = {
        {0, 3, INF, 5},
        {2, 0, INF, 4},
        {INF, 1, 0, INF},
        {INF, INF, 2, 0}
    };

    floydWarshall(graph, MAX_VERTICES);

    return 0;
}

출력 결과

Shortest Distance Matrix:
      0      3      7      5
      2      0      6      4
      3      1      0      5
      5      3      2      0

그래프 연결성 검사


그래프가 연결 그래프인지 확인하려면 DFS 또는 BFS를 사용해 모든 정점을 탐색한 후, 모든 정점이 방문되었는지 검사합니다.

사이클 검출


유향 그래프에서는 DFS를 사용해 사이클을 검출할 수 있습니다. 정점이 방문 중 상태로 다시 탐색되면 사이클이 존재합니다.

응용 사례

  1. 네트워크 라우팅
  • 네트워크 간의 최단 경로를 계산하여 효율적인 데이터 전송을 수행합니다.
  1. 사회 연결망 분석
  • 소셜 네트워크에서 연결 관계를 분석하거나 영향력을 평가합니다.
  1. 교통 경로 계획
  • 도시 간의 최단 경로를 계산하여 교통 체증을 줄이는 데 사용됩니다.

인접 행렬을 활용하면 그래프의 연결성을 다각도로 분석하고 효율적인 알고리즘을 구현할 수 있습니다.

그래프 문제 해결을 위한 연습 문제

인접 행렬을 활용한 그래프 문제를 연습하면 이론적인 이해를 바탕으로 실용적인 구현 능력을 키울 수 있습니다. 다음은 다양한 난이도의 연습 문제와 구현 방향을 제시합니다.

문제 1: 그래프의 연결성 확인


설명
인접 행렬을 사용하여 그래프가 연결 그래프인지 확인합니다. 연결 그래프는 모든 정점이 서로 연결된 상태를 의미합니다.

문제 해결 방향

  • DFS나 BFS를 사용하여 모든 정점을 탐색합니다.
  • 탐색 후 방문하지 않은 정점이 있다면 연결되지 않은 그래프입니다.

추가 요구사항

  • 연결되지 않은 경우, 연결되지 않은 정점 그룹을 출력합니다.

문제 2: 그래프에서 최단 경로 찾기


설명
주어진 그래프에서 특정 시작 정점에서 다른 모든 정점까지의 최단 경로를 구합니다.

문제 해결 방향

  • 플로이드-워셜 알고리즘이나 다익스트라 알고리즘을 사용해 구현합니다.
  • 인접 행렬에 간선의 가중치를 저장한 후, 최단 거리 행렬을 출력합니다.

추가 요구사항

  • 특정 정점 간의 최단 경로를 출력하도록 기능을 확장합니다.

문제 3: 사이클 존재 여부 확인


설명
유향 그래프에서 사이클이 존재하는지 확인합니다.

문제 해결 방향

  • DFS를 사용하여 탐색 중 방문 중 상태의 정점을 다시 방문하면 사이클이 존재한다고 판정합니다.
  • 인접 행렬을 기반으로 구현합니다.

추가 요구사항

  • 발견된 사이클의 정점을 나열합니다.

문제 4: 그래프에서 MST(최소 신장 트리) 찾기


설명
무향 가중치 그래프에서 모든 정점을 연결하는 최소 가중치의 트리를 구합니다.

문제 해결 방향

  • 프림(Prim) 또는 크루스칼(Kruskal) 알고리즘을 사용해 구현합니다.
  • 인접 행렬을 활용하여 간선 정보를 저장합니다.

추가 요구사항

  • 트리의 총 가중치와 트리를 구성하는 간선을 출력합니다.

문제 5: 그래프 색칠 문제


설명
주어진 무향 그래프의 각 정점을 최소한의 색상으로 색칠하여 인접한 정점끼리 같은 색이 되지 않도록 합니다.

문제 해결 방향

  • 백트래킹을 사용하여 가능한 색상 조합을 탐색합니다.
  • 인접 행렬을 사용하여 정점 간의 연결 상태를 확인합니다.

추가 요구사항

  • 색상을 최소화하는 솔루션을 출력합니다.

문제 6: 그래프의 지름 구하기


설명
그래프의 지름은 두 정점 사이의 최장 최단 경로를 의미합니다.

문제 해결 방향

  • 플로이드-워셜 알고리즘으로 모든 정점 쌍 간의 최단 경로를 구한 뒤, 최단 경로 중 가장 긴 값을 찾습니다.

문제의 예시 입출력


입력

정점 개수: 4  
간선 정보:  
0 1  
0 2  
1 3

출력

연결 여부: 연결됨  
최단 경로 (0에서 3까지): 2  
사이클 여부: 없음

문제를 통해 배우는 것

  • 인접 행렬의 구조적 이해
  • 그래프 탐색 및 경로 계산 알고리즘의 응용
  • 다양한 그래프 문제 해결 능력 강화

이 문제들을 해결하면서 그래프 이론과 C 언어 구현 능력을 효과적으로 향상시킬 수 있습니다.

그래프 구현에서 발생할 수 있는 문제와 디버깅 팁

그래프 구현 과정에서는 다양한 문제에 직면할 수 있습니다. 아래는 흔히 발생하는 문제들과 이를 해결하기 위한 디버깅 방법을 정리한 내용입니다.

문제 1: 인접 행렬 초기화 오류


증상

  • 그래프 데이터를 입력하기 전에 인접 행렬에 초기 값이 제대로 설정되지 않아 의도하지 않은 결과가 발생합니다.

해결 방법

  • 초기화 코드를 반복적으로 확인합니다.
  • 모든 배열 요소를 명시적으로 0으로 초기화합니다.
  • 디버깅 시 초기화 결과를 출력하여 문제를 파악합니다.

예제 코드

for (int i = 0; i < vertices; i++) {
    for (int j = 0; j < vertices; j++) {
        matrix[i][j] = 0;
    }
}

문제 2: 배열 인덱스 초과


증상

  • 사용자가 입력한 정점 번호가 배열 크기를 초과하여 프로그램이 충돌하거나 잘못된 데이터를 처리합니다.

해결 방법

  • 배열 인덱스 범위를 엄격히 검사합니다.
  • 잘못된 입력이 감지되면 사용자에게 경고 메시지를 출력합니다.

예제 코드

if (u >= vertices || v >= vertices) {
    printf("Invalid edge: (%d, %d)\n", u, v);
    continue;
}

문제 3: 메모리 누수


증상

  • 동적 메모리를 사용하는 경우, 할당한 메모리를 제대로 해제하지 않아 프로그램 종료 후에도 메모리 누수가 발생합니다.

해결 방법

  • free를 사용하여 모든 동적 메모리를 해제합니다.
  • 디버깅 도구(예: Valgrind)를 사용하여 메모리 상태를 확인합니다.

예제 코드

for (int i = 0; i < vertices; i++) {
    free(matrix[i]);
}
free(matrix);

문제 4: 그래프 탐색 중 무한 루프


증상

  • DFS 또는 BFS 탐색 과정에서 방문 배열이 제대로 설정되지 않아 동일한 정점을 반복적으로 탐색합니다.

해결 방법

  • 방문 여부를 저장하는 배열을 사용하고 탐색 시작 시 올바르게 초기화합니다.
  • 탐색 진행 중 각 정점의 상태를 로그로 출력해 문제를 추적합니다.

예제 코드

bool visited[MAX_VERTICES] = {false};

문제 5: 사이클 검출 오류


증상

  • 그래프 탐색 과정에서 사이클 존재 여부를 잘못 판별합니다.

해결 방법

  • DFS를 사용할 때 방문 중인 정점(visiting)과 방문 완료된 정점(visited)을 구분하여 관리합니다.
  • 스택 상태를 출력하며 탐색 과정을 확인합니다.

문제 6: 가중치 처리 실수


증상

  • 가중치 그래프에서 간선 가중치가 잘못 저장되거나 누락됩니다.

해결 방법

  • 가중치 입력을 검증하고, 인접 행렬에 올바르게 저장되었는지 확인합니다.
  • 입력 데이터를 디버깅 단계에서 출력하여 오류를 추적합니다.

디버깅 도구 활용

  • Printf 디버깅
  • 각 단계의 데이터를 출력하여 프로그램 상태를 확인합니다.
  • 메모리 디버거
  • Valgrind 또는 AddressSanitizer를 사용하여 메모리 문제를 탐지합니다.
  • IDE 디버거
  • 중단점(Breakpoint)을 설정하여 프로그램의 흐름을 세부적으로 추적합니다.

디버깅을 위한 체크리스트

  1. 인접 행렬 초기화와 입력 데이터 확인
  2. 배열 인덱스 범위 초과 여부 점검
  3. 탐색 알고리즘의 방문 상태와 루프 조건 점검
  4. 메모리 누수 및 동적 메모리 해제 여부 확인

이러한 문제와 해결 방법을 숙지하면 그래프 구현 시 발생할 수 있는 대부분의 오류를 효과적으로 처리할 수 있습니다.

요약


본 기사에서는 C 언어로 인접 행렬을 활용하여 그래프를 구현하는 방법을 다뤘습니다. 그래프의 기본 개념부터 탐색 알고리즘(DFS, BFS), 응용 예제, 연습 문제, 그리고 구현 시 발생할 수 있는 문제와 디버깅 팁까지 자세히 설명했습니다. 이를 통해 인접 행렬 기반의 그래프 구현과 실용적인 활용 방법에 대한 이해를 심화할 수 있습니다.

C 언어
C언어 그래프 데이터 구조 인접 행렬
목차