为了账号安全，请及时绑定邮箱和手机立即绑定
首页 手记 深度优先遍历算法入门教程

深度优先遍历算法入门教程

标签：
深度学习 计算机视觉 算法与数据结构
深度优先遍历简介

深度优先遍历（Depth-First Search, DFS）是一种用于遍历或搜索树或图的算法。它从根节点开始，尽可能深入地沿着每个分支遍历，直到到达叶节点，然后回溯到最近的祖先节点，并继续遍历其尚未遍历的分支。DFS具有回溯机制和通常使用栈作为数据结构的特点，广泛应用于解决各种图相关问题，如路径寻找、环检测和拓扑排序等。

深度优先遍历的特点

  1. 回溯机制：DFS依赖于回溯机制，即在遍历完一个分支后返回到父节点，继续遍历其他分支。
  2. 栈数据结构：DFS通常使用栈作为数据结构来实现，虽然递归方法也隐含了栈的机制。
  3. 递归实现：递归是一种常见的DFS实现方式，递归函数在访问完一个节点后会递归地访问其子节点，直到所有子节点都被访问。

深度优先遍历的应用场景

  1. 迷宫问题：在迷宫中寻找从起点到终点的路径，可以使用DFS来解决。
  2. 图的连通性：检查图中是否存在两个节点之间的路径，可以使用DFS来确定图的连通性。
  3. 拓扑排序：对有向无环图进行排序，使得对于每一条有向边 u -> v，顶点 u 在顶点 v 的前面。
  4. 图的环检测：检测图中是否存在环，DFS可以用于此类问题的高效解决。

深度优先遍历的基本步骤

递归实现深度优先遍历

递归实现DFS的步骤如下：

  1. 访问当前节点。
  2. 对当前节点的子节点进行递归调用。
  3. 回溯到上一个节点。

示例代码如下所示（以Python为例）：

def dfs_recursive(graph, node, visited):
    if node not in visited:
        print(node)
        visited.add(node)
        for neighbor in graph[node]:
            dfs_recursive(graph, neighbor, visited)

非递归实现深度优先遍历

非递归实现DFS通常使用栈来模拟递归过程。步骤如下：

  1. 初始化一个空栈，并将起始节点压入栈。
  2. 当栈不为空时，弹出栈顶节点，访问该节点。
  3. 将与当前节点相邻的未访问节点压入栈。

示例代码如下所示（以Python为例）：

def dfs_iterative(graph, start):
    visited = set()
    stack = [start]
    while stack:
        node = stack.pop()
        if node not in visited:
            print(node)
            visited.add(node)
            stack.extend(graph[node] - visited)

深度优先遍历的代码实现

使用Python实现深度优先遍历

下面是一个简单的Python程序实现DFS，假设我们有一个有向图，用字典表示：

def dfs(graph, start, visited=None):
    if visited is None:
        visited = set()
    visited.add(start)
    print(start)
    for next in graph[start] - visited:
        dfs(graph, next, visited)
    return visited

graph = {'A': set(['B', 'C']),
         'B': set(['A', 'D', 'E']),
         'C': set(['A', 'F']),
         'D': set(['B']),
         'E': set(['B', 'F']),
         'F': set(['C', 'E'])}
dfs(graph, 'A')

使用Java实现深度优先遍历

下面是一个简单的Java程序实现DFS，同样假设我们有一个有向图，用邻接表表示：

import java.util.*;

public class Graph {
    private int vertices;
    private LinkedList<Integer>[] adjacencyList;

    public Graph(int vertices) {
        this.vertices = vertices;
        adjacencyList = new LinkedList[vertices];
        for (int i = 0; i < vertices; i++) {
            adjacencyList[i] = new LinkedList<>();
        }
    }

    public void addEdge(int source, int destination) {
        adjacencyList[source].add(destination);
    }

    public void dfs(int startVertex) {
        boolean[] visited = new boolean[vertices];
        dfsUtil(startVertex, visited);
    }

    private void dfsUtil(int vertex, boolean[] visited) {
        visited[vertex] = true;
        System.out.print(vertex + " ");
        Iterator<Integer> iterator = adjacencyList[vertex].listIterator();
        while (iterator.hasNext()) {
            int next = iterator.next();
            if (!visited[next]) {
                dfsUtil(next, visited);
            }
        }
    }

    public static void main(String[] args) {
        Graph graph = new Graph(5);
        graph.addEdge(0, 1);
        graph.addEdge(0, 2);
        graph.addEdge(1, 2);
        graph.addEdge(2, 0);
        graph.addEdge(2, 3);
        graph.addEdge(3, 3);

        System.out.println("Depth First Traversal (starting from vertex 2):");
        graph.dfs(2);
    }
}

深度优先遍历的变体

前序遍历

前序遍历是深度优先遍历的一种形式，它按照 "访问根节点 -> 递归遍历左子树 -> 递归遍历右子树" 的顺序。对于二叉树而言，前序遍历的顺序是根节点 -> 左子树 -> 右子树。

示例代码（以Python为例）：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def preorder_traversal(node):
    if node is not None:
        print(node.value)
        preorder_traversal(node.left)
        preorder_traversal(node.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
preorder_traversal(root)

示例代码（以Java为例）：

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }

    public void preorderTraversal(TreeNode root) {
        if (root != null) {
            System.out.print(root.value + " ");
            preorderTraversal(root.left);
            preorderTraversal(root.right);
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        new TreeNode().preorderTraversal(root);
    }
}

中序遍历

中序遍历按照 "递归遍历左子树 -> 访问根节点 -> 递归遍历右子树" 的顺序。对于二叉树而言，中序遍历的顺序是左子树 -> 根节点 -> 右子树。

示例代码（以Python为例）：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def inorder_traversal(node):
    if node is not None:
        inorder_traversal(node.left)
        print(node.value)
        inorder_traversal(node.right)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
inorder_traversal(root)

示例代码（以Java为例）：

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }

    public void inorderTraversal(TreeNode root) {
        if (root != null) {
            inorderTraversal(root.left);
            System.out.print(root.value + " ");
            inorderTraversal(root.right);
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        new TreeNode().inorderTraversal(root);
    }
}

后序遍历

后序遍历按照 "递归遍历左子树 -> 递归遍历右子树 -> 访问根节点" 的顺序。对于二叉树而言，后序遍历的顺序是左子树 -> 右子树 -> 根节点。

示例代码（以Python为例）：

class Node:
    def __init__(self, value):
        self.value = value
        self.left = None
        self.right = None

def postorder_traversal(node):
    if node is not None:
        postorder_traversal(node.left)
        postorder_traversal(node.right)
        print(node.value)

root = Node(1)
root.left = Node(2)
root.right = Node(3)
root.left.left = Node(4)
root.left.right = Node(5)
postorder_traversal(root)

示例代码（以Java为例）：

public class TreeNode {
    int value;
    TreeNode left;
    TreeNode right;

    public TreeNode(int value) {
        this.value = value;
        this.left = null;
        this.right = null;
    }

    public void postorderTraversal(TreeNode root) {
        if (root != null) {
            postorderTraversal(root.left);
            postorderTraversal(root.right);
            System.out.print(root.value + " ");
        }
    }

    public static void main(String[] args) {
        TreeNode root = new TreeNode(1);
        root.left = new TreeNode(2);
        root.right = new TreeNode(3);
        root.left.left = new TreeNode(4);
        root.left.right = new TreeNode(5);
        new TreeNode().postorderTraversal(root);
    }
}

深度优先遍历的优缺点

优点分析

  1. 简单：DFS实现相对简单，易于理解和编写。
  2. 适用广泛：DFS可以应用于各种数据结构，如树、图等，非常适合解决许多实际问题。
  3. 路径搜索：DFS可以用于查找从起点到终点的路径，非常适合迷宫问题等。
  4. 内存使用：在递归实现中，DFS使用栈来存储节点，内存消耗相对较小。

缺点分析

  1. 栈溢出风险：对于深度较大的树或图，递归实现可能导致栈溢出。
  2. 回溯成本高：DFS需要频繁回溯，这可能导致较高的时间复杂度。
  3. 不适用于最小路径问题：对于一些需要找到最小路径的问题，DFS可能不是最佳选择。

深度优先遍历的实际案例

用深度优先遍历解决迷宫问题

假设有一个迷宫，用二维数组表示，其中1表示墙，0表示路径，目标是找到一个从起点到终点的路径。以下是使用DFS解决迷宫问题的示例代码（以Python为例）：

def solve_maze(maze, start, end):
    path = []
    visited = set()
    if find_path(maze, start, end, path, visited):
        return path
    return "No path found"

def find_path(maze, position, end, path, visited):
    row, col = position
    if (row, col) == end:
        path.append(position)
        return True
    if (row, col) not in visited and maze[row][col] == 0:
        visited.add((row, col))
        path.append(position)
        if row > 0 and find_path(maze, (row - 1, col), end, path, visited):
            return True
        if row < len(maze) - 1 and find_path(maze, (row + 1, col), end, path, visited):
            return True
        if col > 0 and find_path(maze, (row, col - 1), end, path, visited):
            return True
        if col < len(maze[0]) - 1 and find_path(maze, (row, col + 1), end, path, visited):
            return True
        path.pop()
    return False

maze = [
    [1, 1, 0, 0, 0],
    [0, 1, 0, 1, 0],
    [0, 1, 0, 0, 1],
    [0, 0, 0, 1, 0],
    [0, 0, 0, 0, 0]
]
start = (0, 0)
end = (4, 4)
print(solve_maze(maze, start, end))

用深度优先遍历解决图的连通性问题

假设有一个图，用邻接表表示，目标是检查图中是否存在两个节点之间的路径。以下是使用DFS解决图的连通性问题的示例代码（以Python为例）：

def dfs_connected(graph, start, visited=None):
    if visited is None:
        visited = set()
    print(start)
    visited.add(start)
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs_connected(graph, neighbor, visited)

graph = {
    0: [1, 2],
    1: [0, 3],
    2: [0, 3],
    3: [1, 2, 4],
    4: [3]
}

dfs_connected(graph, 0)

总结来说，深度优先遍历是一种非常强大的算法，适用于许多实际问题。了解其基本概念、实现方法以及优缺点，可以帮助你在编程中更有效地应用它。

点击查看更多内容
发表于 2024.11.04 16:19， 共 19 人浏览

本文原创发布于慕课网 ，转载请注明出处，谢谢合作

举报
为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

作者其他优质文章

正在加载中

青春有我

JAVA开发工程师
手记
篇
粉丝
205
获赞与收藏
1008

关注作者，订阅最新文章

相关文章推荐

阅读免费教程

  • 推荐
  • 评论
  • 收藏
  • 共同学习，写下你的评论
感谢您的支持，我会继续努力的～
扫码打赏，你说多少就多少
赞赏金额会直接到老师账户
支付方式
打开微信扫一扫，即可进行扫码打赏哦
今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与 放弃机会
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消