删除子文件夹[字典树 + go变量 + strings.builder的copyCheck()]

前言

对于类似字符串匹配相关的问题，用字典树可以大大提高效率；go的变量没有引用的概念，即使是一个结构体变量赋值给另一个变量，也是结构体全部内容的复制版；go为了并发安全，在变量复制（参数传递–隐式）时，会做copyCheck()检查addr指针变量是否指向自己，如果是复制过来的addr，就会发生panic。

一、删除子文件夹

二、字典树

1、idea

父子文件夹存在字符串匹配的关系，可用字典树存储，当碰到节点为尾节点时，就不用继续插入了；对于树遍历的时候，碰到尾节点就结束递归，就不需要后面的深层子目录了。
注：
bug1:child map[string]*TreeNode “<文件路径，文件节点>”，map的value使用*TreeNode，而不是TreeNode变量，否则遍历树时，新的root就是复制的内容，最后面的isEnd修改就白修改了。
bug2:由于go的no copy机制，strings.builder的方法会做copyCheck()检查，防止并发问题。由于传参是strings.builder类型，而不是其指针类型，此时就做了复制，当WriteString时，会先this.copyCheck()，如果addr发生了改变，就会发生panic。
addr初始时是nil状态，go的结构体没法赋值默认值，所以只要没调结构体方法，再赋值，都不会出现copyCheck()不通过的情况，毕竟addr == nil，各自初始化各自的addr，不会出错。而如果先掉方法再赋值，就会panic。
panic: strings: illegal use of non-zero Builder copied by value

2、go

package main

import (
	"fmt"
	"strings"
)

func main() {
	fmt.Println(removeSubfolders([]string{"/a", "/a/b", "/c/d", "/c/d/e", "/c/f"}))
}
func removeSubfolders(folder []string) []string {
	// 建树
	root := &TreeNode{path: "", child: make(map[string]*TreeNode)}
	root.BuildTree(folder)
	// 遍历树
	ans := make([]string, 0)
	var path strings.Builder
	dfs(root, &path, &ans)
	return ans
}

// p: slice是否扩容后，原传递的slice参数还能指向新地址？不会指向新地址。
func dfs(root *TreeNode, path *strings.Builder, ans *[]string) {
	if root.isEnd {
		*ans = append(*ans, path.String())
		return
	}
	for k, v := range root.child {
		s := path.String()

		path.WriteString(k)
		dfs(v, path, ans)
		path.Reset()
		path.WriteString(s)
	}

}

// 构建特定的树，遍历树，得到最后的有效路径。
type TreeNode struct {
	path  string               "文件路径"
	child map[string]*TreeNode "<文件路径，文件节点>"
	isEnd bool                 "最短文件路径截止处"
}

func (root *TreeNode) BuildTree(folder []string) {
	for _, f := range folder {
		root.Insert(f)
	}
}
func (root *TreeNode) Insert(f string) {
	// 按 "/xx"格式拆分f
	strs := getStrs(f)

	// 生成子树
	p := root
	for i := 0; i < len(strs); i++ {
		if _, ok := p.child[strs[i]]; !ok {
			t := &TreeNode{path: strs[i], child: make(map[string]*TreeNode)}
			p.child[strs[i]] = t
		}
		// 不用再插入了，已经有有效的父目录了。
		if p.child[strs[i]].isEnd {
			return
		}
		p = p.child[strs[i]]
	}
	p.isEnd = true
}
func getStrs(f string) []string {
	strs := make([]string, 0)
	last := 0
	for i := 1; i < len(f); i++ {
		if f[i] == '/' {
			strs = append(strs, f[last:i])
			last = i
		}
	}
	strs = append(strs, f[last:])

	return strs
}

总结

1）含字符串匹配相关问题，基于字典树来做，会大大提高效率，甚至解题关键。
2）go没有引用变量的概念，即使是一个结构体也属于全部内容的复制，注意指针变量的使用。
3）go为了并发安全，加入了no Copy机制，带指针属性的结构体，其方法都会做copyCheck，防止副本变量里的内容篡改，导致原变量的内容被非法篡改。

参考文献

[1] LeetCode 删除子文件夹