Hampir setiap proyek yang memiliki beberapa model atau dokumen yang dapat diedit akan memiliki struktur hierarki. Dapat berguna untuk mengimplementasikan 'simpul hierarkis' sebagai kelas dasar untuk entitas yang berbeda. Seringkali daftar terkait (child sibling, model 2) adalah cara alami banyak perpustakaan kelas tumbuh, namun anak-anak mungkin dari berbagai jenis, dan mungkin " model objek " bukan apa yang kita pertimbangkan ketika berbicara tentang pohon pada umumnya.
Implementasi favorit saya dari pohon (simpul) dari model pertama Anda adalah satu-liner (dalam C #):
public class node : List<node> { /* props go here */ }
Mewarisi dari Daftar generik dari tipe Anda sendiri (atau mewarisi dari kumpulan generik lain dari tipe Anda sendiri). Berjalan dimungkinkan dalam satu arah: bentuk root ke bawah (item tidak mengenal orang tua mereka).
Hanya pohon induk
Model lain yang tidak Anda sebutkan adalah model di mana setiap anak memiliki referensi ke orang tua itu:
null
|
+---------+---------------------------------+
| parent |
| root |
+-------------------------------------------+
| | |
+---------+------+ +-------+--------+ +--+-------------+
| parent | | parent | | parent |
| node 1 | | node 2 | | node 3 |
+----------------+ +----------------+ +----------------+
Berjalan pohon ini hanya mungkin sebaliknya, biasanya semua node ini akan disimpan dalam koleksi (array, hashtable, kamus dll.) Dan sebuah node akan ditemukan dengan mencari koleksi pada kriteria selain posisi hirarkis di pohon yang biasanya tidak terlalu penting.
Pohon induk saja ini biasanya terlihat dalam aplikasi basis data. Sangat mudah untuk menemukan anak-anak dari simpul dengan pernyataan "SELECT * WHERE ParentId = x". Namun kami jarang menemukan ini berubah menjadi objek kelas pohon-simpul seperti itu. Dalam aplikasi statefull (desktop) mereka dapat dibungkus ke dalam kontrol simpul pohon yang ada. Dalam aplikasi stateless (web) bahkan itu mungkin tidak mungkin. Saya telah melihat alat-alat kelas-generator pemetaan ORM melempar kesalahan stack overflow ketika membuat kelas untuk tabel yang memiliki hubungan dengan diri mereka sendiri (terkekeh), jadi mungkin pohon ini tidak begitu umum.
pohon dinavigasi dua arah
Namun dalam kebanyakan kasus praktis, nyaman untuk memiliki yang terbaik dari kedua dunia. Node yang memiliki daftar anak-anak dan selain itu mengenal orang tuanya: pohon dua arah yang dapat dinavigasi.
null
|
+--------------------+--------------------+
| parent |
| root |
| child1 child2 child3 |
+--+------------------+----------------+--+
| | |
+---------+-----+ +-------+-------+ +---+-----------+
| parent | | parent | | parent |
| node1 | | node2 | | node3 |
| child1 child2 | | child1 child2 | | child1 child2 |
+--+---------+--+ +--+---------+--+ +--+---------+--+
| | | | | |
Ini membawa lebih banyak aspek untuk dipertimbangkan:
- Di mana harus menerapkan penautan dan pembatalan tautan induk?
- biarkan logika bisnis berhati-hati, dan biarkan aspek keluar dari simpul (mereka akan lupa!)
- Node memiliki metode untuk membuat anak-anak (tidak memungkinkan pemesanan ulang) (pilihan Microsoft dalam implementasi DOM System.Xml.XmlDocument mereka, yang hampir membuat saya gila ketika saya pertama kali menemukannya)
- Node mengambil induk di konstruktornya (tidak mengizinkan pemesanan ulang)
- di semua add (), masukkan () dan hapus () metode dan kelebihan node mereka (biasanya pilihan saya)
- Ketekunan
- Cara berjalan di pohon saat bertahan (misalkan tautan orangtua)
- Cara membangun kembali penghubung dua arah setelah penghilangan bersambung (mengatur semua orang tua lagi sebagai tindakan pasca deserialisasi)
- Notifikasi
- Mekanisme statis (bendera IsDirty), menangani properti secara rekursif?
- Peristiwa, menggelembung melalui orang tua, turun melalui anak-anak, atau keduanya (pertimbangkan pompa pesan windows misalnya).
Sekarang untuk menjawab pertanyaan , pohon dua arah yang dapat dinavigasi cenderung (dalam karir dan bidang saya sejauh ini) yang paling banyak digunakan. Contohnya adalah implementasi Microsoft dari System.Windows.Forms.Control, atau System.Web.UI.Control dalam kerangka .Net, tetapi juga setiap implementasi DOM (Document Object Model) akan memiliki node yang mengetahui orang tua mereka serta enumerasi anak-anak mereka. Alasannya: kemudahan penggunaan lebih dari kemudahan implementasi. Juga, ini biasanya kelas dasar untuk kelas yang lebih spesifik (XmlNode mungkin basis Tag, Atribut, dan kelas Teks) dan kelas dasar ini adalah tempat alami untuk meletakkan serialisasi umum dan arsitektur penanganan peristiwa.
Tree terletak di jantung banyak arsitektur, dan mampu bernavigasi secara bebas berarti mampu mengimplementasikan solusi lebih cepat.