Java函数：使用递归实现深度优先搜索和广度优先搜索

1. 深度优先搜索

深度优先搜索（Depth First Search，DFS）是一种常见的搜索算法。它的基本思路是尽可能沿着一条路径一直走到底，只有当无法继续下去时，才返回上一层进行后续搜索。

使用递归实现深度优先搜索，可以采用如下的算法：

DFS(v):
    如果 v 已经被访问过，则退出函数。
    将 v 标记为已经访问。
    对于 v 的每个邻居 u，如果 u 没有被访问过，则递归调用 DFS(u)。

其中，v 表示当前正在搜索的节点，如果 v 已经被访问过，则退出函数；否则，将 v 标记为已经访问，并对 v 的每个邻居 u 进行递归调用 DFS(u)。

例如，考虑以下的图：

A ── B ── C
│     │     │
D ── E ── F

从 A 开始进行深度优先搜索，按照描绘出的流程，搜索的先后顺序为 A → B → C → E → F → D。

Java 代码实现：

import java.util.*;

public class Graph {
    private int V;
    private LinkedList<Integer> adj[];
    
    public Graph(int v) {
        V = v;
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList();
        }
    }
    
    public void addEdge(int v, int w) {
        adj[v].add(w);
    }
    
    public void DFS(int v, boolean visited[]) {
        visited[v] = true;
        System.out.print(v + " ");
        
        Iterator<Integer> i = adj[v].listIterator();
        while (i.hasNext()) {
            int n = i.next();
            if (!visited[n]) {
                DFS(n, visited);
            }
        }
    }
    
    public void DFS(int v) {
        boolean visited[] = new boolean[V];
        DFS(v, visited);
    }
    
    public static void main(String[] args) {
        Graph g = new Graph(6);
        
        g.addEdge(0, 1);
        g.addEdge(0, 3);
        g.addEdge(1, 2);
        g.addEdge(2, 5);
        g.addEdge(4, 5);
        g.addEdge(3, 4);
        g.addEdge(1, 4);
        
        System.out.println("Following is Depth First Traversal (starting from vertex 0)");
        g.DFS(0);
    }
}

输出结果为：

Following is Depth First Traversal (starting from vertex 0)
0 1 2 5 4 3

2. 广度优先搜索

广度优先搜索（Breadth First Search，BFS）也是一种常见的搜索算法。它的基本思路是从起始节点开始，逐层地向外搜索，先搜索距离起始节点为 1 的节点，再搜索距离起始节点为 2 的节点，以此类推。

使用递归实现广度优先搜索，可以采用如下的算法：

BFS(v):
    将 v 加入队列。
    将 v 标记为已经访问。
    while 队列非空：
        从队列中取出一个节点 u。
        对于 u 的每个邻居 w，如果 w 没有被访问过，则将 w 加入队列，并标记为已经访问。

其中，v 表示起始节点，首先将 v 加入队列，并将 v 标记为已经访问；然后循环取出队列中的节点进行处理，对于每个节点 u，遍历其所有的邻居 w，如果 w 没有被访问过，则将 w 加入队列，并标记为已经访问。

例如，考虑以下的图：

A ── B ── C
│     │     │
D ── E ── F

从 A 开始进行广度优先搜索，按照描绘出的流程，搜索的先后顺序为 A → B → D → C → E → F。

Java 代码实现：

import java.util.*;

public class Graph {
    private int V;
    private LinkedList<Integer> adj[];
    
    public Graph(int v) {
        V = v;
        adj = new LinkedList[V];
        for (int i = 0; i < V; i++) {
            adj[i] = new LinkedList();
        }
    }
    
    public void addEdge(int v, int w) {
        adj[v].add(w);
    }
    
    public void BFS(int s) {
        boolean visited[] = new boolean[V];
        LinkedList<Integer> queue = new LinkedList<Integer>();
        
        visited[s] = true;
        queue.add(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 static void main(String[] args) {
        Graph g = new Graph(6);
        
        g.addEdge(0, 1);
        g.addEdge(0, 3);
        g.addEdge(1, 2);
        g.addEdge(2, 5);
        g.addEdge(4, 5);
        g.addEdge(3, 4);
        g.addEdge(1, 4);
        
        System.out.println("Following is Breadth First Traversal (starting from vertex 0)");
        g.BFS(0);
    }
}

输出结果为：

Following is Breadth First Traversal (starting from vertex 0)
0 1 3 2 4 5

综上所述，使用递归实现深度优先搜索和广度优先搜索是一种简单且易于实现的方式，Java 代码实现也比较简洁，并且容易理解。在实际应用中，根据实际需求和场景选择相应的搜索算法是十分重要的。