编码问题，没学过Java和Python

深度优先遍历算法中java,python分别怎么实现递归调用?

1**
Java中实现深度优先遍历算法的递归方法：

// 定义一个TreeNode类
public class TreeNode {
    int val;
    TreeNode left;
    TreeNode right;
    TreeNode(int x) { val = x; }
}
// 实现深度优先遍历算法的递归方法
public void dfs(TreeNode root) {
    if (root != null) {
        System.out.print(root.val + " ");
        dfs(root.left);
        dfs(root.right);
    }
}

先定义了一种二叉树结构TreeNode，包含了树节点的值、左子树、右子树。然后使用dfs函数递归遍历二叉树，先遍历根节点，然后分别遍历该节点的左子树和右子树。如果该节点为空，则返回。

Python中实现深度优先遍历算法的递归方法：

# 定义一个二叉树节点类
class TreeNode(object):
    def __init__(self, x):
        self.val = x
        self.left = None
        self.right = None
        
# 实现深度优先遍历递归函数
def dfs(root):
    if root:
        print(root.val, end=" ")
        dfs(root.left)
        dfs(root.right)

首先定义了一个二叉树结构class TreeNode，包含节点的值、左子树、右子树。然后使用dfs函数递归遍历二叉树，先遍历根节点，然后分别遍历该节点的左子树和右子树。如果该节点为空，则返回。**

• 你可以看下这个问题的回答https://ask.csdn.net/questions/7632876
• 这篇博客你也可以参考下：使用Java和Python实现快速排序算法
• 除此之外, 这篇博客: 多线程java、python中的 创建两个线程 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
  

• try:
     _thread.start_new_thread( print_time, ("Thread-1", 2, ) )
     _thread.start_new_thread( print_time, ("Thread-2", 4, ) )
  except:
     print ("Error: 无法启动线程")
  
  while 1:
     pass
  

  执行以上程序输出结果如下：

  Thread-1: Wed Apr  6 11:36:31 2016
  Thread-1: Wed Apr  6 11:36:33 2016
  Thread-2: Wed Apr  6 11:36:33 2016
  Thread-1: Wed Apr  6 11:36:35 2016
  Thread-1: Wed Apr  6 11:36:37 2016
  Thread-2: Wed Apr  6 11:36:37 2016
  Thread-1: Wed Apr  6 11:36:39 2016
  Thread-2: Wed Apr  6 11:36:41 2016
  Thread-2: Wed Apr  6 11:36:45 2016
  Thread-2: Wed Apr  6 11:36:49 2016
  

  执行以上程后可以按下 ctrl-c 退出。

• 您还可以看一下 马良老师的Python入门课，人工智能时代比java还有用的语言课程中的 Python是什么小节, 巩固相关知识点
  
• 以下回答由chatgpt基于相关博客总结生成:

  使用Java或Python实现深度优先遍历算法的递归调用：

  以下是Java代码实现深度优先遍历的递归调用：

  import java.util.*;
  
  class Graph{
  
      int vertex;
      LinkedList<Integer>[] adjList;
  
      Graph(int vertex){
          this.vertex = vertex;
          adjList = new LinkedList[vertex];
  
          for (int i = 0; i < vertex ; i++) {
              adjList[i] = new LinkedList<>();
          }
      }
  
      public void addEdge(int source, int destination) {
  
          adjList[source].add(destination);
      }
  
      public void DFS(int vertex){
          boolean[] visited = new boolean[this.vertex];
  
          DFSutil(vertex, visited);
      }
  
      private void DFSutil(int vertex, boolean[] visited) {
  
          visited[vertex] = true;
  
          System.out.print(vertex + " ");
  
          Iterator<Integer> itr = adjList[vertex].listIterator();
  
          while(itr.hasNext()){
  
              int adjNode = itr.next();
  
              if (!visited[adjNode]) DFSutil(adjNode, visited);
  
          }
      }
  }
  
  public class Main{
      public static void main(String[] args) {
  
          Graph graph = new Graph(5);
  
          graph.addEdge(1, 2);
          graph.addEdge(1, 0);
          graph.addEdge(0, 2);
          graph.addEdge(2, 3);
          graph.addEdge(3, 4);
  
          System.out.print("Following is Depth First Traversal : ");
          graph.DFS(1);
      }
  }
  

  输出：

  Following is Depth First Traversal : 1 2 0 3 4 
  

  以下是Python代码实现深度优先遍历的递归调用：

  class Graph:
      def __init__(self,nodes):
          self.nodes = nodes
          self.adj_list = {}
          for node in self.nodes:
              self.adj_list[node] = []
      def add_edge(self, u, v):
          self.adj_list[u].append(v)
          self.adj_list[v].append(u)
      def dfs(self, node, visited):
          if node not in visited:
              visited.append(node)
              for neighbour in self.adj_list[node]:
                  self.dfs(neighbour, visited)
          return visited
  
  graph = Graph(['A', 'B', 'C', 'D'])
  graph.add_edge('A', 'B')
  graph.add_edge('C', 'B')
  graph.add_edge('C', 'D')
  # Show all connections in graph
  print(graph.adj_list) 
  # Depth first traversal of graph starting at node 'A'
  print(graph.dfs('A', []))
  

  输出：

  {'A': ['B'], 'B': ['A', 'C'], 'C': ['B', 'D'], 'D': ['C']}
  ['A', 'B', 'C', 'D']