Kahn’s Algorithm in C Language

// C program to implement Kahn's Algorithm

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

#define MAX 100

// Structure to represent a graph
struct Graph {
    // Number of vertices in the graph
    int V;
    // Adjacency matrix representation of the graph
    int adj[MAX][MAX];
};

// Function to create a graph with V vertices
struct Graph* createGraph(int V)
{
    // Allocate memory for the graph structure
    struct Graph* graph
        = (struct Graph*)malloc(sizeof(struct Graph));
    graph->V = V; // Set the number of vertices

    // Initialize the adjacency matrix to 0
    for (int i = 0; i < V; i++)
        for (int j = 0; j < V; j++)
            graph->adj[i][j] = 0;

    return graph;
}

// Function to add an edge to the graph
void addEdge(struct Graph* graph, int u, int v)
{
    // Set the edge from u to v
    graph->adj[u][v] = 1;
}

// Function to perform Kahn's Algorithm for Topological
// Sorting
void kahnTopologicalSort(struct Graph* graph)
{
    // Array to store in-degrees of all vertices
    int in_degree[MAX] = { 0 };

    // Compute in-degrees of all vertices
    for (int i = 0; i < graph->V; i++)
        for (int j = 0; j < graph->V; j++)
            if (graph->adj[i][j])
                in_degree[j]++;

    // Enqueue vertices with zero in-degrees
    int queue[MAX], front = 0, rear = 0;
    for (int i = 0; i < graph->V; i++)
        if (in_degree[i] == 0)
            queue[rear++] = i;
    // Count of visited vertices
    int count = 0;
    // Array to store topological order
    int top_order[MAX];

    // Process vertices in the queue
    while (front < rear) {
        int u = queue[front++];
        top_order[count++] = u;

        // Reduce in-degrees of adjacent vertices
        for (int i = 0; i < graph->V; i++) {
            if (graph->adj[u][i]) {
                if (--in_degree[i] == 0)
                    queue[rear++] = i;
            }
        }
    }

    // Check if there was a cycle in the graph
    if (count != graph->V) {
        printf("There exists a cycle in the graph\n");
        return;
    }

    // Print the topological order
    for (int i = 0; i < count; i++)
        printf("%d ", top_order[i]);
    printf("\n");
}

int main()
{
    // Create a graph with 6 vertices
    struct Graph* graph = createGraph(6);

    // Add edges to the graph
    addEdge(graph, 5, 2);
    addEdge(graph, 5, 0);
    addEdge(graph, 4, 0);
    addEdge(graph, 4, 1);
    addEdge(graph, 2, 3);
    addEdge(graph, 3, 1);

    // Perform and print topological sort
    printf("Topological Sort of the given graph:\n");
    kahnTopologicalSort(graph);

    return 0;
}