面试经典 150 题 2 —（栈）— 71. 简化路径

71. 简化路径

方法

class Solution {
public:
    string simplifyPath(string path) {
        // 划分字符串，使用Lambda表达式
        // []中可以放上下文中定义的参数，(const string& s, char delim)就是参数，vector<string>是返回值，后边就是函数体
        auto split = [](const string& s, char delim) -> vector<string> {
            vector<string> ans;
            string cur;
            for(char ch : s){
                if(ch == delim){
                    ans.push_back(move(cur));
                    cur.clear();
                }
                else{
                    cur += ch;
                }
            }
            // move(obj)函数的功能是把obj当做右值处理，可以应用在对象的移动上。
            ans.push_back(move(cur));
            return ans;
        };
        // 把原路径path根据/进行划分
        vector<string> names = split(path, '/');
        // 用一个栈来维护路径中的每一个目录名
        vector<string> stack;
        for(string name : names){
            // 如果是".."，就出栈，相当于返回上一级目录
            if(name == ".."){
                if(!stack.empty()){
                    stack.pop_back();
                }
            }
            // 多个连续的 "//"会分割出空字符串,空字符串可以不做处理 ；"."的话相当于目录本身，可以不做处理；
            else if(!name.empty() && name != "."){
                stack.push_back(move(name));
            }
        }

        string ans;
        // 如果栈是空的。相当于处理完了之后什么也没有，也要记得返回"/"
        if(stack.empty()){
            ans = "/";
        }
        else{
            // 从栈底到栈顶的字符串用 "//" 进行连接
            for(string name : stack){
                ans += "/" + move(name);
            }
        }

        return ans;

    }
};

class Solution {
public:
    string simplifyPath(string path) {
        // 划分字符串，使用Lambda表达式
        // []中可以放上下文中定义的参数，(const string& s, char delim)就是参数，vector<string>是返回值，后边就是函数体
        auto split = [](const string& s, char delim) -> vector<string> {
            vector<string> ans;
            string cur;
            for(char ch : s){
                if(ch == delim){
                    ans.push_back(cur);
                    cur.clear();
                }
                else{
                    cur += ch;
                }
            }
            // move(obj)函数的功能是把obj当做右值处理，可以应用在对象的移动上。
            ans.push_back(cur);
            return ans;
        };
        // 把原路径path根据/进行划分
        vector<string> names = split(path, '/');
        // 用一个栈来维护路径中的每一个目录名
        vector<string> stack;
        for(string name : names){
            // 如果是".."，就出栈，相当于返回上一级目录
            if(name == ".."){
                if(!stack.empty()){
                    stack.pop_back();
                }
            }
            // 多个连续的 "//"会分割出空字符串,空字符串可以不做处理 ；"."的话相当于目录本身，可以不做处理；
            else if(!name.empty() && name != "."){
                stack.push_back(name);
            }
        }

        string ans;
        // 如果栈是空的。相当于处理完了之后什么也没有，也要记得返回"/"
        if(stack.empty()){
            ans = "/";
        }
        else{
            // 从栈底到栈顶的字符串用 "//" 进行连接
            for(string name : stack){
                ans += "/" + name;
            }
        }

        return ans;

    }
};

class Solution {
public:
    string simplifyPath(string path) {
        // 划分字符串，使用Lambda表达式
        // []中可以放上下文中定义的参数，(const string& s, char delim)就是参数，vector<string>是返回值，后边就是函数体
        auto split = [](const string& s, char delim) -> vector<string> {
            vector<string> ans;
            string cur;
            for(char ch : s){
                if(ch == delim){
                    ans.push_back(cur);
                    cur.clear();
                }
                else{
                    cur += ch;
                }
            }
            // move(obj)函数的功能是把obj当做右值处理，可以应用在对象的移动上。
            ans.push_back(cur);
            return ans;
        };
        // 把原路径path根据/进行划分
        vector<string> names = split(path, '/');
        deque<string> dq;
        for(string name : names){
            // 如果是".."，就出栈，相当于返回上一级目录
            if(name == ".." && !dq.empty()){
                dq.pop_back();
            }
            // 多个连续的 "//"会分割出空字符串,空字符串可以不做处理 ；"."的话相当于目录本身，可以不做处理；
            else if(name != ".." && name != "" && name != "."){
                dq.push_back(name);
            }
        }

        string ans;
        // 如果栈是空的。相当于处理完了之后什么也没有，也要记得返回"/"
        if(dq.empty()){
            ans = "/";
        }
        else{
            // 从栈底到栈顶的字符串用 "//" 进行连接
            for(deque<string>::const_iterator it = dq.begin(); it != dq.end();it++){
                ans += "/" + *it;
            }
        }

        return ans;

    }
};
作者：力扣官方题解
链接：https://leetcode.cn/problems/simplify-path/solutions/1193258/jian-hua-lu-jing-by-leetcode-solution-aucq/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

方法

class Solution {
public:
    string simplifyPath(string path) {
        stringstream is(path);
        vector<string> strs;
        string res = "", tmp = "";
        // 以"/"进行划分，每次将划分的中间结果放到tmp中
        while(getline(is, tmp, '/')) {
            // 多个连续的 "//"会分割出空字符串,空字符串可以不做处理 ；"."的话相当于目录本身，可以不做处理；
            if(tmp == "" || tmp == "."){
                continue;
            }  
            // 如果是".."，就出栈，相当于返回上一级目录
            else if(tmp == ".." && !strs.empty()){
                strs.pop_back();
            }
                
            else if(tmp != ".."){
                strs.push_back(tmp);
            }
                
        }
        for(string str:strs){
            res +=  "/" + str;
        } 
            
        if(res.empty()){
            return "/";
        }
            
        return res;
    }
};
作者：lioney
链接：https://leetcode.cn/problems/simplify-path/solutions/46064/cli-yong-stringstreamhe-getlinefen-ge-zi-fu-chuan-/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。