返回目录

题目描述

实现一个模拟目录管理功能的软件，输入一个命令序列，输出最后一条命令运行结果。

支持命令：

• 创建目录命令：mkdir 目录名称，如 mkdir abc 为在当前目录创建abc目录，如果已存在同名目录则不执行任何操作。此命令无输出。
• 进入目录命令：cd 目录名称，如 cd abc 为进入abc目录，特别地，cd … 为返回上级目录，如果目录不存在则不执行任何操作。此命令无输出。
• 查看当前所在路径命令：pwd，输出当前路径字符串。

约束：

• 目录名称仅支持小写字母；mkdir 和 cd 命令的参数仅支持单个目录，如：mkdir abc 和 cd abc；不支持嵌套路径和绝对路径，如 mkdir abc/efg，cd abc/efg，mkdir /abc/efg，cd /abc/efg 是不支持的。
• 目录符号为/，根目录/作为初始目录。
• 任何不符合上述定义的无效命令不做任何处理并且无输出。

输入描述

输入 N 行字符串，每一行字符串是一条命令。

命令行数限制100行以内，目录名称限制10个字符以内。

输出描述

输出最后一条命令运行结果字符串。

示例：

解题思路

1. 定义一个节点类（Node），用于表示文件系统中的每个目录。该类包含路径信息和一个映射，映射存储子目录和对应的节点对象。
2. 创建一个根节点实例，代表文件系统的根目录。根目录没有父目录。

3. 读取用户输入，根据输入的命令和参数执行相应的操作。

   • 如果输入的是创建目录的命令（例如，“mkdir”），检查目录名是否有效，然后在当前节点下创建新的子目录节点。
   • 如果输入的是切换目录的命令（例如，“cd”），检查目标目录是否存在，如果存在，则更新当前节点为目标节点。
   • 如果输入的是打印当前目录路径的命令（例如，“pwd”），则输出当前节点的路径信息。
4. 循环读取输入直到结束，并在结束时输出最后的路径信息。

Python算法源码

import re

# 定义一个类Node，用于表示文件系统中的每个目录
class Node:
    def __init__(self, path, parent=None):
        self.path = path  # 目录的路径
        self.next = {}  # 存储当前目录下的子目录，键为目录名，值为对应的Node对象
        if parent:
            self.next['..'] = parent  # 如果存在父目录，则在子目录映射中添加一个指向父目录的条目

# 检查目录名是否有效的函数，目录名只能包含小写字母
def is_valid_directory_name(name):
    return bool(re.match('^[a-z]+$', name))  # 如果目录名全部由小写字母组成，则返回True

# 检查是否可以切换到指定的目录的函数，目录名要么是有效的，要么是".."表示上级目录
def is_valid_change_directory(name):
    return name == '..' or is_valid_directory_name(name)  # 如果是".."或者是有效的目录名，则返回True

root = Node('/')  # 创建根目录节点，根目录没有父目录
current_node = root  # 初始化当前目录为根目录

# 逐行读取输入
while True:
    try:
        input_command = input().strip().split(' ')  # 将输入的命令按空格分割为命令和参数
        command = input_command[0]  # 获取命令部分

        if command == 'mkdir' and len(input_command) == 2 and is_valid_directory_name(input_command[1]):
            # 处理mkdir命令，用于创建新的子目录
            if input_command[1] not in current_node.next:
                current_node.next[input_command[1]] = Node(current_node.path + input_command[1] + '/', current_node)
        elif command == 'cd' and len(input_command) == 2 and is_valid_change_directory(input_command[1]):
            # 处理cd命令，用于改变当前目录
            next_node = current_node.next.get(input_command[1])
            if next_node:
                current_node = next_node  # 如果目录存在，则将当前目录切换为该目录
        elif command == 'pwd' and len(input_command) == 1:
            # 处理pwd命令，用于打印当前目录的路径
            print(current_node.path)  # 打印当前目录的路径
    except EOFError:
        break

Java算法源码

import java.util.HashMap;
import java.util.Scanner;

class TreeNode {
    String curDicName;
    TreeNode father;
    HashMap<String, TreeNode> children;

    TreeNode(String curDicName, TreeNode father) {
        this.curDicName = curDicName;
        this.father = father;
        this.children = new HashMap<>();
    }
}

class Tree {
    TreeNode root;
    TreeNode cur;

    Tree() {
        this.root = new TreeNode("/", null);
        this.cur = this.root;
    }

    void mkdir(String dicName) {
        if (!this.cur.children.containsKey(dicName)) {
            this.cur.children.put(dicName, new TreeNode(dicName + "/", this.cur));
        }
    }

    void cd(String dicName) {
        if (dicName.equals("..")) {
            if (this.cur.father != null) {
                this.cur = this.cur.father;
            }
        } else {
            TreeNode child = this.cur.children.get(dicName);
            if (child != null) {
                this.cur = child;
            }
        }
    }

    String pwd() {
        StringBuilder path = new StringBuilder();
        TreeNode temp = this.cur;

        while (temp != null) {
            path.insert(0, temp.curDicName);
            temp = temp.father;
        }

        return path.toString();
    }
}

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        Tree tree = new Tree();
        String lastCommandOutput = "";

        while (true) {
            try {
                String line = scanner.nextLine();

                if (line.isEmpty()) break;

                String[] tmp = line.split(" ");
                String cmdKey = tmp[0];

                if (cmdKey.equals("pwd")) {
                    if (tmp.length != 1) continue;
                    lastCommandOutput = tree.pwd();
                } else if (cmdKey.equals("mkdir") || cmdKey.equals("cd")) {
                    if (tmp.length != 2) continue;

                    String cmdVal = tmp[1];

                    if (!(cmdKey.equals("cd") && cmdVal.equals(".."))) {
                        for (char c : cmdVal.toCharArray()) {
                            if (c < 'a' || c > 'z') {
                                continue;
                            }
                        }
                    }

                    if (cmdKey.equals("mkdir")) {
                        tree.mkdir(cmdVal);
                        lastCommandOutput = "";
                    } else {
                        tree.cd(cmdVal);
                        lastCommandOutput = "";
                    }
                }
            } catch (Exception e) {
                break;
            }
        }

        System.out.println(lastCommandOutput);
    }
}