Пожалуйста, попробуйте найти код, так как я не смог найти правильный результат

---

Граф-это абстрактно набор вершин, которые помечены
неотрицательные целые числа и набор ребер. Граф называется
неориентированный граф, если мы говорим просто о наличии ребра между
вершины i и j, а не ее направление.

Например, ниже приведен график:


В этой задаче задаются ребра в неориентированном графе. Один
ребро-это пара неотрицательных целых чисел (i, j), которая указывает на то, что
vetex i соединен с vetex j ребром.

После этого вам будет присвоен номер вершины n. Вы должны вывести
список вершин, которые соединены ребром N, в порядке в
какие края были входными данными.

Ввод

Вам дается следующее.

1. Первая строка содержит целое число, E, между 1 и 1000

2. После этого по электронной линии, где каждый из которых содержит пару
числа i и j, где i и j-неотрицательные целые числа <=
34,000. Ни одно ребро не будет перечислено более одного раза.

3. Последняя строка содержит неотрицательное целое число n &ЛТ;= 34,000. п
конечно, это вершина, указанная в одной из строк Е в части (2).

Выход

Вы должны вывести список узлов, к которым n имеет ребро, в виде
порядок, в котором были введены ребра, по одной строке для каждой вершины.

Что я уже пробовал:

#include <stdio.h> 
#include <stdlib.h> 
   
struct AdjListNode 
{ 
    int dest; 
    struct AdjListNode* next; 
}; 
  
struct AdjList 
{ 
    struct AdjListNode *head;  
}; 
   
struct Graph 
{ 
    int V; 
    struct AdjList* array; 
}; 
  
struct AdjListNode* newAdjListNode(int dest) 
{ 
    struct AdjListNode* newNode = 
     (struct AdjListNode*) malloc(sizeof(struct AdjListNode)); 
    newNode->dest = dest; 
    newNode->next = NULL; 
    return newNode; 
} 
  
// A utility function that creates a graph of V vertices 
struct Graph* createGraph(int V) 
{ 
    struct Graph* graph =  
        (struct Graph*) malloc(sizeof(struct Graph)); 
    graph->V = V; 
  
    graph->array =  
      (struct AdjList*) malloc(V * sizeof(struct AdjList)); 
  
    int i; 
    for (i = 0; i < V; ++i) 
        graph->array[i].head = NULL; 
  
    return graph; 
} 
  
void addEdge(struct Graph* graph, int src, int dest) 
{ 
   
    struct AdjListNode* newNode = newAdjListNode(dest); 
    newNode->next = graph->array[src].head; 
    graph->array[src].head = newNode; 
  
    newNode = newAdjListNode(src); 
    newNode->next = graph->array[dest].head; 
    graph->array[dest].head = newNode; 
} 
  
void printGraph(struct Graph* graph) 
{ 
    int v; 
    for (v = 0; v < graph->V; ++v) 
    { 
        struct AdjListNode* pCrawl = graph->array[v].head; 
        printf("\n Adjacency list of vertex %d\n head ", v); 
        while (pCrawl) 
        { 
            printf("-> %d", pCrawl->dest); 
            pCrawl = pCrawl->next; 
        } 
        printf("\n"); 
    } 
} 
   
int main() 
{ 
   
    int V = 5; 
    struct Graph* graph = createGraph(V); 
    addEdge(graph, 0, 1); 
    addEdge(graph, 0, 4); 
    addEdge(graph, 1, 2); 
    addEdge(graph, 1, 3); 
    addEdge(graph, 1, 4); 
    addEdge(graph, 2, 3); 
    addEdge(graph, 3, 4); 
  
    return 0; 
}

---