数据结构——图的算法练习题

数据结构——图算法题总结（持续更新）

DFS

对于DFS的理解

DFS是从某个结点出发，首先找到一个相邻的结点，遍历到底，直到第一个结点完全遍历完毕之后，才会开始从第二个相邻的结点出发继续之前的操作，对于一个图

其深度优先遍历的过程为

1. 判断从结点u到v是否又简单路径

题目描述：对于无向图给定一个图的邻接表或者邻接矩阵，设计一个算法，判断从结点u到结点v是否存在简单路径

简单路径指的是，从顶点u到顶点v的这一条路径上，不存在重复的顶点，对于这个，从顶点u开始进行深度优先遍历，在深度优先遍历的过程中，如果遇到了顶点v，则返回True，如果深度优先遍历完毕之后还没有找到顶点v，那么返回False，即没有从u到v的简单路径

c++实现

bool existPath(vector<vector<int>> &matrix,int startNode,int aimNode){
    //判断传入的参数是否正确
    if(matrix.size() != matrix[0].size())
        throw runtime_error("matrix is incorrect");
    if(startNode>matrix.size() || aimNode>matrix.size())
        throw runtime_error("index out of range");
    if(startNode == aimNode)
        return true;
    //前期准备
    int i = startNode - 1,j,len = matrix.size();
    vector<bool> flag(len,false);
    vector<int> stack;
    flag[i] = true;
    stack.push_back(i);
    //开始深度递归
    while(!stack.empty()){
        i = stack.back();
        stack.pop_back();
        if(i+1 == aimNode)
            return true;
        for(j=0;j<len;j++){
            if(matrix[i][j] != 0 && !flag[j]){
                flag[j] = true;
                stack.push_back(j);
            }
        }
    }
    return false;
}

python实现

使用的是python3

def existPath(matrix:tuple,startNode:int,aimNode:int)->bool:
	"""
	tuple是邻接矩阵
	startNode是起始结点
	aimNode是目标结点
	"""
	if startNode == aimNode:
		return True
	# 前期准备
	i = startNode-1;lens = len(matrix)
	stack = list()
	flag = [False]*lens  # 构建一个重复lens次，值为False的列表
	stack.append(i)
	flag[i] = True
	# 开始深度递归
	while len(stack) != 0:
		i = stack[-1]
		del stack[-1]
		if i+1 == aimNode:
			return True
		for j in range(len(matrix)):
			if matrix[i][j] != 0 and not flag[j]:
				flag[j] = True
				stack.append(j)
	return False

java实现

    boolean existPath(int[][] matrix,int startNode,int aimNode){
        //验证传入的参数是否正确
        if(matrix.length!=matrix[0].length)
            throw new RuntimeException("matrix length is incorrect");
        if(startNode>matrix.length || aimNode>matrix.length)
            throw new IndexOutOfBoundsException("Index out of range");
        if(startNode == aimNode)
            return true;
        //前期准备
        int i = startNode-1;  //创建临时变量
        int j,len = matrix.length;
        int [][] temp_matrix = matrix;
        boolean[] flag = new boolean[len];
        for(j=0;j<len;++j){
            flag[j] = false;
        }
        flag[i] = true;  //使用栈来实现递归的过程
        Stack<Integer> stack = new Stack<>();
        stack.push(i);
        //开始深度优先遍历
        while(!stack.empty()){
            i = stack.pop();
            if(i+1 == aimNode)
                return true;
            for(j=0;j<len;++j){
                if(temp_matrix[i][j]!=0 && !flag[j]){
                    flag[j] = true;
                    stack.push(j);
                }
            }
        }
        return false;
    }

BFS