[力扣c语言实现]71. 简化路径

1. 题目描述

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

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

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

示例 1：

输入：“/home/”
输出：“/home”
解释：注意，最后一个目录名后面没有斜杠。
示例 2：

输入：“/…/”
输出：“/”
解释：从根目录向上一级是不可行的，因为根是你可以到达的最高级。
示例 3：

输入：“/home//foo/”
输出：“/home/foo”
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。
示例 4：

输入：“/a/./b/…/…/c/”
输出：“/c”
示例 5：

输入：“/a/…/…/b/…/c//.//”
输出：“/c”
示例 6：

输入：“/a//bc/d//././/…”
输出：“/a/b/c”

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

2.解决过程和我刷力扣的原因

1.写这道题我也是无语了，一开始按照读题后最直接的思路就写，写出来一运行，就有通不过的case,于是就转战到vs下边调试边提交，于是就一个case一个case地调，这个时候已经变成了面向case编程了，最终缝缝补补还是提交通过了，所以代码很长-_-!
2.我刷力扣的很大原因是因为学习编程的时候基本就是照着书抄，很少逼自己空手写代码，动手能力弱鸡。考研阶段学习了数据结构，当时是为了考试，数据结构和常用算法概念很清楚，题目也会算，但是连链表都不会写，现在工作了，就趁着理论扎实把这些基本数据结构，借由力扣这个平台，亲自实现一遍！所以我写力扣，我就是亲自写，手旁一个笔记本，脑袋模拟不出来就画一下，我给自己的要求就是，你一定要亲自写，千万别看别人怎么写，这种东西，思路很简单，一看就能看懂，随之而来的就是一看就懂，再写绝逼还是写不出来，所以我刷力扣，我要逼自己真的写不来，才看看别人的思路（思路，而不是代码），然后又得到正确的思路，再来自己亲手实现！总之一句话，亲手实现，而不是照着别人的代码抄
3.在我刷满100个题（前100个题，我的目的是为了能亲自动手，用c语言实现所有的数据结构+初级排序+查找这些题）之前，我不考虑不关心题目要求的时间和空间复杂度，刷满100题后，后续再考虑其他的时间空间效率。

3.代码如下

1. c

//2018-12-27
//2018-12-28   "/EQnvK///U/./../LQnJc/./rI/Ckzz/lmO/./"
//2018-12-29   "/...",    "/.",   "/.."
char* simplifyPath(char* path) {
    typedef struct stack
    {
        char character[1000];
        int top;
    }stack;
    char *newpath;
    int i = 0;
    int dotcount = 0;
    stack *s1 = (stack *)malloc(sizeof(stack));
    memset(s1,0,sizeof(stack));
    if(path[0]=='\0')
    {
        return NULL;
    }
    while(path[i]!='\0')
    {
        switch(path[i])
        {
            case '/':
                if(dotcount==1&&s1->character[s1->top-1]=='.')
               {
                   dotcount = 0;
                   s1->top-=1;
                   if(s1->character[s1->top-1]!='/')
                   {
                       s1->character[s1->top]=path[i];
                       s1->top++;
                       i++;
                       break;
                   }
                   else
                   {
                       i++;
                       break;
                   }
               }
               else if(dotcount==2&&s1->character[s1->top-1]=='.')
               {    
                  
                    dotcount = 0;
                    s1->top-=2;
                   
                    
                    if(s1->top==1&&s1->character[s1->top-1]=='/')
                    {
                       i++;
                       break;
                    }
                    s1->top-=1;
                    while(s1->top>0&&s1->character[s1->top-1]!='/')
                    {
                        s1->top--;
                    }
                    if(s1->character[s1->top-1]!='/')
                    {
                       s1->character[s1->top]=path[i];
                       s1->top++;
                       i++;
                       break;
                    }
                    else
                    {
                       i++;
                       break;
                    }
               }
               else
               {
                   if(s1->top>0)
                   {
                        if(s1->character[s1->top-1]=='/')
                        {
                            i++;
                            break;
                        }
                   }
                    s1->character[s1->top]=path[i];
                    s1->top++;
                    i++;
                    break;
               }
            case '.':
                dotcount++;
                //i++;顺序错误
                s1->character[s1->top]=path[i];
                i++;
                s1->top++;
                break;
            default:
                dotcount=0;
                s1->character[s1->top]=path[i];
                s1->top++;
                i++;
                break;
        }
    }
    
    if(s1->top>1)
    {
        if(dotcount==2&&s1->character[s1->top-1]=='.')
        {
            dotcount=0;
            s1->top-=2;
            if(s1->top>1&&s1->character[s1->top-1]=='/')
            {   
                s1->top-=1;
                while(s1->top>0&&s1->character[s1->top-1]!='/')
                {
                    s1->top--;
                }
            }
        }
        if(dotcount==1&&s1->character[s1->top-1]=='.')
        {    
            dotcount=0;
             s1->top-=1;
        }
        if(s1->top>1&&s1->character[s1->top-1]=='/')
        {
            s1->top--;
        }
        
        
    }
    newpath = (char *)malloc(sizeof(char)*(s1->top+20));//多分配字节留给结束符
    strncpy(newpath,s1->character,s1->top);//拷贝不带结束符的字符串
    newpath[s1->top]='\0';//手动添加结束符
    return newpath;
}

int main()
{
    char p[]="/EQnvK///U/./../LQnJc/./rI/Ckzz/lmO/./";//"/";
    char *path = simplifyPath(p);
    printf("%sthe length is %d\n",path,strlen(path));
    system("pause");
    return 0;
}

2. c++

//2022-12-28 
#include <iostream>
#include <stack>
#include <string>
#include <cassert>
#include <sstream>

class Solution {
public:
    std::string simplifyPath(std::string path) 
    {
        std::stack<std::string> pathStack;
        std::istringstream input(path);
        std::string tmp;
        while (getline(input,tmp,'/'))
        {
            if (!tmp.empty() && tmp != ".." && tmp != ".")
            {
                pathStack.push(tmp);
            }
            else if (tmp == ".." && !pathStack.empty())
            {
                pathStack.pop();
            }
        }
        std::string ret;
        while (!pathStack.empty())
        {
            ret.insert(0,pathStack.top());
            ret.insert(0,"/");
            pathStack.pop();
        }
        return ret == ""?"/":ret;
    }
};

int main(int argc,char **argv)
{
    assert((argc == 2));
    Solution slu;
    //std::string path = "/home/.../";
    std::string path = argv[1];
    auto simplifyPath = slu.simplifyPath(path);
    std::cout << simplifyPath << std::endl;
    return 0;
}