假设图采用邻接矩阵存储，设计一个从顶点，出发的深度优先遍历算法

好的，我理解了你的问题。

以下是一个从顶点出发的深度优先遍历算法，假设图用邻接矩阵存储：

def dfs(graph, start):
    # 创建一个栈来存储遍历过的顶点
    stack = [start]
    # 创建一个列表来存储已经遍历过的顶点
    visited = [False] * len(graph)
    # 标记起始顶点为已访问
    visited[start] = True

    while stack:
        # 取出栈顶顶点
        vertex = stack.pop()
        print(vertex, end=' ')

        # 遍历与该顶点相邻的未访问过的顶点
        for i in range(len(graph)):
            if graph[vertex][i] == 1 and not visited[i]:
                # 将该顶点标记为已访问，并加入栈中
                visited[i] = True
                stack.append(i)

该算法的基本思路是：从起始顶点开始，不断地遍历与该顶点相邻的未访问过的顶点，并将它们加入栈中。当遍历完所有相邻的顶点后，从栈中取出下一个顶点，继续以上操作，直到栈为空为止。

希望这个算法能够解决你的问题。

相关问题

假设图采用邻接矩阵存储，设计一个从顶点，出发的深度优先遍历算法，请使用C语言

好的，以下是使用C语言实现从一个顶点出发的深度优先遍历算法，假设图采用邻接矩阵存储。

#include <stdio.h>
#define MAXSIZE 100

int visited[MAXSIZE] = {0}; // 记录每个节点是否被访问过

void dfs(int graph[][MAXSIZE], int start, int n) {
    visited[start] = 1; // 标记为已访问
    printf("%d ", start);
    for (int i = 0; i < n; i++) {
        if (graph[start][i] == 1 && visited[i] == 0) {
            dfs(graph, i, n); // 递归访问邻居节点
        }
    }
}

int main() {
    int n; // 节点个数
    scanf("%d", &n);
    int graph[MAXSIZE][MAXSIZE]; // 邻接矩阵
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            scanf("%d", &graph[i][j]);
        }
    }
    int start; // 起始节点
    scanf("%d", &start);
    dfs(graph, start, n);
    return 0;
}

其中，`visited`数组用于记录每个节点是否被访问过，初始值为0。`dfs`函数用于递归访问邻居节点，`graph`是邻接矩阵，`start`是起始节点，`n`是节点个数。`main`函数中读入节点个数和邻接矩阵，以及起始节点，然后调用`dfs`函数进行深度优先遍历。

希望这个算法能够帮助到你，如果你还有其他问题，可以继续问我。

邻接矩阵存储的图的深度优先遍历C语言

在C语言中，使用邻接矩阵存储的图进行深度优先搜索（Depth First Search, DFS），通常我们会维护一个栈或者递归结构来跟踪未访问的节点。下面是简单的DFS算法步骤：

1. 初始化：设置一个访问标志数组，标记所有节点为未访问，并选择一个起始节点（通常是顶点0）。

int visited[vertices] = {0}; // 假设vertices是图的节点数
visited[start_node] = 1;

2. 深度优先遍历函数：
- 创建一个递归函数dfs(node)，对每个未访问节点执行：
a. 栈入当前节点
b. 对当前节点的所有邻居（即邻接矩阵中的对应元素非零的位置）：
i. 如果邻居未访问，则标记为已访问并调用dfs递归
c. 出栈，继续处理下一个邻居，直到栈为空

void dfs(int node) {
    Stack *stack = create_stack(); // 创建堆栈用于存放节点
    push(stack, node); // 将起始节点放入堆栈

    while (!is_empty(stack)) {
        int current = pop(stack);
        if (visited[current]) {
            for (int neighbor = 0; neighbor < vertices; ++neighbor) {
                if (adj_matrix[current][neighbor] && !visited[neighbor]) {
                    visited[neighbor] = 1;
                    push(stack, neighbor);
                }
            }
        }
    }

    // 清理操作
    destroy_stack(stack);
}