字节跳动机试准备

引言

最近投了字节跳动的算法岗，突然给我发了机试通知，真是防不胜防，本来以为已经凉了。既然如此那就好好准备，这几天便将LeetCode上字节跳动专题中的题目好好刷一刷，刷的题目都是带有标记的，也就是这家公司最常考的题目。

专题1:挑战字符串

简化路径

• 通过时间：20min
• 解题思路：栈

题目描述

以 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//b////c/d//././/.."
输出："/a/b/c"

算法

粗看题目时并没有什么特别好的想法，看了几个样例后发现了一些端倪。核心思想：将两个斜杠之间出现的‘字符串’压栈，但是获取的子字符串不一定是合法的目录名，需要对获得的子字符串判断：

1. 若字符串为".."进行出栈操作
2. 若字符串为"."跳过
3. 若字符串为合法的目录名，则压栈
4. 当然，过程中多余的/要去掉

代码

1. canonical path.h

   //
   // Created by shayue on 2019-04-11.
   // 利用栈
   
   #ifndef EXPLORE_BYTEDANCE_CANONICAL_PATH_H
   #define EXPLORE_BYTEDANCE_CANONICAL_PATH_H
   
   #include <string>
   #include <iostream>
   #include <vector>
   using namespace std;
   
   class Solution {
   public:
       string simplifyPath(string path) {
           vector<string> myStack;
           string ret;
   
           // 1. 规范化处理（这步可能有些多余，输入的path应该本身就是合法的，所以不会出现第一个字符不是'/'的情况）
           if (path[0] != '/') 
               path = '/' + path;
   
           // 2. LOOP
           int len = path.size(), i = 0, j;
           while (i < len)
           {
               if (path[i] == '/')
               {
                   i++;
                   continue;
               }
               else
               {
                   string sub;
                   // 获取两个斜杠之间的子字符串
                   for (j = i; j < len && path[j] != '/'; j++)
                       sub += path[j];
                   // 更新i
                   i = j;
   
                   // 判断子字符串的意义
                   if (sub == ".")
                       continue;
                   else if (sub == "..")
                   {
                       if (!myStack.empty())
                           myStack.pop_back();
                   }
                   else
                       myStack.push_back(sub);
               }
           }
           // 3. return
           if (myStack.empty())
               return "/";
           else
           {
               for (i = 0; i < myStack.size(); i++)
               {
                   string adds = "/" + myStack[i];
                   ret += adds;
               }
               return ret;
           }
       }
   };
   
   #endif //EXPLORE_BYTEDANCE_CANONICAL_PATH_H
   

2. main.cpp

   #include <iostream>
   #include "Questions/canonical path.h"
   using namespace std;
   
   int main() {
       Solution s;
       string s1 = "/home/";
       string s2 = "/../";
       string s3 = "/home//foo/";
       string s4 = "/a/./b/../../c/";
       string s5 = "/a/../../b/../c//.//";
       string s6 = "/a//b////c/d//././/..";
   
       cout << s.simplifyPath(s1) << endl;
       cout << s.simplifyPath(s2) << endl;
       cout << s.simplifyPath(s3) << endl;
       cout << s.simplifyPath(s4) << endl;
       cout << s.simplifyPath(s5) << endl;
       cout << s.simplifyPath(s6) << endl;
   
       return 0;
   }

3. 结果