简化路径

以 Unix 风格给出一个文件的绝对路径,你需要简化它。或者换句话说,将其转换为规范路径。

在 Unix 风格的文件系统中,一个点(.)表示当前目录本身;此外,两个点 (..) 表示将目录切换到上一级(指向父目录);两者都可以是复杂相对路径的组成部分。更多信息请参阅:Linux / Unix中的绝对路径 vs 相对路径

请注意,返回的规范路径必须始终以斜杠 / 开头,并且两个目录名之间必须只有一个斜杠 /。最后一个目录名(如果存在)不能以 / 结尾。此外,规范路径必须是表示绝对路径的最短字符串。

来源:力扣(LeetCode)
链接:https://leetcode-cn.com/problems/simplify-path
著作权归领扣网络所有。商业转载请联系官方授权,非商业转载请注明出处。

路径简化并不算复杂,规则无非就几点:

  1. 保留一个斜杠,即不得有连续的/出现
  2. /./表示本路径,可以 使用/表示
  3. /a/../..表示上一层路径
  4. 其他都不需要处理

明显,解决问题的时候,只需要按照这个规则描述即可,不难发现我们只需要处理/.的问题处理即可,那么很简单,只需要保证/前面没有/,而遇到点则处理。

不难发现,对于.来说,除了路径的最后,其前后都需要有/才生效,否则无任何效果。那么对于.的处理应该放在发现/的时候处理,而遇到.时,前面不是/则不予于理会。

不过我们需要一样东西来记录最终的答案,题目属于栈类的题目,我们可以使用栈来作为存储容器。

看代码:

class Solution {
public:
    string simplifyPath(string path) {
        string res;
        std::deque<char> deq;
        int dot_count{0};

        path += '/';

        for (size_t i{0}; i<path.size(); ++i) {
            char ch = path[i];
            switch (ch) {
                case '/':
                    if (0 != dot_count) {
                        if ('.' != path[i-1]) {
                            --i;
                            continue;
                        }

                        switch (dot_count) {
                            case 2: {
                                // 向前
                                int slash{0};
                                while (2 != slash && !deq.empty()) {
                                    if ('/' == *(deq.end() - 1)) {
                                        slash += 1;
                                    }
                                    deq.pop_back();
                                }
                                deq.push_back('/');
                                break;
                            }
                            case 1:
                                deq.pop_back();
                                break;
                            default:
                                break;
                        }
                        dot_count = 0;
                    }

                    if (!deq.empty() && '/' == *(deq.end() - 1)) {
                        deq.pop_back();
                    }
                    deq.push_back('/');
                    break;
                case '.':
                    if ('/' == *(deq.end() - 1)) {
                        deq.push_back('.');
                        dot_count = 1;
                        continue;
                    }
                    deq.push_back('.');
                    if (0 != dot_count) {
                        dot_count+=1;
                    }
                    break;
                default:
                    dot_count = 0;
                    deq.push_back(ch);
                    break;
            }
        }

        if (1 != deq.size() && '/' == *(deq.end()-1)) {
            deq.pop_back();
        }

        while (!deq.empty()) {
            res += *(deq.begin());
            deq.pop_front();
        }

        return res;
    }
};    

用例跑完8ms,还算可以,超77%

首先给原有的字符串添加了/在末尾,这是为了处理原字符串末尾没有/的情况,如果末尾是.,按照里面的代码的思路 会将末尾的.忽略掉,最简单的办法是照一个可以被处理的符号在末尾,/很适合。

还有其他的解法,可以尝试将字符串分割,分隔标识符为/,那么最终需要处理的是.,似乎更加简单。

不过现在停留在栈的学习中,对于对应标签的题目尝试使用纯粹的题目来解题。

查看了下golang里面filepath中的Clean函数:

func Clean(path string) string {
    originalPath := path
    volLen := volumeNameLen(path)
    path = path[volLen:]
    if path == "" {
        if volLen > 1 && originalPath[1] != ':' {
            // should be UNC
            return FromSlash(originalPath)
        }
        return originalPath + "."
    }
    rooted := os.IsPathSeparator(path[0])

    // Invariants:
    //    reading from path; r is index of next byte to process.
    //    writing to buf; w is index of next byte to write.
    //    dotdot is index in buf where .. must stop, either because
    //        it is the leading slash or it is a leading ../../.. prefix.
    n := len(path)
    out := lazybuf{path: path, volAndPath: originalPath, volLen: volLen}
    r, dotdot := 0, 0
    if rooted {
        out.append(Separator)
        r, dotdot = 1, 1
    }

    for r < n {
        switch {
        case os.IsPathSeparator(path[r]):
            // empty path element
            r++
        case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])):
            // . element
            r++
        case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])):
            // .. element: remove to last separator
            r += 2
            switch {
            case out.w > dotdot:
                // can backtrack
                out.w--
                for out.w > dotdot && !os.IsPathSeparator(out.index(out.w)) {
                    out.w--
                }
            case !rooted:
                // cannot backtrack, but not rooted, so append .. element.
                if out.w > 0 {
                    out.append(Separator)
                }
                out.append('.')
                out.append('.')
                dotdot = out.w
            }
        default:
            // real path element.
            // add slash if needed
            if rooted && out.w != 1 || !rooted && out.w != 0 {
                out.append(Separator)
            }
            // copy element
            for ; r < n && !os.IsPathSeparator(path[r]); r++ {
                out.append(path[r])
            }
        }
    }

    // Turn empty string into "."
    if out.w == 0 {
        out.append('.')
    }

    return FromSlash(out.string())
}

其主要重点也是在处理...,并不复杂,golang实现起来确实优雅。

Mark一个,可以仿照来做一个C++版本的。