LeetCode 588. Design In-Memory File System

原题链接在这里：https://leetcode.com/problems/design-in-memory-file-system/

题目：

Design a data structure that simulates an in-memory file system.

Implement the FileSystem class:

• FileSystem() Initializes the object of the system.
• List<String> ls(String path)
  • If path is a file path, returns a list that only contains this file's name.
  • If path is a directory path, returns the list of file and directory names in this directory.
  The answer should in lexicographic order.
• void mkdir(String path) Makes a new directory according to the given path. The given directory path does not exist. If the middle directories in the path do not exist, you should create them as well.
• void addContentToFile(String filePath, String content)
  • If filePath does not exist, creates that file containing given content.
  • If filePath already exists, appends the given content to original content.
• String readContentFromFile(String filePath) Returns the content in the file at filePath.

Example 1:

Input
["FileSystem", "ls", "mkdir", "addContentToFile", "ls", "readContentFromFile"]
[[], ["/"], ["/a/b/c"], ["/a/b/c/d", "hello"], ["/"], ["/a/b/c/d"]]
Output
[null, [], null, null, ["a"], "hello"]

Explanation
FileSystem fileSystem = new FileSystem();
fileSystem.ls("/");                         // return []
fileSystem.mkdir("/a/b/c");
fileSystem.addContentToFile("/a/b/c/d", "hello");
fileSystem.ls("/");                         // return ["a"]
fileSystem.readContentFromFile("/a/b/c/d"); // return "hello"

Constraints:

• 1 <= path.length, filePath.length <= 100
• path and filePath are absolute paths which begin with '/' and do not end with '/' except that the path is just "/".
• You can assume that all directory names and file names only contain lowercase letters, and the same names will not exist in the same directory.
• You can assume that all operations will be passed valid parameters, and users will not attempt to retrieve file content or list a directory or file that does not exist.
• 1 <= content.length <= 50
• At most 300 calls will be made to ls, mkdir, addContentToFile, and readContentFromFile.

题解：

It is like Tire.

For each DirNode, it contains a map to children directories DirNode, and a map to children files StringBuilder.

ls has one corner case that when path is "/".  since "/".split("/") is empty array. arr[arr.length - 1] will have index out of bound exception.

Time Complexity: ls, O(m + klogk). m = path.length(). k is number of items in the res.

mkdir, O(m).

add, O(m).

readContentFromFile, O(m).

Space: O(n). size of DirNode tree.

AC Java:

class FileSystem {
    DirNode root;
    
    public FileSystem() {
        root = new DirNode();    
    }
    
    public List<String> ls(String path) {
        DirNode cur = root;
        List<String> res = new ArrayList<>();
        if(!path.equals("/")){
            String [] arr = path.split("/");
            for(int i = 1; i < arr.length - 1; i++){
                cur.dirs.putIfAbsent(arr[i], new DirNode());
                cur = cur.dirs.get(arr[i]);
            }
            
            if(cur.files.containsKey(arr[arr.length - 1])){
                res.add(arr[arr.length - 1]);
                return res;
            }
            
            cur.dirs.putIfAbsent(arr[arr.length - 1], new DirNode());
            cur = cur.dirs.get(arr[arr.length - 1]);
        }
        
        res.addAll(cur.dirs.keySet());
        res.addAll(cur.files.keySet());
        Collections.sort(res);
        return res;
    }
    
    public void mkdir(String path) {
        DirNode cur = root;
        String [] arr = path.split("/");
        for(int i = 1; i < arr.length; i++){
            cur.dirs.putIfAbsent(arr[i], new DirNode());
            cur = cur.dirs.get(arr[i]);
        }
    }
    
    public void addContentToFile(String filePath, String content) {
        DirNode cur = root;
        String [] arr = filePath.split("/");
        for(int i = 1; i < arr.length - 1; i++){
            cur.dirs.putIfAbsent(arr[i], new DirNode());
            cur = cur.dirs.get(arr[i]);
        }
        
        cur.files.putIfAbsent(arr[arr.length - 1], new StringBuilder());
        cur.files.get(arr[arr.length - 1]).append(content);
    }
    
    public String readContentFromFile(String filePath) {
        DirNode cur = root;
        String [] arr = filePath.split("/");
        for(int i = 1; i < arr.length - 1; i++){
            cur.dirs.putIfAbsent(arr[i], new DirNode());
            cur = cur.dirs.get(arr[i]);
        }
        
        return cur.files.get(arr[arr.length - 1]).toString();
    }
}

class DirNode{
    Map<String, DirNode> dirs = new HashMap<>();
    Map<String, StringBuilder> files = new HashMap<>();
}

/**
 * Your FileSystem object will be instantiated and called as such:
 * FileSystem obj = new FileSystem();
 * List<String> param_1 = obj.ls(path);
 * obj.mkdir(path);
 * obj.addContentToFile(filePath,content);
 * String param_4 = obj.readContentFromFile(filePath);
 */