php:algoritma struktur pohon

Penulis：Eve Cole Waktu Pembaruan：2009-06-02 18:07:31

Diposting ulang oleh Joy Murakami, saya sudah membaca artikel ini sebelumnya dan dijelaskan dengan cukup jelas.
Kita akan menghadapi masalah ini di banyak tempat seperti klasifikasi produk, forum terstruktur pohon multi-level, milis, dll.: Bagaimana cara menyimpan data terstruktur multi-level?

Dalam aplikasi PHP, penyimpanan data backend biasanya berupa database relasional, yang dapat menyimpan data dalam jumlah besar dan menyediakan layanan pengambilan dan pembaruan data yang efisien. Namun, bentuk dasar data relasional adalah tabel bersilangan, yang merupakan struktur datar. Jika Anda ingin menyimpan struktur pohon bertingkat dalam database relasional, Anda perlu melakukan pekerjaan terjemahan yang wajar. Selanjutnya, saya akan berdiskusi dengan Anda apa yang telah saya lihat dan dengar serta beberapa pengalaman praktis.

Pada dasarnya ada dua metode desain umum untuk menyimpan data hierarki dalam database datar:

model daftar kedekatan
Algoritme traversal pohon preorder yang dimodifikasi
Saya bukan jurusan komputer, dan saya belum belajar apa pun tentang struktur data, jadi saya menerjemahkan kedua nama ini secara harfiah.

Kedua hal ini mungkin terdengar menakutkan, namun sebenarnya sangat mudah untuk dipahami. Di sini saya menggunakan direktori makanan sederhana sebagai contoh data kita. Struktur data kami seperti ini:

Makanan: Makanan
Buah: buah
Merah: merah
ceri: ceri
Kuning: kuning
Pisang:pisang
Daging: Daging
Daging sapi: daging sapi
Babi:

Model daftar ketetanggaan

babi

adalah model yang sering kita gunakan dan telah diperkenalkan di banyak tutorial dan buku. Kami menggambarkan seluruh struktur pohon melalui tabel datar dengan menambahkan atribut induk ke setiap node untuk mewakili node induk dari node ini. Berdasarkan prinsip ini, data dalam contoh dapat diubah menjadi tabel berikut:

Menampilkan pohon multi-level Jika kita perlu menampilkan struktur multi-level seperti itu, kita memerlukan fungsi rekursif.

<?php
// $parent adalah induk dari anak yang ingin kita lihat
// $level meningkat ketika kita masuk lebih jauh ke dalam pohon,
// digunakan untuk menampilkan fungsi pohon berindentasi yang bagus

display_children($parent, $level)
{
// Dapatkan semua node anak dari node induk $parent
$hasil = mysql_query('PILIH nama DARI pohon '.
'WHERE parent="'.$parent.'";');

// Menampilkan setiap node anak
while ($baris = mysql_fetch_array($hasil))
{
//Indentasi nama node
echo str_repeat(' ',$level).$row['name']."n";

//Panggil fungsi ini lagi untuk menampilkan node anak dari node anak

display_children($row['name'], $level+ 1);
}
}
?>
Menggunakan fungsi ini pada simpul akar (Makanan) dari seluruh struktur dapat mencetak seluruh struktur pohon bertingkat. Karena Makanan adalah simpul akar dan simpul induknya kosong, panggil: display_children('',0). akan menampilkan isi seluruh pohon:

Makanan
Buah
Merah
Ceri
Kuning
Pisang
Daging
Daging sapi
Babi
Jika Anda hanya ingin menampilkan sebagian dari keseluruhan struktur, seperti bagian buah, Anda dapat memanggilnya seperti ini:

display_children('Fruit',0);

Hampir menggunakan cara yang sama, kita dapat mengetahui jalur dari node akar ke node mana pun. Misalnya, jalur Cherry adalah "Makanan > Buah > Merah". Untuk mendapatkan jalur seperti itu, kita perlu memulai dari level terdalam "Cherry", melakukan kueri untuk mendapatkan simpul induknya "Merah" dan menambahkannya ke jalur, lalu kita menanyakan simpul induk Merah dan menambahkannya ke jalur. , dan seterusnya hingga level teratas "Makanan"

<?php
// $node adalah node terdalam
fungsi get_path($simpul)
{
// Kueri simpul induk dari simpul ini
$hasil = mysql_query('PILIH induk DARI pohon '.
'WHERE nama="'.$simpul.'";');
$row = mysql_fetch_array($result);

// Gunakan array untuk menyimpan jalur
$path = array();

// Jika bukan node root, lanjutkan query ke atas
// (Node root tidak memiliki node induk)
if ($baris['orang tua']!='')
{
// bagian terakhir dari path ke $node adalah namanya
// dari induk $node
$path[] = $row['parent'];

// kita harus menambahkan path ke induk node ini
// ke jalan
$jalur = array_merge(get_path($baris['orang tua']), $jalur);
}

// mengembalikan jalurnya
kembalikan $jalur;
}
?>
Jika Anda menggunakan fungsi ini untuk "Cherry": print_r(get_path('Cherry')), Anda akan mendapatkan array seperti ini:

Himpunan
(
[0] => Makanan
[1] => Buah
[2] => Merah
)
Cara mencetaknya ke format yang Anda inginkan terserah Anda.
Kekurangan: Cara ini sangat sederhana, mudah dipahami, dan mudah digunakan. Namun ada beberapa kelemahan. Terutama karena kecepatan larinya sangat lambat, karena setiap node memerlukan query database, dan ketika jumlah datanya besar, banyak query yang diperlukan untuk menyelesaikan sebuah pohon. Selain itu, karena kebutuhan akan operasi rekursif, setiap level rekursi perlu menempati sejumlah memori, sehingga efisiensi pemanfaatan ruang relatif rendah.

Sekarang mari kita lihat metode lain yang tidak menggunakan perhitungan rekursif dan lebih cepat. Ini adalah algoritma penjelajahan pohon preorder yang dimodifikasi. Anda mungkin memiliki lebih sedikit paparan terhadap metode ini, dan tidak seperti yang di atas saat Anda menggunakannya pertama kali. Metode ini mudah dipahami, tetapi karena metode ini tidak menggunakan algoritma kueri rekursif, maka efisiensi kuerinya lebih tinggi.

Pertama-tama kita menggambar data bertingkat di atas kertas dengan cara berikut, tulis 1 di sisi kiri simpul akar Makanan, lalu lanjutkan ke bawah pohon, tulis 2 di sisi kiri Buah, lalu lanjutkan menyusuri seluruh pohon . Tepi memberi label pada setiap simpul dengan nomor di kiri dan kanan. Angka terakhir adalah 18 yang ditandai di sebelah kanan Makanan. Pada gambar di bawah ini Anda dapat melihat keseluruhan struktur bertingkat yang ditandai dengan angka. (Tidak mengerti? Tunjuk angka tersebut dengan jari Anda dan hitung dari 1 sampai 18 dan Anda akan mengerti. Jika Anda masih belum mengerti, hitung lagi dan hati-hati menggerakkan jari Anda).
Angka-angka ini menunjukkan hubungan antara setiap node. Angka "Merah" adalah 3 dan 6, yang merupakan node turunan dari "Makanan" 1-18. Demikian pula, kita dapat melihat bahwa semua node dengan nilai kiri lebih besar dari 2 dan nilai kanan kurang dari 11 adalah keturunan dari "Buah" 2-11

Dengan cara ini, seluruh struktur pohon dapat disimpan dalam database melalui nilai kiri dan kanan. Sebelum melanjutkan, mari kita lihat tabel data kompilasi di bawah ini.

+------------+-----+-----+
|.nama |.rgt |
+------------+-----+-----+
|.Makanan |.1 |.18 |
|.Buah |.2 |.11 |
|.Merah |.3 |.6 |
|.ceri |.4 |.5 |
|.kuning |.7 |.10 |
|.Pisang |.8 |.9 |
|.Daging |.12 |.17 |
|.Daging Sapi |.13 |.14 |
|.Babi |.15 |.16 |
+------------+-----+-----+
Oke, sekarang kita bisa mendapatkan data dari database. Misalnya, jika kita ingin mendapatkan semua node di bawah item "Buah", kita bisa menulis pernyataan query seperti ini: SELECT * FROM tree WHERE lft BETWEEN 2 AND 11 This kueri mendapat hasil sebagai berikut.

+------------+-----+-----+
|.nama |.rgt |
+------------+-----+-----+
|.Buah |.2 |.11 |
|.Merah |.3 |.6 |
|.ceri |.4 |.5 |
|.kuning |.7 |.10 |
|.Pisang |.8 |.9 |
+------------+-----+-----+
Lihat, Anda bisa mendapatkan semua node ini hanya dengan satu permintaan. Untuk dapat menampilkan keseluruhan struktur pohon seperti fungsi rekursif di atas, kita juga perlu mengurutkan query tersebut. Urutkan berdasarkan nilai simpul:

SELECT * FROM tree WHERE lft BETWEEN 2 AND 11 ORDER BY lft ASC;
Pertanyaan yang tersisa adalah bagaimana menampilkan indentasi hierarki.

<?php
fungsi tampilan_pohon($root)
{
//Dapatkan nilai kiri dan kanan dari simpul akar
$hasil = mysql_query('PILIH lft, rgt DARI pohon '.'WHERE name="'.$root.'";');
$row = mysql_fetch_array($result);

// Siapkan tumpukan nilai kosong
$right = array();

// Dapatkan semua node turunan dari titik akar
$hasil = mysql_query('PILIH nama, lft, rgt DARI pohon '.
'DIMANA lft ANTARA '.$row['lft'].'
$row['rgt'].' ORDER BY lft ASC;');

// Tampilkan setiap baris
while ($baris = mysql_fetch_array($hasil))
{
// hanya periksa tumpukan jika ada
jika (hitung($kanan)>0)
{
// Periksa apakah kita harus memindahkan node dari tumpukan
while ($kanan[hitung($kanan)-1]<$baris['rgt'])
{
array_pop($kanan);
}
}

// Indentasi nama node.

echo str_repeat(' ',count($right))

$row['name']."n";

$kanan[] = $baris['rgt'];
}
}
?>
Jika Anda menjalankan fungsi di atas, Anda akan mendapatkan hasil yang sama seperti fungsi rekursif. Hanya saja fungsi baru kita mungkin lebih cepat karena hanya ada 2 query database. Lebih mudah untuk mengetahui jalur suatu node. Jika kita ingin mengetahui jalur Cherry, kita menggunakan nilai kiri dan kanannya 4 dan 5 untuk membuat query.

PILIH nama DARI pohon DIMANA lft < 4 DAN rgt > 5 DIPESAN BERDASARkan lft ASC;
Ini akan memberi Anda hasil berikut:

+-+
|.nama |
+-+
|.Makanan |
|.Buah |
|.Merah |
+-+
Jadi, berapa banyak node turunan yang dimiliki node tertentu? Caranya sangat mudah, jumlah keturunan = (nilai r - nilai kiri - 1)/2 keturunan = (kanan - kiri - 1) / 2 Tidak percaya? Hitung sendiri. Dengan menggunakan rumus sederhana ini, kita dapat dengan cepat menghitung bahwa node "Buah 2-11" memiliki 4 node turunan, sedangkan node "Pisang 8-9" tidak memiliki node turunan, yang berarti bukan node induk.
Luar biasa, bukan? Meski saya sudah menggunakan cara ini berkali-kali, tetap saja terasa luar biasa setiap kali saya melakukannya.

Ini memang metode yang bagus, tetapi adakah cara untuk membantu kita membuat tabel data dengan nilai kiri dan kanan? Berikut adalah fungsi lain yang akan diperkenalkan kepada Anda. Fungsi ini dapat secara otomatis mengubah tabel dengan nama dan struktur induk menjadi tabel data dengan nilai kiri dan kanan.

<?php
fungsi membangun kembali_pohon($induk, $kiri) {
//nilai kanan dari node ini adalah nilai kiri +1
$kanan = $kiri+1;

// dapatkan semua anak dari simpul ini
$hasil = mysql_query('PILIH nama DARI pohon '.
'WHERE parent="'.$parent.'";');
while ($baris = mysql_fetch_array($hasil)) {
// eksekusi rekursif dari fungsi ini untuk masing-masing
// anak dari node ini
// $right adalah nilai kanan saat ini, yaitu
// bertambah dengan fungsi rebuild_tree
$kanan = membangun kembali_pohon($baris['nama'], $kanan);
}

// kita sudah mendapat nilai tersisa, dan sekarang kita sudah memprosesnya
// anak dari node ini kita juga mengetahui nilai yang benar
mysql_query('UPDATE pohon SET lft='.$kiri.', rgt='.
$right.' WHERE name="'.$parent.'";');

// mengembalikan nilai yang benar dari node ini + 1
kembalikan $kanan+1;
}
?>
Tentu saja, fungsi ini adalah fungsi rekursif. Kita perlu menjalankan fungsi ini dari node akar untuk membangun kembali pohon dengan nilai kiri dan kanan

rebuild_tree('Food',1);
Fungsi ini terlihat agak rumit, namun fungsinya sama dengan penomoran tabel secara manual, yaitu mengubah struktur multilayer tiga dimensi menjadi tabel data dengan nilai kiri dan kanan.

Jadi bagaimana kita menambah, memperbarui dan menghapus node untuk struktur seperti itu? Biasanya ada dua cara untuk menambahkan node:

mempertahankan nama asli dan struktur induk, menggunakan metode lama untuk menambahkan data ke data, dan menggunakan fungsi rebuild_tree untuk memberi nomor ulang seluruh struktur setelah setiap bagian data ditambahkan.
Pendekatan yang lebih efisien adalah dengan mengubah semua nilai di sebelah kanan node baru. Misalnya: kita ingin menambahkan buah baru "Strawberry" yang akan menjadi node anak terakhir dari node "Merah". Pertama kita perlu menyediakan ruang untuk itu. Nilai kanan "Merah" harus diubah dari 6 menjadi 8, dan nilai kiri dan kanan "Kuning 7-10" harus diubah menjadi 9-12. Dengan analogi, kita dapat mengetahui bahwa jika Anda ingin memberikan ruang untuk nilai baru, Anda perlu menambahkan 2 ke semua node dengan nilai kiri dan kanan lebih besar dari 5 (5 adalah nilai kanan dari node anak terakhir "Merah" ). Jadi kita melakukan operasi database seperti ini:

UPDATE tree SET rgt=rgt+2 WHERE rgt>5;
PERBARUI pohon SET lft=lft+2 WHERE lft>5;
Ini mengosongkan ruang untuk nilai yang baru dimasukkan. Sekarang Anda dapat membuat node data baru di ruang kosong. Nilai kiri dan kanannya masing-masing adalah 6 dan 7.

INSERT INTO tree SET lft=6, rgt=7, name = 'Strawberry';

Ayo lakukan pertanyaan lain dan lihat! Bagaimana dengan itu? Segera.
Oke, sekarang Anda dapat mendesain struktur database multi-level Anda dengan dua cara berbeda. Metode mana yang Anda gunakan sepenuhnya bergantung pada penilaian pribadi Anda, tetapi untuk struktur dengan banyak level dan jumlah yang besar, saya lebih memilih metode kedua. Cara pertama lebih mudah jika volume kueri kecil tetapi data perlu sering ditambahkan dan diperbarui.

Selain itu, jika database mendukungnya, Anda juga dapat menulis rebuild_tree() dan operasi pembebasan ruang sebagai fungsi pemicu di sisi database, dan menjalankannya secara otomatis selama penyisipan dan pembaruan. Hal ini dapat mencapai efisiensi pengoperasian yang lebih baik, dan Anda bisa menambahkan node baru. Pernyataan SQL akan menjadi lebih sederhana.
Metode rekursif kelas
Diposting oleh tamu pada tahun 2004, 31 Mei - 09:18.
Saya menulis sebuah program menggunakan metode kuasi-rekursif, yang tidak persis sama dengan rekursi di artikel, dan saya bersiap untuk memindahkannya ke xoops:
http://dev.xoops.org/modules/xfmod/project/?ulink

mengalami memory overflow, namun saya berencana untuk terus menggunakan metode rekursif. Saya hanya perlu terus

meningkatkannya cm bersamamu.
» balas komentar ini
Atau perbandingan kedua metode tersebut?
Diposting oleh tamu pada tahun 2004, 17 Maret - 20:30.
Saya mempelajari artikel ini dengan cermat dan merasa sangat bermanfaat, tetapi kemudian saya memikirkannya lagi dan merasa ada masalah (demi ingatan, saya menyebut mode direktori yang berdekatan sebagai metode rekursif, dan traversal pra-sortir algoritma pohon Saya menyebutnya metode pohon pra-penyortiran):

1. Perbedaan terbesar antara kedua metode adalah bahwa rekursi memerlukan penggunaan tumpukan saat melakukan kueri, sedangkan pohon pra-penyortiran memerlukan setengah dari node (mengacu pada paruh kedua dari node yang dimasukkan) saat memperbarui node pembaruan. Meskipun Anda juga mengatakan bahwa jika ada banyak node dan sering diperbarui, efisiensi pohon yang diurutkan sebelumnya akan berkurang, dan rekursi akan lebih baik. Jika ada banyak level node, pertama-tama, rekursi akan menyebabkan stack overflow, dan lebih jauh lagi, rekursi itu sendiri tidak terlalu efisien, ditambah lagi setiap level rekursi memerlukan pengoperasian database, efek keseluruhannya tidak akan ideal. Pendekatan saya saat ini adalah mengambil semua data sekaligus, dan kemudian melakukan operasi rekursif pada array, yang akan lebih baik jika dapat ditingkatkan lebih lanjut, node root ROOT dapat ditambahkan ke setiap baris catatan (saat ini, saja node induk yang berdekatan dicatat), sehingga efisiensi saat mencari pohon cabang akan lebih tinggi, dan juga akan sangat nyaman saat memperbarui pohon, yang seharusnya menjadi cara yang lebih baik.

2. Meningkatkan metode rekursif. Dalam artikel tersebut, saat menghitung nilai kiri dan kanan dari node pohon yang telah diurutkan sebelumnya, metode traversal sebenarnya digunakan. Tumpukan diganti dengan array, dan push dan pop diimplementasikan secara manual; jika metode ini direferensikan dalam algoritma rekursif, jika Anda menggunakan array alih-alih tumpukan saat melakukan rekursi, Anda juga dapat meningkatkan efisiensi rekursi.

3. Konkurensi. Jika konkurensi diperhitungkan, terutama saat memperbarui pohon, metode memperbarui informasi node di area yang luas dari pohon yang telah diurutkan sebelumnya memerlukan perhatian ekstra pada penggunaan mekanisme penguncian dan transaksi untuk memastikannya. konsistensi data.

4. Dalam kasus beberapa node akar atau beberapa node induk, dalam hal ini, jelas bukan pohon biner standar atau pohon multi-fork. Algoritma pohon yang telah diurutkan sebelumnya perlu ditingkatkan untuk beradaptasi, dan metode rekursif diterapkan secara bebas, jadi dalam hal ini, rekursi lebih mudah beradaptasi. Hal ini tentu saja karena metode rekursif merupakan salah satu bentuk linked list. Pohon dan grafik dapat diekspresikan dengan linked list, dan tentunya sangat mudah beradaptasi.

5. Intuitif. Jika Anda mengamati langsung data yang disimpan dalam database tanpa pengoperasian program, terlihat jelas bahwa data yang disimpan dalam mode rekursif lebih intuitif, sedangkan data pada pohon yang telah diurutkan sebelumnya sulit dibaca secara langsung (untuk hierarkis). hubungan). Hal ini penting dalam pertukaran data.

Secara umum, saya pribadi lebih suka menggunakan metode rekursif, tetapi saya selalu khawatir tentang dampak rekursi terhadap efisiensi. Untungnya, saya belum terpapar pada level klasifikasi skala besar. Menggunakan array daripada tumpukan secara rekursif akan menjadi peningkatan yang lebih baik metode. Pohon yang telah disortir sebelumnya adalah metode yang efisien untuk menyelesaikan pohon sederhana. Setelah Anda terbiasa, ini akan menjadi sangat baik, terutama pencarian terbalik dari simpul daun ke simpul akar sangat mudah.

serigala
www.fwolf.com
» balas komentar ini
Sangat senang melihat balasan Anda
Diposting oleh shuke pada 2004, 18 Maret - 5:47 pagi.
Saya sangat senang Anda membaca artikel ini dengan cermat. Artikel ini sebenarnya awalnya diterbitkan di sitepoint.com Saya menerjemahkannya, berharap dapat memperkenalkan beberapa metode kepada teman-teman yang ingin memulai. Metode Anda juga sangat bagus, saya akan mencobanya jika ada kesempatan. (Jika Anda tertarik, mengapa tidak menulis metode dan kode implementasi spesifik Anda sebagai tutorial berdasarkan contoh di atas, sehingga semua orang dapat menirunya dengan contoh yang lebih praktis) Jika Anda memiliki pertanyaan tentang menyimpan struktur multi-level di database Jika Anda tertarik dengan penelitian, berikut dua link bagus lainnya yang bisa dijadikan referensi:
Memperkenalkan empat metode umum skrip kueri satu kali dan pengurutan array. Saya pikir skrip Anda harus lebih baik dari ini.
Selain itu, saya melihat Anda juga menggunakan drupal, ia juga memiliki fitur lanjutan yang disebut sistem otentikasi pengguna terdistribusi. Selama Anda mendaftar di situs drupal mana pun, Anda dapat masuk untuk mengakses situs drupal lainnya. Cukup menarik.
Semoga sukses!
» balas komentar ini
Membangun pohon menggunakan loop telah diterapkan
Diposting oleh tamu pada tahun 2004, 25 Maret - 22:10.
Saya sudah membaca semua informasi yang Anda berikan terakhir kali, tapi sejujurnya, tidak banyak hal baru di artikel pertama. Mungkin saya kurang memahaminya. Artikel kedua sebenarnya ditulis dalam PHP3, dan struktur programnya tidak detail. Lihat, terlalu banyak fungsi persimpangan yang digunakan.
Kebetulan saya perlu menggunakan peran pengguna hierarkis dalam suatu sistem, jadi saya menuliskan traversal berdasarkan ide array. Saya tidak punya waktu untuk memilahnya, jadi saya akan menaruhnya di sini untuk Anda lihat. Basis datanya adalah ADODB, dan program ini diekstraksi langsung dari sistem. Saya harap ini dapat dijelaskan dengan jelas. Ini terutama menggunakan operasi array PHP yang kuat dan menggunakan loop untuk melakukan rekursi. Metode komentarnya serupa, tetapi waktu pemrosesan hasilnya berbeda.

<?php
/**
* Tampilkan daftar
* @akses publik
*/
fungsi DaftarTampilan()
{
//Mode tampilan tanpa lekukan
// $ini->mIsDispListIndex = benar;
// echo('<a href="?action=new&part=role">Tambahkan peran baru</a> '); ">Tambahkan peran baru</a> ');"
//
// $this->mListTitle = 'Daftar peran pengguna';
// $ini->SetDataOption('daftar');
//
// $ini->SetQueryTable( array($ini->mTableUserRole) );
//
// //Urutan kueri
// $ini->SetQueryOrder( 'asc', $ini->mTableUserRole, 'urutan' );
//
// $ini->Kueri('daftar');
// parent::DispList();

// //Metode tampilan lain, menggunakan array sebagai tumpukan, A: Simpan peran saat mendorong tumpukan, dan menghapus sumber setelah mendorong.
// $ini->PeriksaProperti('mrDb');
// $ini->PeriksaProperti('mrSql');
// $ini->mrSql->Pilih('peran, jabatan, induk');
// $ini->mrSql->Dari($ini->mTableUserRole);
// $ini->mrSql->Orderby('induk, urutan');
// $ini->mRs = $ini->mrDb->Eksekusi($ini->mrSql->Sql());
// jika (0 < hitungan($ini->mRs))
// {
// $source = & $this->mRs->GetArray(); //Indeks numerik
// $tumpukan = larik(''); //tumpukan
// $stacki = array(-1); //Sesuai dengan tumpukan, mencatat level data dalam tumpukan di pohon
// $target = susunan();
// sementara (0 < hitungan($tumpukan))
// {
// $barang = array_shift($tumpukan);
// $lev = array_shift($stacki);
// jika (!kosong($item))
// {
// //Masukkan data yang telah diproses ke dalam array target di sini
// array_push($target, str_repeat(' ', $lev) .$item);
// //$s1 = str_repeat(' ', $lev) $item;
// }
// $del = array(); //Node yang akan dihapus dari $source
// $ar = array(); //Node yang perlu ditambahkan ke tumpukan
// foreach ($sumber sebagai $key=>$val)
// {
// //Menemukan node anak yang cocok
// jika (kosong($item))
// {
// $temukan = kosong($sumber[$kunci]['orang tua']);
// }
//kalau tidak
// {
// $temukan = ($item == $sumber[$kunci]['induk']);
// }
// jika ($temukan)
// {
// array_unshift($ar, $source[$key]['peran']);
// $del[] = $kunci;
// }
// }
// foreach ($ar sebagai $val)
// {
//array_unshift($tumpukan, $val);
//array_unshift($stacki, $lev + 1);
// }
// foreach ($del sebagai $val)
// {
// tidak disetel($sumber[$val]);
// }
// echo(implode(', ', $stack) . ' ' . implode(', ', $stacki) . ' ' . implode(', ', $target) . ' ');
// }
//debug_array();
// }
//kalau tidak
// {
// echo('<center>Tidak ada data yang diambil</center>');
// }

//Metode tampilan lain, menggunakan array sebagai tumpukan, B: Simpan indeks array saat mendorong tumpukan, keluarkan dari tumpukan, lalu hapus sumbernya setelah digunakan.
$ini->PeriksaProperti('mrDb');
$ini->PeriksaProperti('mrSql');
$this->mrSql->Select('role, title, parent');
$ini->mrSql->Dari($ini->mTableUserRole);
$ini->mrSql->Orderby('induk, urutan');
$ini->mRs = $ini->mrDb->Eksekusi($ini->mrSql->Sql());
jika (!kosong($ini->mRs) && !$ini->mRs->EOF)
{
$source = & $this->mRs->GetArray(); //indeks numerik
$tumpukan = larik(-1); //tumpukan
$stacki = array(-1); //Sesuai dengan tumpukan, mencatat level data dalam tumpukan di pohon
$target = susunan();
sementara (0 <hitung($tumpukan))
{
$item = array_shift($tumpukan);
$lev = array_shift($stacki);
jika (-1 != $barang)
{
//Masukkan data yang telah diproses ke dalam array target di sini
$s1 = str_repeat(' ', $lev) . '<a href="?action=disp&part=role&role=' . $source[$item]['role'] . '">' . ['judul'] .'</a>';
$s2 = '<a href="?action=edit&part=role&role=' . $source[$item]['role'] . '">Edit</a> <a href="?action=delete&part=role&role= ' . $source[$item]['role'] . '">Hapus</a>';
array_push($target, array($s1, $s2));
}
$del = array(); //Node yang akan dihapus dari $source
$ar = array(); //Node yang perlu ditambahkan ke tumpukan
foreach ($sumber sebagai $key=>$val)
{
//Temukan node anak yang cocok
jika (-1 == $barang)
{
$temukan = kosong($sumber[$kunci]['orang tua']);
}
kalau tidak
{
$find = ($source[$item]['role'] == $source[$key]['parent']);
}
jika($temukan)
{
array_unshift($ar, $kunci);
}
}
foreach ($ar sebagai $val)
{
array_unshift($tumpukan, $val);
array_unshift($stacki, $lev + 1);
}
//Hapus dari sumber
tidak disetel($sumber[$item]);
//echo(implode(', ', $stack) . ' ' . implode(', ', $stacki) . ' ' . implode(', ', $target) . ' ');
}
//Keluaran
echo('<a href="?action=new&part=role">Tambahkan peran baru</a> ');
array_unshift($target, array('peran', 'operasi'));
$ini->PeriksaProperti('mrLt');
$ini->mrLt->SetData($target);
$this->mrLt->mListTitle = 'Daftar peran pengguna';
$ini->mrLt->mIsDispIndex = salah;
$ini->mrLt->Tampilan();
}
kalau tidak
{
echo('<center>Tidak ada data yang diambil</center>');
}
} // akhir fungsi DispList
?>