用Java函数实现图的深度优先搜索(DFS)和广度优先搜索(BFS)算法

图的深度优先搜索（DFS）和广度优先搜索（BFS）是用于图遍历的两种常用算法。下面将使用Java函数分别实现这两种算法。

1. 深度优先搜索（DFS）算法的实现：

import java.util.*;

class Graph {
    private int V; // 图中顶点的数量
    private LinkedList<Integer> adj[]; // 邻接表

    Graph(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
    }

    void addEdge(int v, int w) {
        adj[v].add(w); // 添加边
    }

    void DFSUtil(int v, boolean visited[]) {
        visited[v] = true; // 标记v为已访问
        System.out.print(v + " ");

        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n])
                DFSUtil(n, visited); // 递归访问邻接顶点
        }
    }

    void DFS(int v) {
        boolean visited[] = new boolean[V]; // 记录顶点是否已访问
        
        DFSUtil(v, visited); // 从v开始深度优先搜索
        
        for (int i = 0; i < V; ++i) {
            if (visited[i] == false)
                DFSUtil(i, visited); // 对未访问的顶点进行深度优先搜索
        }
    }
}

public class Main {
    public static void main(String args[]) {
        Graph g = new Graph(4);

        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("深度优先搜索（DFS）算法结果：");
        g.DFS(2); // 从顶点2开始进行深度优先搜索
    }
}

输出结果：

深度优先搜索（DFS）算法结果：
2 0 1 3

2. 广度优先搜索（BFS）算法的实现：

import java.util.*;

class Graph {
    private int V; // 图中顶点的数量
    private LinkedList<Integer> adj[]; // 邻接表

    Graph(int v) {
        V = v;
        adj = new LinkedList[v];
        for (int i=0; i<v; ++i)
            adj[i] = new LinkedList();
    }

    void addEdge(int v, int w) {
        adj[v].add(w); // 添加边
    }

    void BFS(int s) {
        boolean visited[] = new boolean[V]; // 记录顶点是否已访问

        LinkedList<Integer> queue = new LinkedList<>();

        visited[s] = true;
        queue.add(s); // 将顶点s加入队列

        while (queue.size() != 0) {
            s = queue.poll(); // 从队列中取出并删除一个顶点
            System.out.print(s + " ");

            Iterator<Integer> i = adj[s].listIterator();
            while (i.hasNext()) {
                int n = i.next();
                if (!visited[n]) {
                    visited[n] = true;
                    queue.add(n); // 将未访问过的邻接顶点加入队列
                }
            }
        }
    }
}

public class Main {
    public static void main(String args[]) {
        Graph g = new Graph(4);

        g.addEdge(0, 1);
        g.addEdge(0, 2);
        g.addEdge(1, 2);
        g.addEdge(2, 0);
        g.addEdge(2, 3);
        g.addEdge(3, 3);

        System.out.println("广度优先搜索（BFS）算法结果：");
        g.BFS(2); // 从顶点2开始进行广度优先搜索
    }
}

输出结果：

广度优先搜索（BFS）算法结果：
2 0 3 1

上述代码中，我们首先创建了一个Graph类，其中有一个邻接表LinkedList<Integer>[] adj用于表示图的结构。然后，我们实现了深度优先搜索算法DFS和广度优先搜索算法BFS。在DFSUtil函数中，我们使用递归进行深度优先搜索，并使用一个boolean数组visited[]记录顶点是否已经被访问过。在DFS函数中，我们遍历所有未访问的顶点，并从每个顶点开始进行深度优先搜索。同样，在BFS函数中，我们使用一个队列LinkedList<Integer> queue来进行广度优先搜索，并在遍历顶点时更新visited[]数组。

以上是使用Java函数实现图的深度优先搜索（DFS）和广度优先搜索（BFS）算法的示例代码。这两种算法是图遍历中非常常用的，可以用于解决很多与图相关的问题。