Find k-cores of an undirected graph

// C Program 
// Find k-cores of an undirected graph
#include <stdio.h>
#include <stdlib.h>

// Define edge of graph node
struct AjlistNode
{
    int id; //Vertices id
    struct AjlistNode *next;
};

// Define node of graph 
struct GraphNode
{
    int data; //node key value
    struct AjlistNode *edge;
};

// Define structure of graph
struct MyGraph
{
    int size; // Number of graph nodes
    struct GraphNode *node;
};

// This are return a new graph with given number of nodes
struct MyGraph *newGraph(int size)
{
    if (size < 0)
    {
        printf("\n Invalid size of nodes %d \n", size);
        return NULL;
    }

    // Create a graph
    struct MyGraph *graph = (struct MyGraph *) malloc(sizeof(struct MyGraph));
    
    if (graph != NULL)
    {
        // Set node size
        graph->size = size;

        // Allocate memory to graph node
        graph->node = (struct GraphNode *) malloc(sizeof(struct GraphNode) *size);
        
        // Loop controlling variable
        int i = 0;

        // Set graph node level and e
        for (i = 0; i < graph->size; i++)
        {
            // Set node level (0...size-1)
            graph->node[i].data = i;
            
            // Set the node [i] have no edge
            graph->node[i].edge = NULL;
        }
    }
    else
    {
        printf("\n Graph of nodes %d is not created (memory overflow problem)\n", size);
    }
    return graph;
}

//This function are connect nodes with one edge 
void connect_edge(struct MyGraph *graph, int a, int b)
{
    if (graph->node == NULL)
    {
        printf("\n Graph have no nodes \n");
        return;
    }
    // Create Adjacency node
    struct AjlistNode *newEdge = (struct AjlistNode *) malloc(sizeof(struct AjlistNode));
    
    if (newEdge != NULL)
    {
        newEdge->next = NULL;

        newEdge->id = b;

        // Get first edge of [i] node
        struct AjlistNode *edge = graph->node[a].edge;

        if (edge == NULL)
        {
            // Whe no edge of graph node [i] then
            // Add a first edge of a [i] node
            graph->node[a].edge = newEdge;
        }
        else
        {
            //Find last location to add new edge
            while (edge->next != NULL)
            {
                edge = edge->next;
            }

            // Add edge at last position
            edge->next = newEdge;
        }
    }
    else
    {
        printf("\nMemory overflow, when connect a new edge from ( %d to %d ) nodes.\n", a, b);
    }
}
// This is handles the request of connecting Edges between given node a to b
void add_edge(struct MyGraph *graph, int a, int b)
{
    if (a < graph->size && b < graph->size)
    {
        // connect edge
        // a---->b
        connect_edge(graph, a, b);

        if (a == b)
        {
            //self loop
            return;
        }
        // connect edge
        // a <---- b
        connect_edge(graph, b, a);
    }
    else
    {
        //not valid Vertices
        printf("Invalid Node Vertices %d  %d", a, b);
    }
}
//Display Adjacency list of vertex
void print_graph(struct MyGraph *graph)
{
    if (graph->node != NULL)
    {
        struct AjlistNode *temp = NULL;

        // Loop controlling variable
        int i = 0;

        for (i = 0; i < graph->size; i++)
        {
            printf("\n Adjacency list of vertex %d  :", i);

            // Get first edge of [i] node
            temp = graph->node[i].edge;
           
            while (temp != NULL)
            {
                //temp->id is graph node vertices
                //in this case temp->id is same as 
                //node[temp->id].data
                printf("  %d", graph->node[temp->id].data);
                temp = temp->next;
            }
        }
    }
    else
    {
        printf("Empty GraphNode");
    }
}
//This is an undirected graph so indegree will be equal to outdegree
//Find indegree of each nodes of a given graph
void find_degree(int indegree[], struct MyGraph *graph)
{
    if (graph->node == NULL) 
    {
        return;
    }

    struct AjlistNode *temp = NULL;
    // Loop controlling variable
    int i = 0;
    for (i = 0; i < graph->size; ++i)
    {
        indegree[i] = 0;
    }

    //Find the  incoming edges of each node
    for (i = 0; i < graph->size; ++i)
    {
        // Get first edge of i node in given graph
        temp = graph->node[i].edge;

        while (temp != NULL)
        {
            indegree[temp->id]++;

            // visit to next edge
            temp = temp->next;
        }
    }
}

// This is removing connection of node which is less than k edges
void k_cores(struct MyGraph *graph, int k)
{
    if (k <= 0)
    {
        return;
    }
    if (graph->node != NULL)
    {


        int indegree[graph->size];

        // Loop controlling variable
        int i = 0;

        find_degree(indegree, graph);

        struct AjlistNode *edge = NULL, *auxiliary = NULL, *temp = NULL;
        
        int status = 1;
        
        while (status == 1)
        {
            status = 0;
            
            for (i = 0; i < graph->size; ++i)
            {
                if (indegree[i] > 0 && indegree[i] < k)
                {

                    edge = graph->node[i].edge;
                    graph->node[i].edge = NULL;
                    while (edge != NULL)
                    {
                        auxiliary = edge;
                        indegree[edge->id]--;
                        edge = edge->next;
                        //remove edge
                        free(auxiliary);
                        auxiliary = NULL;
                    }
                    indegree[i] = 0;
                    status = 1;
                }
            }
        }
        // Edge are connect both direction 
        // for example a---> b and b--->a 
        // remove edges which is less than k
        for (i = 0; i < graph->size; ++i)
        {
            edge = graph->node[i].edge;

            auxiliary = NULL;

            while (edge != NULL)
            {
                if (indegree[edge->id] <= 0)
                {
                    if (graph->node[i].edge == edge)
                    {
                        //delete first edge
                        graph->node[i].edge = edge->next;
                    }
                    else
                    {
                        auxiliary->next = edge->next;
                    }
                    temp = edge;
                    edge = edge->next;
                    //remove edge
                    free(temp);
                    temp = NULL;
                }
                else
                {
                    auxiliary = edge;
                    // visit to next edge
                    edge = edge->next;
                }
            }
        }
        printf("\n");
    }
    else
    {
        printf("Empty Edge\n");
    }
}
int main()
{
    struct MyGraph *graph = newGraph(10);
    //Connected two node with Edges
    add_edge(graph, 0, 1);
    add_edge(graph, 0, 4);
    add_edge(graph, 0, 7);
    add_edge(graph, 1, 2);
    add_edge(graph, 1, 4);
    add_edge(graph, 1, 6);
    add_edge(graph, 2, 3);
    add_edge(graph, 2, 4);
    add_edge(graph, 3, 4);
    add_edge(graph, 3, 5);
    add_edge(graph, 3, 6);
    add_edge(graph, 4, 5);
    add_edge(graph, 5, 6);
    add_edge(graph, 5, 7);
    add_edge(graph, 5, 8);
    add_edge(graph, 6, 9);
    add_edge(graph, 7, 8);
    add_edge(graph, 8, 9);

    print_graph(graph);
    int k = 3;

    k_cores(graph, k);

    printf("\n After remove %d Cores\n",k);
    print_graph(graph);
    return 0;
}

Output

 Adjacency list of vertex 0  :  1  4  7
 Adjacency list of vertex 1  :  0  2  4  6
 Adjacency list of vertex 2  :  1  3  4
 Adjacency list of vertex 3  :  2  4  5  6
 Adjacency list of vertex 4  :  0  1  2  3  5
 Adjacency list of vertex 5  :  3  4  6  7  8
 Adjacency list of vertex 6  :  1  3  5  9
 Adjacency list of vertex 7  :  0  5  8
 Adjacency list of vertex 8  :  5  7  9
 Adjacency list of vertex 9  :  6  8

 After remove 3 Cores

 Adjacency list of vertex 0  :
 Adjacency list of vertex 1  :  2  4  6
 Adjacency list of vertex 2  :  1  3  4
 Adjacency list of vertex 3  :  2  4  5  6
 Adjacency list of vertex 4  :  1  2  3  5
 Adjacency list of vertex 5  :  3  4  6
 Adjacency list of vertex 6  :  1  3  5
 Adjacency list of vertex 7  :
 Adjacency list of vertex 8  :
 Adjacency list of vertex 9  :