C++实现DFS显示ubuntu指定目录下所有的文件，请老师指点。
#include <dirent.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <iostream>
#include <regex>
#include <stack>
using namespace std;

class FileSearch {
  private:
  stack<string> path; // 路径栈

  public:
  /**
   * Detail: DFS显示ubuntu指定目录下文件
   * basePath- 文件路径
   * return: null
   */
  void DfsFile(char *basePath) {
    DIR *dir;
    struct dirent *ptr;
    char base[1000];
    char temp[1000];
    // 路径入栈
    path.push(basePath);
    // 遍历开始
    while (!path.empty()) {
      // 打开当前目录
      strcpy(temp, path.top().c_str());
      path.pop();
      cout << "Current path: " << temp << endl;
      if ((dir = opendir(temp)) == NULL) {
        perror("Open dir error, please input the right path");
        exit(1);
      }
      // 显示当前路径下的文件
      while ((ptr = readdir(dir)) != NULL) {
        // 忽略隐藏文件和路径: .and..
        if (regex_match(ptr->d_name, regex("\\.(.*)"))) {
          continue;
        }
        if (ptr->d_type == 8) {
          // A regular file
          //cout << "file: " << basePath << "/" << ptr->d_name << endl;
          cout << ptr->d_name << endl;
        } else if (ptr->d_type == 4) {
          // 检测为文件夹
          memset(base, '\0', sizeof(base));
          strcpy(base, temp);
          strcat(base, "/");
          strcat(base, ptr->d_name);
          path.push(base);
          continue;
        }
      }
    }
    // 关闭文件
    closedir(dir);
  }
};
int main(void) {
  FileSearch test;
  // 需要遍历的文件夹目录
  char basePath[] = {"/home/joe/Desktop/leetcode"};
  test.DfsFile(basePath);
  return 0;
}
// 大致输出结果为：
Current path: /home/joe/Desktop/leetcode
leetcodePractice.cpp
a.out
README.md
Current path: /home/joe/Desktop/leetcode/math_fundamental_algorithms
recursion.cpp
tree_depth_first_search.cpp
recursion_integer.cpp
permutation.cpp
dynamic_programming.md
iteration_way.cpp
tree_breadth_first_search.md
a.out
tree_breadth_first_search.cpp
math_induction.cpp
byte_operation.cpp
......

自己代码功力不行，尽力写一个python版本的

class Node:
    def __init__(self, number):
        self.num = number
        self.nodes = []

    def setNode(self, num):
        if(self.nodes.__contains__(num) == False):
            node = Node(num)
            self.nodes.append(node)
            return node
        else:
            return None

    def setNodeUnder(self, num, base):
        if (self.num == num):
            return self.setNode(num)

        baseNode = self.get(base, self.nodes)
        if baseNode == None:
            return None
        else:
            return baseNode.setNode(num)

    def get(self, num, nodes=None):
        if(self.nodes == None or len(nodes) == 0):
            return None
        else:
            someNodes = []
            for node in nodes:
                if node.num == num:
                    return node
                for n in node.nodes:
                    someNodes.append(n)
            return self.get(num, someNodes)
    
    def search(self):
        print(self.num)
        self.printNodes(self.nodes)

    def printNodes(self, nodes=None):
        if nodes == None or len(nodes) == 0:
            return
        else:
            someNodes = []
            for node in nodes:
                print(node.num)
                for n in node.nodes:
                    someNodes.append(n)
            return self.printNodes(someNodes)

root = Node(110)
root.setNode(123)
root.setNode(879)
root.setNode(945)
root.setNode(131)
root.setNodeUnder(162, 123)
root.setNodeUnder(587, 123)
root.setNodeUnder(580, 945)
root.setNodeUnder(762, 945)
root.setNodeUnder(906, 131)
root.setNodeUnder(681, 587)

root.search()

output:
110
123
879
945
131
162
587
580
762
906
681
finish...

简单用Python写了一个程序：
# 用深搜和广搜列出目录
import os

# 深搜列目录
def dls(path,level):
#BEGIN

    for file in os.listdir(path):

        # 如果是子目录，则递归访问该子目录
        if os.path.isdir(file):
            print('-' * level * 2, '子目录：{}'.format(file))
            dls(path + '/' + file, level + 1)
        else:
            print('-' * level * 2, '文件名：{}'.format(file), '-'*10)
#END


# 广搜列目录
def bls(path):
#BEGIN
    level = 0

    #创建并初始化队列
    queue = []
    queue.append((path,level))


    # 队列不空时，取出队列中的元素进行遍历
    while len(queue) > 0:
        subpath = queue[0][0]
        level = queue[0][1]
        queue.remove(subpath)

        print('-' * level * 2, '{}下的所有文件：'.format(subpath), '-' * level * 2)

        for file in os.listdir(subpath):

            # 如果是子目录仍然进队列
            if os.path.isdir(file):
                print(' ' * (level + 1) * 2, '子目录：{}'.format(file))
                queue.append((subpath + '/' + file, level + 1))
            else:
                print(' ' * (level + 1) * 2, '文件名：{}'.format(file))
#END

# 主程序
def main():
#BEGIN
    print('深度优先搜索目录：C:\')
    dls('c:/', 1)
    print('广度优先搜索目录：C:\')
    bls('c:/')
#END


if __name__ == '__main__':
    main()

package package13;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;

public class File {
    public String name;
    public HashSet<File> children;
    public String parent;
    
    public String getPath() {
        if (name == null)
            return null;
        if (parent == null) {
            return this.name;
        }
        return this.parent.concat("/").concat(this.name);
    }
    
    public File(String name, String parent) {
        this.name = name;
        this.parent = parent;
        this.children = new HashSet<File>();
    }
    
    public static void addFile(File file, String path) {
        String[] arr = path.split("/");
        boolean exist = false;
        File newFile = null;
        for (File files : file.children) {
            if (files.name.equals(arr[0])) {
                exist = true;
                newFile = files;
            }
        }
        if (!exist) {
            newFile = new File(arr[0], file.getPath());
            file.children.add(newFile);
        }
        if (arr.length > 1) {
            addFile(newFile, path.substring(path.indexOf("/") + 1));
        }
    }
    
    public static void guangdu(File file) {
        Queue<File> queue = new LinkedList<File>();
        queue.offer(file);
        while(!queue.isEmpty()) {
            File iterator = queue.poll();
            System.out.println(iterator.getPath());
            for (File child : iterator.children) {
                queue.offer(child);
            }
        }
    }
    
    public static void shendu(File file) {
        Stack<File> stack = new Stack<File>();
        stack.push(file);
        while(!stack.isEmpty()) {
            File iterator = stack.pop();
            System.out.println(iterator.getPath());
            for (File child : iterator.children) {
                stack.push(child);
            }
        }
    }
    
    public static void main(String[] args) {
        File file = new File(null, null);
        addFile(file, "d:/a/b/c");
        addFile(file, "d:/a/b/c");
        addFile(file, "d:/a/b/d");
        addFile(file, "d:/a/b2/d");
        addFile(file, "d:/a/b3/d");
        addFile(file, "d:/b/b3/d");
//        shendu(file);
        guangdu(file);
    }
}

我好好检查了一下我的代码逻辑，您的逻辑是正确的。

我这边visited集合没有把user_id加入，导致的问题。

控制台的输出日志。我查询的是user_id是 0， 而控制台打印了一行记录是 2度好友:0 。 出现这个打印的原因是遍历0的好友。该好友的friends包含了0，在for循环中算了user_id=0的情况。

谢谢老师指正！

广度优先搜索那块有2个小瑕疵，您看一下。
1. 防止数组越界的异常，user_id 等于数组长度也会越界。
2.遍历子节点的时候，如果子节点friends中存在需要查询的user_id,则出现错误的打印输出。如果是查询的user_id应该continue。

控制台打印
0:[3]:0
1:[3]:0
2:[3]:0
3:[0, 1, 2, 4]:0
4:[3]:0
    1 度好友:3
    2 度好友:0
    2 度好友:1
    2 度好友:2
    2 度好友:4

代码如下，
    public static Node[] init(int user_num, int relation_num) {
        Random rand = new Random();

        Node[] user_nodes = new Node[user_num];

        // 生成所有表示用户的节点
        for (int i = 0; i < user_num; i++) {
            user_nodes[i] = new Node(i);
        }

        // 生成所有表示好友关系的边
        for (int i = 0; i < relation_num; i++) {
            int friend_a_id = rand.nextInt(user_num);
            int friend_b_id = rand.nextInt(user_num);
            if (friend_a_id == friend_b_id)
                continue;
            Node friend_a = user_nodes[friend_a_id];
            Node friend_b = user_nodes[friend_b_id];
            friend_a.friends.add(friend_b_id);
            friend_b.friends.add(friend_a_id);
        }

        return user_nodes;
    }

    public static void bfs(Node[] user_nodes, int user_id) {
        // 防止数组越界异常
        if (user_id >= user_nodes.length)
            return;

        // 用于广度优先搜索的队列
        Queue<Integer> queue = new LinkedList<>();

        // 放入初始节点
        queue.offer(user_id);

        // 存放已经被访问过的节点，防止回路
        HashSet<Integer> visited = new HashSet<>();

        while (!queue.isEmpty()) {
            // 取出队列头部的第一个节点
            int current_user_id = queue.poll();
            if (user_nodes[current_user_id] == null)
                continue;

            // 遍历刚刚拿到的这个节点的所有直接连接节点，并加入队列尾部
            for (int friend_id : user_nodes[current_user_id].friends) {
                if (user_nodes[current_user_id] == null)
                    continue;
                if (visited.contains(friend_id))
                    continue;
                queue.offer(friend_id);
                // 记录已经访问过的节点
                visited.add(friend_id);
                // 好友度数是当前节点的好友度数再加1
                user_nodes[friend_id].degree = user_nodes[current_user_id].degree + 1;
                System.out.println(String.format("\t%d 度好友:%d", user_nodes[friend_id].degree, friend_id));
            }
        }
    }

    public static void main(String[] args) {
        Node[] user_nodes = init(5, 8);
        for (Node d : user_nodes) {
            System.out.println(d.user_id + ":" + d.friends + ":" + d.degree);
        }
        bfs(user_nodes, 0);
    }

使用C++的双端队列deque实现的BFS和DFS
namespace FilePathOperator {
    struct St_FilePathNode;
    typedef std::set<St_FilePathNode*> SetterFilePathNode;
    typedef void(*FilPathOperator)(const St_FilePathNode& rStFilePathNode);
    typedef struct St_FilePathNode {
        int m_nLevel;
        std::string m_strFilePath;
        SetterFilePathNode m_setChildernPathNodes;
    }StFilePathNode;
};
void FilePathOperator::BFSFilePathNodes(StFilePathNode * pRoot, FilPathOperator nodeOperator, int nMaxLevel)
{
    if (NULL == pRoot)
        return;

    std::deque<StFilePathNode*> queNode;
    queNode.push_front(pRoot);

    pRoot->m_nLevel = 0;    // Root Level is first one

    while (!queNode.empty())
    {
        StFilePathNode* pNode = queNode.back();
        queNode.pop_back();
        if (NULL == pNode) continue;
    
        int nNodeLevel = pNode->m_nLevel;
        nodeOperator(*pNode);

        if (nNodeLevel + 1 > nMaxLevel)    continue; // childern beyond MaxLevel

        SetterFilePathNode::iterator ChildItr = pNode->m_setChildernPathNodes.begin();
        for (; ChildItr != pNode->m_setChildernPathNodes.end(); ChildItr++） {
            if (NULL == *ChildItr)
                continue;

            (*ChildItr)->m_nLevel = nNodeLevel + 1;
            queNode.push_front(*ChildItr);
        }
    }
}
void FilePathOperator::DFSFilePathNodes(StFilePathNode * pRoot, FilPathOperator nodeOperator, int nMaxLevel)
{
    if (NULL == pRoot)
        return;

    std::deque<StFilePathNode*> deqNode;
    deqNode.push_front(pRoot);

    pRoot->m_nLevel = 0;    // Root Level is first one

    while (!deqNode.empty())
    {
        StFilePathNode* pNode = deqNode.front();
        deqNode.pop_front();
        if (NULL == pNode) continue;

        int nNodeLevel = pNode->m_nLevel;
        nodeOperator(*pNode);

        if (nNodeLevel + 1 > nMaxLevel)    continue; // childern beyond MaxLevel

        SetterFilePathNode::iterator ChildItr = pNode->m_setChildernPathNodes.cbegin();
        for (; ChildItr != pNode->m_setChildernPathNodes.cend(); ChildItr++) {
            if (NULL == *ChildItr)
                continue;

            (*ChildItr)->m_nLevel = nNodeLevel + 1;
            deqNode.push_front(*ChildItr);
        }
    }
}
（其他的Create、Destroy、Print就暂时不贴出来了）