mirror of
https://github.com/krahets/hello-algo.git
synced 2026-08-17 14:10:57 +00:00
Add ru version (#1865)
* Add Russian docs site baseline * Add Russian localized codebase * Polish Russian code wording * Update ru code translation. * Update code translation and chapter covers. * Fix pythontutor extraction. * Add README and landing page. * placeholder of profiles * Use figures of English version * Remove chapter paperbook
This commit is contained in:
Yudong Jin
@@ -0,0 +1,4 @@
|
||||
add_executable(graph_adjacency_matrix graph_adjacency_matrix.c)
|
||||
add_executable(graph_adjacency_list_test graph_adjacency_list_test.c)
|
||||
add_executable(graph_bfs graph_bfs.c)
|
||||
add_executable(graph_dfs graph_dfs.c)
|
||||
@@ -0,0 +1,171 @@
|
||||
/**
|
||||
* File: graph_adjacency_list.c
|
||||
* Created Time: 2023-07-07
|
||||
* Author: NI-SW (947743645@qq.com)
|
||||
*/
|
||||
|
||||
#include "../utils/common.h"
|
||||
|
||||
// Предположим, что максимальное число узлов равно 100
|
||||
#define MAX_SIZE 100
|
||||
|
||||
/* Структура узла */
|
||||
typedef struct AdjListNode {
|
||||
Vertex *vertex; // Вершина
|
||||
struct AdjListNode *next; // Узел-преемник
|
||||
} AdjListNode;
|
||||
|
||||
/* Класс неориентированного графа на основе списка смежности */
|
||||
typedef struct {
|
||||
AdjListNode *heads[MAX_SIZE]; // Массив узлов
|
||||
int size; // Количество узлов
|
||||
} GraphAdjList;
|
||||
|
||||
/* Конструктор */
|
||||
GraphAdjList *newGraphAdjList() {
|
||||
GraphAdjList *graph = (GraphAdjList *)malloc(sizeof(GraphAdjList));
|
||||
if (!graph) {
|
||||
return NULL;
|
||||
}
|
||||
graph->size = 0;
|
||||
for (int i = 0; i < MAX_SIZE; i++) {
|
||||
graph->heads[i] = NULL;
|
||||
}
|
||||
return graph;
|
||||
}
|
||||
|
||||
/* Деструктор */
|
||||
void delGraphAdjList(GraphAdjList *graph) {
|
||||
for (int i = 0; i < graph->size; i++) {
|
||||
AdjListNode *cur = graph->heads[i];
|
||||
while (cur != NULL) {
|
||||
AdjListNode *next = cur->next;
|
||||
if (cur != graph->heads[i]) {
|
||||
free(cur);
|
||||
}
|
||||
cur = next;
|
||||
}
|
||||
free(graph->heads[i]->vertex);
|
||||
free(graph->heads[i]);
|
||||
}
|
||||
free(graph);
|
||||
}
|
||||
|
||||
/* Найти узел, соответствующий вершине */
|
||||
AdjListNode *findNode(GraphAdjList *graph, Vertex *vet) {
|
||||
for (int i = 0; i < graph->size; i++) {
|
||||
if (graph->heads[i]->vertex == vet) {
|
||||
return graph->heads[i];
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/* Вспомогательная функция добавления ребра */
|
||||
void addEdgeHelper(AdjListNode *head, Vertex *vet) {
|
||||
AdjListNode *node = (AdjListNode *)malloc(sizeof(AdjListNode));
|
||||
node->vertex = vet;
|
||||
// Вставка в голову
|
||||
node->next = head->next;
|
||||
head->next = node;
|
||||
}
|
||||
|
||||
/* Добавление ребра */
|
||||
void addEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {
|
||||
AdjListNode *head1 = findNode(graph, vet1);
|
||||
AdjListNode *head2 = findNode(graph, vet2);
|
||||
assert(head1 != NULL && head2 != NULL && head1 != head2);
|
||||
// Добавить ребро vet1 - vet2
|
||||
addEdgeHelper(head1, vet2);
|
||||
addEdgeHelper(head2, vet1);
|
||||
}
|
||||
|
||||
/* Вспомогательная функция удаления ребра */
|
||||
void removeEdgeHelper(AdjListNode *head, Vertex *vet) {
|
||||
AdjListNode *pre = head;
|
||||
AdjListNode *cur = head->next;
|
||||
// Искать в связном списке узел, соответствующий vet
|
||||
while (cur != NULL && cur->vertex != vet) {
|
||||
pre = cur;
|
||||
cur = cur->next;
|
||||
}
|
||||
if (cur == NULL)
|
||||
return;
|
||||
// Удалить из связного списка узел, соответствующий vet
|
||||
pre->next = cur->next;
|
||||
// Освободить память
|
||||
free(cur);
|
||||
}
|
||||
|
||||
/* Удаление ребра */
|
||||
void removeEdge(GraphAdjList *graph, Vertex *vet1, Vertex *vet2) {
|
||||
AdjListNode *head1 = findNode(graph, vet1);
|
||||
AdjListNode *head2 = findNode(graph, vet2);
|
||||
assert(head1 != NULL && head2 != NULL);
|
||||
// Удалить ребро vet1 - vet2
|
||||
removeEdgeHelper(head1, head2->vertex);
|
||||
removeEdgeHelper(head2, head1->vertex);
|
||||
}
|
||||
|
||||
/* Добавление вершины */
|
||||
void addVertex(GraphAdjList *graph, Vertex *vet) {
|
||||
assert(graph != NULL && graph->size < MAX_SIZE);
|
||||
AdjListNode *head = (AdjListNode *)malloc(sizeof(AdjListNode));
|
||||
head->vertex = vet;
|
||||
head->next = NULL;
|
||||
// Добавить новый список в список смежности
|
||||
graph->heads[graph->size++] = head;
|
||||
}
|
||||
|
||||
/* Удаление вершины */
|
||||
void removeVertex(GraphAdjList *graph, Vertex *vet) {
|
||||
AdjListNode *node = findNode(graph, vet);
|
||||
assert(node != NULL);
|
||||
// Удалить из списка смежности список, соответствующий вершине vet
|
||||
AdjListNode *cur = node, *pre = NULL;
|
||||
while (cur) {
|
||||
pre = cur;
|
||||
cur = cur->next;
|
||||
free(pre);
|
||||
}
|
||||
// Обойти списки других вершин и удалить все ребра, содержащие vet
|
||||
for (int i = 0; i < graph->size; i++) {
|
||||
cur = graph->heads[i];
|
||||
pre = NULL;
|
||||
while (cur) {
|
||||
pre = cur;
|
||||
cur = cur->next;
|
||||
if (cur && cur->vertex == vet) {
|
||||
pre->next = cur->next;
|
||||
free(cur);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
// Сдвинуть вершины после данной вперед, чтобы заполнить образовавшийся пробел
|
||||
int i;
|
||||
for (i = 0; i < graph->size; i++) {
|
||||
if (graph->heads[i] == node)
|
||||
break;
|
||||
}
|
||||
for (int j = i; j < graph->size - 1; j++) {
|
||||
graph->heads[j] = graph->heads[j + 1];
|
||||
}
|
||||
graph->size--;
|
||||
free(vet);
|
||||
}
|
||||
|
||||
/* Вывести список смежности */
|
||||
void printGraph(const GraphAdjList *graph) {
|
||||
printf("Список смежности =\n");
|
||||
for (int i = 0; i < graph->size; ++i) {
|
||||
AdjListNode *node = graph->heads[i];
|
||||
printf("%d: [", node->vertex->val);
|
||||
node = node->next;
|
||||
while (node) {
|
||||
printf("%d, ", node->vertex->val);
|
||||
node = node->next;
|
||||
}
|
||||
printf("]\n");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
/**
|
||||
* File: graph_adjacency_list_test.c
|
||||
* Created Time: 2023-07-11
|
||||
* Author: NI-SW (947743645@qq.com)
|
||||
*/
|
||||
|
||||
#include "graph_adjacency_list.c"
|
||||
|
||||
/* Driver Code */
|
||||
int main() {
|
||||
int vals[] = {1, 3, 2, 5, 4};
|
||||
int size = sizeof(vals) / sizeof(vals[0]);
|
||||
Vertex **v = valsToVets(vals, size);
|
||||
Vertex *edges[][2] = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]}, {v[2], v[3]}, {v[2], v[4]}, {v[3], v[4]}};
|
||||
int egdeSize = sizeof(edges) / sizeof(edges[0]);
|
||||
GraphAdjList *graph = newGraphAdjList();
|
||||
// Добавить все вершины и ребра
|
||||
for (int i = 0; i < size; i++) {
|
||||
addVertex(graph, v[i]);
|
||||
}
|
||||
for (int i = 0; i < egdeSize; i++) {
|
||||
addEdge(graph, edges[i][0], edges[i][1]);
|
||||
}
|
||||
printf("\nПосле инициализации граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
/* Добавление ребра */
|
||||
// Вершины 1 и 2 соответствуют v[0] и v[2]
|
||||
addEdge(graph, v[0], v[2]);
|
||||
printf("\nПосле добавления ребра 1-2 граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
/* Удаление ребра */
|
||||
// Вершины 1 и 3 соответствуют v[0] и v[1]
|
||||
removeEdge(graph, v[0], v[1]);
|
||||
printf("\nПосле удаления ребра 1-3 граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
/* Добавление вершины */
|
||||
Vertex *v5 = newVertex(6);
|
||||
addVertex(graph, v5);
|
||||
printf("\nПосле добавления вершины 6 граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
/* Удаление вершины */
|
||||
// Вершина 3 соответствует v[1]
|
||||
removeVertex(graph, v[1]);
|
||||
printf("\nПосле удаления вершины 3 граф имеет вид:\n");
|
||||
printGraph(graph);
|
||||
|
||||
// Освободить память
|
||||
delGraphAdjList(graph);
|
||||
free(v);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,150 @@
|
||||
/**
|
||||
* File: graph_adjacency_matrix.c
|
||||
* Created Time: 2023-07-06
|
||||
* Author: NI-SW (947743645@qq.com)
|
||||
*/
|
||||
|
||||
#include "../utils/common.h"
|
||||
|
||||
// Предположить, что максимальное число вершин равно 100
|
||||
#define MAX_SIZE 100
|
||||
|
||||
/* Структура неориентированного графа на основе матрицы смежности */
|
||||
typedef struct {
|
||||
int vertices[MAX_SIZE];
|
||||
int adjMat[MAX_SIZE][MAX_SIZE];
|
||||
int size;
|
||||
} GraphAdjMat;
|
||||
|
||||
/* Конструктор */
|
||||
GraphAdjMat *newGraphAdjMat() {
|
||||
GraphAdjMat *graph = (GraphAdjMat *)malloc(sizeof(GraphAdjMat));
|
||||
graph->size = 0;
|
||||
for (int i = 0; i < MAX_SIZE; i++) {
|
||||
for (int j = 0; j < MAX_SIZE; j++) {
|
||||
graph->adjMat[i][j] = 0;
|
||||
}
|
||||
}
|
||||
return graph;
|
||||
}
|
||||
|
||||
/* Деструктор */
|
||||
void delGraphAdjMat(GraphAdjMat *graph) {
|
||||
free(graph);
|
||||
}
|
||||
|
||||
/* Добавление вершины */
|
||||
void addVertex(GraphAdjMat *graph, int val) {
|
||||
if (graph->size == MAX_SIZE) {
|
||||
fprintf(stderr, "Количество вершин графа уже достигло максимума\n");
|
||||
return;
|
||||
}
|
||||
// Добавить n-ю вершину и обнулить n-ю строку и столбец
|
||||
int n = graph->size;
|
||||
graph->vertices[n] = val;
|
||||
for (int i = 0; i <= n; i++) {
|
||||
graph->adjMat[n][i] = graph->adjMat[i][n] = 0;
|
||||
}
|
||||
graph->size++;
|
||||
}
|
||||
|
||||
/* Удаление вершины */
|
||||
void removeVertex(GraphAdjMat *graph, int index) {
|
||||
if (index < 0 || index >= graph->size) {
|
||||
fprintf(stderr, "индекс вершины выходит за границы\n");
|
||||
return;
|
||||
}
|
||||
// Удалить вершину с индексом index из списка вершин
|
||||
for (int i = index; i < graph->size - 1; i++) {
|
||||
graph->vertices[i] = graph->vertices[i + 1];
|
||||
}
|
||||
// Удалить строку с индексом index из матрицы смежности
|
||||
for (int i = index; i < graph->size - 1; i++) {
|
||||
for (int j = 0; j < graph->size; j++) {
|
||||
graph->adjMat[i][j] = graph->adjMat[i + 1][j];
|
||||
}
|
||||
}
|
||||
// Удалить столбец с индексом index из матрицы смежности
|
||||
for (int i = 0; i < graph->size; i++) {
|
||||
for (int j = index; j < graph->size - 1; j++) {
|
||||
graph->adjMat[i][j] = graph->adjMat[i][j + 1];
|
||||
}
|
||||
}
|
||||
graph->size--;
|
||||
}
|
||||
|
||||
/* Добавление ребра */
|
||||
// Параметры i и j соответствуют индексам элементов vertices
|
||||
void addEdge(GraphAdjMat *graph, int i, int j) {
|
||||
if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
|
||||
fprintf(stderr, "индексы ребра выходят за границы или совпадают\n");
|
||||
return;
|
||||
}
|
||||
graph->adjMat[i][j] = 1;
|
||||
graph->adjMat[j][i] = 1;
|
||||
}
|
||||
|
||||
/* Удаление ребра */
|
||||
// Параметры i и j соответствуют индексам элементов vertices
|
||||
void removeEdge(GraphAdjMat *graph, int i, int j) {
|
||||
if (i < 0 || j < 0 || i >= graph->size || j >= graph->size || i == j) {
|
||||
fprintf(stderr, "индексы ребра выходят за границы или совпадают\n");
|
||||
return;
|
||||
}
|
||||
graph->adjMat[i][j] = 0;
|
||||
graph->adjMat[j][i] = 0;
|
||||
}
|
||||
|
||||
/* Вывести матрицу смежности */
|
||||
void printGraphAdjMat(GraphAdjMat *graph) {
|
||||
printf("Список вершин = ");
|
||||
printArray(graph->vertices, graph->size);
|
||||
printf("Матрица смежности =\n");
|
||||
for (int i = 0; i < graph->size; i++) {
|
||||
printArray(graph->adjMat[i], graph->size);
|
||||
}
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
int main() {
|
||||
// Инициализация неориентированного графа
|
||||
GraphAdjMat *graph = newGraphAdjMat();
|
||||
int vertices[] = {1, 3, 2, 5, 4};
|
||||
for (int i = 0; i < 5; i++) {
|
||||
addVertex(graph, vertices[i]);
|
||||
}
|
||||
int edges[][2] = {{0, 1}, {0, 3}, {1, 2}, {2, 3}, {2, 4}, {3, 4}};
|
||||
for (int i = 0; i < 6; i++) {
|
||||
addEdge(graph, edges[i][0], edges[i][1]);
|
||||
}
|
||||
printf("\nПосле инициализации граф имеет вид\n");
|
||||
printGraphAdjMat(graph);
|
||||
|
||||
/* Добавление ребра */
|
||||
// Индексы вершин 1 и 2 равны 0 и 2 соответственно
|
||||
addEdge(graph, 0, 2);
|
||||
printf("\nПосле добавления ребра 1-2 граф имеет вид\n");
|
||||
printGraphAdjMat(graph);
|
||||
|
||||
/* Удаление ребра */
|
||||
// Индексы вершин 1 и 3 равны 0 и 1 соответственно
|
||||
removeEdge(graph, 0, 1);
|
||||
printf("\nПосле удаления ребра 1-3 граф имеет вид\n");
|
||||
printGraphAdjMat(graph);
|
||||
|
||||
/* Добавление вершины */
|
||||
addVertex(graph, 6);
|
||||
printf("\nПосле добавления вершины 6 граф имеет вид\n");
|
||||
printGraphAdjMat(graph);
|
||||
|
||||
/* Удаление вершины */
|
||||
// Индекс вершины 3 равен 1
|
||||
removeVertex(graph, 1);
|
||||
printf("\nПосле удаления вершины 3 граф имеет вид\n");
|
||||
printGraphAdjMat(graph);
|
||||
|
||||
// Освободить память
|
||||
delGraphAdjMat(graph);
|
||||
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,116 @@
|
||||
/**
|
||||
* File: graph_bfs.c
|
||||
* Created Time: 2023-07-11
|
||||
* Author: NI-SW (947743645@qq.com)
|
||||
*/
|
||||
|
||||
#include "graph_adjacency_list.c"
|
||||
|
||||
// Предположим, что максимальное число узлов равно 100
|
||||
#define MAX_SIZE 100
|
||||
|
||||
/* Структура очереди узлов */
|
||||
typedef struct {
|
||||
Vertex *vertices[MAX_SIZE];
|
||||
int front, rear, size;
|
||||
} Queue;
|
||||
|
||||
/* Конструктор */
|
||||
Queue *newQueue() {
|
||||
Queue *q = (Queue *)malloc(sizeof(Queue));
|
||||
q->front = q->rear = q->size = 0;
|
||||
return q;
|
||||
}
|
||||
|
||||
/* Проверка, пуста ли очередь */
|
||||
int isEmpty(Queue *q) {
|
||||
return q->size == 0;
|
||||
}
|
||||
|
||||
/* Операция добавления в очередь */
|
||||
void enqueue(Queue *q, Vertex *vet) {
|
||||
q->vertices[q->rear] = vet;
|
||||
q->rear = (q->rear + 1) % MAX_SIZE;
|
||||
q->size++;
|
||||
}
|
||||
|
||||
/* Операция извлечения из очереди */
|
||||
Vertex *dequeue(Queue *q) {
|
||||
Vertex *vet = q->vertices[q->front];
|
||||
q->front = (q->front + 1) % MAX_SIZE;
|
||||
q->size--;
|
||||
return vet;
|
||||
}
|
||||
|
||||
/* Проверить, была ли вершина уже посещена */
|
||||
int isVisited(Vertex **visited, int size, Vertex *vet) {
|
||||
// Искать узел обходом за O(n) времени
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (visited[i] == vet)
|
||||
return 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Обход в ширину */
|
||||
// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
|
||||
void graphBFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize, Vertex **visited, int *visitedSize) {
|
||||
// Очередь используется для реализации BFS
|
||||
Queue *queue = newQueue();
|
||||
enqueue(queue, startVet);
|
||||
visited[(*visitedSize)++] = startVet;
|
||||
// Начиная с вершины vet, продолжать цикл, пока не будут посещены все вершины
|
||||
while (!isEmpty(queue)) {
|
||||
Vertex *vet = dequeue(queue); // Извлечь головную вершину из очереди
|
||||
res[(*resSize)++] = vet; // Отметить посещенную вершину
|
||||
// Обойти все смежные вершины данной вершины
|
||||
AdjListNode *node = findNode(graph, vet);
|
||||
while (node != NULL) {
|
||||
// Пропустить уже посещенную вершину
|
||||
if (!isVisited(visited, *visitedSize, node->vertex)) {
|
||||
enqueue(queue, node->vertex); // Помещать в очередь только непосещенные вершины
|
||||
visited[(*visitedSize)++] = node->vertex; // Отметить эту вершину как посещенную
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
// Освободить память
|
||||
free(queue);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
int main() {
|
||||
// Инициализация неориентированного графа
|
||||
int vals[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
|
||||
int size = sizeof(vals) / sizeof(vals[0]);
|
||||
Vertex **v = valsToVets(vals, size);
|
||||
Vertex *edges[][2] = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]}, {v[1], v[4]}, {v[2], v[5]}, {v[3], v[4]},
|
||||
{v[3], v[6]}, {v[4], v[5]}, {v[4], v[7]}, {v[5], v[8]}, {v[6], v[7]}, {v[7], v[8]}};
|
||||
int egdeSize = sizeof(edges) / sizeof(edges[0]);
|
||||
GraphAdjList *graph = newGraphAdjList();
|
||||
// Добавить все вершины и ребра
|
||||
for (int i = 0; i < size; i++) {
|
||||
addVertex(graph, v[i]);
|
||||
}
|
||||
for (int i = 0; i < egdeSize; i++) {
|
||||
addEdge(graph, edges[i][0], edges[i][1]);
|
||||
}
|
||||
printf("\nПосле инициализации граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
// Обход в ширину
|
||||
// Последовательность обхода вершин
|
||||
Vertex *res[MAX_SIZE];
|
||||
int resSize = 0;
|
||||
// Используется для записи уже посещенных вершин
|
||||
Vertex *visited[MAX_SIZE];
|
||||
int visitedSize = 0;
|
||||
graphBFS(graph, v[0], res, &resSize, visited, &visitedSize);
|
||||
printf("\nПоследовательность вершин при обходе в ширину (BFS)\n");
|
||||
printArray(vetsToVals(res, resSize), resSize);
|
||||
|
||||
// Освободить память
|
||||
delGraphAdjList(graph);
|
||||
free(v);
|
||||
return 0;
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
/**
|
||||
* File: graph_dfs.c
|
||||
* Created Time: 2023-07-13
|
||||
* Author: NI-SW (947743645@qq.com)
|
||||
*/
|
||||
|
||||
#include "graph_adjacency_list.c"
|
||||
|
||||
// Предположим, что максимальное число узлов равно 100
|
||||
#define MAX_SIZE 100
|
||||
|
||||
/* Проверить, была ли вершина уже посещена */
|
||||
int isVisited(Vertex **res, int size, Vertex *vet) {
|
||||
// Искать узел обходом за O(n) времени
|
||||
for (int i = 0; i < size; i++) {
|
||||
if (res[i] == vet) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Вспомогательная функция обхода в глубину */
|
||||
void dfs(GraphAdjList *graph, Vertex **res, int *resSize, Vertex *vet) {
|
||||
// Отметить посещенную вершину
|
||||
res[(*resSize)++] = vet;
|
||||
// Обойти все смежные вершины данной вершины
|
||||
AdjListNode *node = findNode(graph, vet);
|
||||
while (node != NULL) {
|
||||
// Пропустить уже посещенную вершину
|
||||
if (!isVisited(res, *resSize, node->vertex)) {
|
||||
// Рекурсивно обходить смежные вершины
|
||||
dfs(graph, res, resSize, node->vertex);
|
||||
}
|
||||
node = node->next;
|
||||
}
|
||||
}
|
||||
|
||||
/* Обход в глубину */
|
||||
// Использовать список смежности для представления графа, чтобы получить все смежные вершины заданной вершины
|
||||
void graphDFS(GraphAdjList *graph, Vertex *startVet, Vertex **res, int *resSize) {
|
||||
dfs(graph, res, resSize, startVet);
|
||||
}
|
||||
|
||||
/* Driver Code */
|
||||
int main() {
|
||||
// Инициализация неориентированного графа
|
||||
int vals[] = {0, 1, 2, 3, 4, 5, 6};
|
||||
int size = sizeof(vals) / sizeof(vals[0]);
|
||||
Vertex **v = valsToVets(vals, size);
|
||||
Vertex *edges[][2] = {{v[0], v[1]}, {v[0], v[3]}, {v[1], v[2]}, {v[2], v[5]}, {v[4], v[5]}, {v[5], v[6]}};
|
||||
int egdeSize = sizeof(edges) / sizeof(edges[0]);
|
||||
GraphAdjList *graph = newGraphAdjList();
|
||||
// Добавить все вершины и ребра
|
||||
for (int i = 0; i < size; i++) {
|
||||
addVertex(graph, v[i]);
|
||||
}
|
||||
for (int i = 0; i < egdeSize; i++) {
|
||||
addEdge(graph, edges[i][0], edges[i][1]);
|
||||
}
|
||||
printf("\nПосле инициализации граф имеет вид\n");
|
||||
printGraph(graph);
|
||||
|
||||
// Обход в глубину
|
||||
Vertex *res[MAX_SIZE];
|
||||
int resSize = 0;
|
||||
graphDFS(graph, v[0], res, &resSize);
|
||||
printf("\nПоследовательность вершин при обходе в глубину (DFS)\n");
|
||||
printArray(vetsToVals(res, resSize), resSize);
|
||||
|
||||
// Освободить память
|
||||
delGraphAdjList(graph);
|
||||
free(v);
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user