返回深度最深的条目中，最长路径的长度

题目

路径都由字母、数字或空格组成，给定一个以上述代码格式表示目录的字符串input，返回深度最深的条目中，最长路径的长度。

示例 1：

输入：input = "Title\n\tSubtitle1\n\tSubtitle2\n\t\taaaa"

输出：20

解释：aaaa 路径为 "Title/Subtitle2/aaaa"，深度是 3，路径长度 20

示例 2：

输入：input = "Title\n\tSubtitle1\n\t\taaa\n\t\tSubsubtitle1\n\t\t\tbbbb\n\tSubtitle2\n\t\tSubsubtitle2\n\t\t\tcccccc"

输出：35

解释：深度为 4 存在两个路径：

"Title/Subtitle1/Subsubtitle1/bbbb" ，长度33

"Title/Subtitle2/Subsubtitle2/cccccc" ，长度35，长度最长。

解析

1. 先按照 \n 划分字符串 s.split("\n");

2. 解析字符串中有几个 \t （tabCount），判断其在几级目录；

   2.1 若后一个字符串的 tabCount大于前一个 tabCount，则添加到链表中

   2.2 否则将链表中的数据加入到中间数据的链表，然后从 0 到 tabCount 截取链表

3. 若到最后一个字符串，其后一个字符串的 tabCount仍大于前一个 tabCount。则将其添加到链表并加入到中间链表。

4. 从中间链表遍历中取出最大深度的链表，并输出最大路径的长度。

代码实现

import java.util.*;

/**
 * @author 江七
 * @version 1.0
 * @date 2021/9/12 22:30
 */
public class ReturnPath {
    public static void main(String[] args) {
        String path = "Title\n\tSubtitle1\n\t\taaa\n\t\tSubsubtitle1\n\t\t\tbbbb\n\tSubtitle2\n\t\tSubsubtitle2\n\t\t\tcccccc";
        List<String> arrayList = getAllList(path);//中间数据集合
        int resultlist = getMaxList(arrayList);//最长深度
        System.out.println("返会最大深度中的最长路径的长度为:" + resultlist);
    }

    /**
     * 获取最大深度的最长路径长度
     *
     * @param arrayList
     */
    private static int getMaxList(List<String> arrayList) {
        int maxLength = arrayList.get(0).length();
        int m = 0;
        System.out.println(maxLength);
        for (int i = 1; i < arrayList.size(); i++) {
            int temp = arrayList.get(i).length();
            if (maxLength < temp) {
                maxLength = temp;
                m = i;
            }
        }
        System.out.println("返会最大深度中的最长路径:" + maxLength);
        System.out.println("输出最长路径名字:" + arrayList.get(m));
        return maxLength;
    }
    /**
     * 获取所有路径的集合
     * @param s
     * @return
     */
    public static List<String> getAllList(String s) {
        String[] strings = s.split("\n");
        List<String> arrayList = new ArrayList<>();//存放中间数据
        List<String> list = new LinkedList();//
        list.add(strings[0]);//字符串第一个为一级目录，不用考虑

        int tabCount = 0;// \t数量初始化为0
        for (int i = 1; i < strings.length; i++) {
            int count = tabCount(strings[i]);
            if (count > tabCount) {
                list.add(strings[i].trim());
                tabCount = count;
                if (i == strings.length - 1) {
                    arrayList.add(String.join("/", list));//将list中的数据以 / 分开
                    System.out.println("count > tabCount：" + list);
                }
            } else {
                arrayList.add(String.join("/", list));//将list中的数据以 / 分开
                System.out.println("count <= tabCount：" + list);
                tabCount = count;
                list = list.subList(0, tabCount);//生成最新列表
                System.out.println("生成最新的列表：" + list);
                list.add(strings[i].trim());//添加数据
            }
        }
        return arrayList;
    }

    /**
     * 返回 \t的数量
     *
     * @param s
     * @return
     */
    public static int tabCount(String s) {
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '\t') {
                count++;
            }
        }
        return count;
    }
}

结果：

注意：

一开始 存放中间链表是采用的是 List<List>的形式，但是在 arrayList.add(list))中 出现问题，即遍历到最后时， arrayList前几个数据出现错误，原因应该是 list 都是指向同一个地址，当后面的list数据进行添加时，前面添加到 arrayList 的数据也跟着变化。感兴趣的可以跟着测试下

原始代码如下：

 public static  List<List> getAllList(String s) {
        String[] strings = s.split("\n");
        List<List> arrayList = new ArrayList<>();//存放中间数据
        List<String> list = new LinkedList();//
        list.add(strings[0]);//字符串第一个为一级目录，不用考虑

        int tabCount = 0;// \t数量初始化为0
        for (int i = 1; i < strings.length; i++) {
            int count = tabCount(strings[i]);
            if (count > tabCount) {
                list.add(strings[i].trim());
                tabCount = count;
                if (i == strings.length - 1) {
                    arrayList.add(list);
                    System.out.println("count > tabCount：" + list);
                }
            } else {
                arrayList.add(list);//结束上个列表
                System.out.println("count <= tabCount：" + list);
                tabCount = count;
                list = list.subList(0, tabCount);//生成最新列表
                System.out.println("生成最新的列表：" + list);
                list.add(strings[i].trim());//添加数据
            }
        }
        return arrayList;
    }

测试该函数代码如下：

public static void main(String[] args) {
        String path = "Title\n\tSubtitle1\n\t\taaa\n\t\tSubsubtitle1\n\t\t\tbbbb\n\tSubtitle2\n\t\tSubsubtitle2\n\t\t\tcccccc";
        List<List> arrayList=getAllList1(path);
        System.out.println("遍历：");
        for (List l:arrayList) {
            System.out.println(l);
        }
 }

测试结果：