**深度优先遍历目录（Depth-First Traversal）**是一种递归或栈式的目录遍历方法，优先深入到子目录中，再回溯到父目录继续遍历其他子目录。这是一种常见的文件系统操作，适用于查找文件、统计目录大小等场景。
深度优先遍历完整思路
- 递归式遍历：优先进入子目录，完成当前目录所有子目录的遍历后再返回上一层。
- 适合处理嵌套结构：目录树是一个递归结构，深度优先遍历特别适用于这种嵌套结构。
- 有序性：
- 由上至下：先访问父目录，再依次深入子目录。
- 从左至右：每层目录按照特定顺序（如字母顺序）排列。
代码详情具体实现深度优先遍历目录的过程（通过代码的编程思路直观的理解深度优先的编程思路）
在 C语言 中，可以使用 dirent.h 提供的函数（如 opendir() 和 readdir()）来遍历目录。同时可以使用递归来实现深度优先遍历。
#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <sys/stat.h>
#include <string.h>
// 深度优先遍历目录
void dfs_directory(const char *path, int depth) {
DIR *dir = opendir(path);
if (dir == NULL) {
perror("opendir");
return;
}
struct dirent *entry;
while ((entry = readdir(dir)) != NULL) {
// 跳过当前目录和父目录
if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) {
continue;
}
// 构造完整路径
char full_path[1024];
snprintf(full_path, sizeof(full_path), "%s/%s", path, entry->d_name);
// 判断是否为目录
struct stat st;
if (stat(full_path, &st) == 0 && S_ISDIR(st.st_mode)) {
// 打印目录并递归进入
printf("%*s[DIR] %s\n", depth * 2, "", full_path);
dfs_directory(full_path, depth + 1);
} else {
// 打印文件
printf("%*s[FILE] %s\n", depth * 2, "", entry->d_name);
}
}
closedir(dir);
}
int main(int argc, char *argv[]) {
const char *start_path = argc > 1 ? argv[1] : ".";
dfs_directory(start_path, 0);
return 0;
}
再使用 Python 实现，因为 python 轻量级语言，实现过程更为简洁：
Python 的标准库 os 和 os.path 提供了文件和目录操作的相关工具，可以轻松实现深度优先遍历目录。
代码逻辑（递归实现）：
import os
def dfs_directory(path, depth=0):
# 打印当前目录
print(" " * depth + f"[DIR] {path}")
# 遍历当前目录的所有文件和子目录
for entry in os.listdir(path):
full_path = os.path.join(path, entry)
# 如果是目录，则递归遍历
if os.path.isdir(full_path):
dfs_directory(full_path, depth + 1)
else:
# 如果是文件，则打印文件路径
print(" " * (depth + 1) + f"[FILE] {entry}")
# 调用函数
start_path = "./test_directory" # 替换为需要遍历的目录
dfs_directory(start_path)
我们先假设目录结构如下：
test_directory/
├── file1.txt
├── subdir1/
│ ├── file2.txt
│ └── file3.txt
└── subdir2/
└── subsubdir/
└── file4.txt
输出：
[DIR] ./test_directory
[FILE] file1.txt
[DIR] ./test_directory/subdir1
[FILE] file2.txt
[FILE] file3.txt
[DIR] ./test_directory/subdir2
[DIR] ./test_directory/subdir2/subsubdir
[FILE] file4.txt
另一种实现方式：栈实现（非递归）：
深度优先遍历也可以通过栈来实现，避免递归调用的栈深度限制。
import os
def dfs_directory_stack(path):
# 使用栈实现深度优先遍历
stack = [path]
while stack:
current_path = stack.pop()
if os.path.isdir(current_path):
print(f"[DIR] {current_path}")
# 将当前目录的内容加入栈
for entry in sorted(os.listdir(current_path), reverse=True):
stack.append(os.path.join(current_path, entry))
else:
print(f"[FILE] {current_path}")
# 调用函数
start_path = "./test_directory" # 替换为需要遍历的目录
dfs_directory_stack(start_path)
也可以直接使用 Shell 实现，不用写代码，Shell 脚本中可以使用 find 命令来实现深度优先遍历：
find ./test_directory
输出：
./test_directory
./test_directory/file1.txt
./test_directory/subdir1
./test_directory/subdir1/file2.txt
./test_directory/subdir1/file3.txt
./test_directory/subdir2
./test_directory/subdir2/subsubdir
./test_directory/subdir2/subsubdir/file4.txt
深度优先遍历的应用场景
- 文件搜索：
- 在复杂的目录树中查找特定文件或文件类型。
- 示例：查找所有
.txt文件：
import os
def find_txt_files(path):
for root, dirs, files in os.walk(path):
for file in files:
if file.endswith(".txt"):
print(os.path.join(root, file))
find_txt_files("./test_directory")
- 目录大小统计：
- 统计目录及其子目录的总大小。
- 示例代码：
import os
def calculate_directory_size(path):
total_size = 0
for root, dirs, files in os.walk(path):
for file in files:
file_path = os.path.join(root, file)
total_size += os.path.getsize(file_path)
return total_size
print(f"Total size: {calculate_directory_size('./test_directory')} bytes")
- 备份工具：遍历目录树并复制文件到备份位置。
- 文件清理：删除某些特定类型的文件或空文件夹。
- 目录树展示：以树状结构展示目录层级。
使用深度优先遍历具有诸多好处：递归实现方式与目录树结构天然契合，代码思路简单直观；适合嵌套结构，能深入到子目录，适合操作深层嵌套的目录；占用资源少：在处理大目录时，深度优先遍历通常比广度优先遍历占用内存更少。不过，在应用过程中也需要注意一些可能会出现的问题：① 可能导致栈溢出：如果目录嵌套过深，递归实现可能导致栈溢出。② 目录顺序不固定：由于深度优先的遍历顺序，无法保证目录按字母顺序排列。
深度优先遍历目录是一种高效、灵活的目录操作方法，尤其适用于嵌套结构的文件系统。通过递归或栈实现深度优先遍历，可以方便地完成文件搜索、目录统计等任务。我们以上提供了三种不同的实现方式（但代码思路是一致的），综上。希望该内容能对你有帮助，感谢您的阅读！
以上。仅供学习与分享交流，请勿用于商业用途！转载需提前说明。
我是一个十分热爱技术的程序员，希望这篇文章能够对您有帮助，也希望认识更多热爱程序开发的小伙伴。
感谢！