Bagaimana untuk membina struktur seperti pokok dengan cekap daripada pelbagai rentetan laluan yang mewakili hierarki sistem fail?

Cara Membina Struktur Seperti Pokok daripada Tatasusunan Rentetan Laluan

Pengenalan:
Diberikan tatasusunan rentetan yang mewakili laluan fail, kami berhasrat untuk membina struktur data seperti pepohon yang mencerminkan hierarki direktori. Setiap rentetan dalam tatasusunan mewakili laluan lengkap daripada direktori akar ke fail atau direktori tertentu.

Pendekatan Rekursif dengan Senarai Anak:
Untuk membina pepohon secara rekursif, kita perlu melintasi rentetan laluan dari kiri ke kanan, membahagikannya kepada komponen. Kita boleh mewakili pepohon menggunakan struct Nod dengan nama dan sekeping nod anak.

<code class="go">type Node struct {
    Name     string
    Children []Node
}</code>

Cerapan utama adalah untuk beroperasi pada senarai nod dan bukannya anak-anak satu nod. Ini membolehkan kami mengendalikan berbilang pokok dengan nod akar yang berbeza.

<code class="go">func AddToTree(root []Node, names []string) []Node {
    if len(names) > 0 {
        var i int
        for i = 0; i < len(root); i++ {
            if root[i].Name == names[0] { //already in tree
                break
            }
        }
        if i == len(root) {
            root = append(root, Node{Name: names[0]})
        }
        root[i].Children = AddToTree(root[i].Children, names[1:])
    }
    return root
}</code>

1. Semak sama ada komponen pertama (nama[0]) wujud dalam senarai nod semasa (root).
2. Jika tidak, tambahkan nod dengan nama ini pada senarai.
3. Panggil AddToTree secara rekursif pada senarai yang dikemas kini, melepasi komponen laluan yang tinggal.

Contoh :
Untuk rentetan laluan input:

<code class="go">s := [...]string{"a/b/c", "a/b/g", "a/d"}</code>

Fungsi AddToTree menghasilkan struktur pokok berikut:

<code class="json">{
 "name": "a",
 "children": [
     {
      "name": "b",
      "children": [
        {
         "name": "c"
        },
        {
         "name": "g"
        }
      ]
    },
    {
     "name": "d",
     "children": []
    }
  ]
}</code>

Kelebihan Berbanding Pendekatan Asal:

1. Beroperasi pada senarai nod, membenarkan berbilang pokok dengan nod akar yang berbeza.
2. Mencipta nod baharu dan bukannya menggunakan semula nod input, memastikan setiap peringkat pokok adalah berbeza.
3. Mencari pokok untuk mengelakkan pertindihan nod.

Atas ialah kandungan terperinci Bagaimana untuk membina struktur seperti pokok dengan cekap daripada pelbagai rentetan laluan yang mewakili hierarki sistem fail?. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!